fujaba/NetworkParser

View on GitHub

Showing 3,691 of 4,645 total issues

Method getEntity has a Cognitive Complexity of 90 (exceeds 5 allowed). Consider refactoring.
Open

    public Object getEntity(ByteBuffer buffer, BitEntity entry, SimpleKeyValueList<String, Object> values) {
        if (entry == null) {
            return null;
        }
        if (entry.size() < 1) {
Severity: Minor
Found in src/main/java/de/uniks/networkparser/bytes/ByteParser.java - About 1 day to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Method calculateFields has a Cognitive Complexity of 90 (exceeds 5 allowed). Consider refactoring.
Open

    public Double[] calculateFields(String formular) {
        CharacterBuffer tokener = new CharacterBuffer();
        tokener.with(formular);

        ArrayList<String> parts = new ArrayList<String>();
Severity: Minor
Found in src/main/java/de/uniks/networkparser/calculator/RegCalculator.java - About 1 day to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

File RabbitMessage.java has 766 lines of code (exceeds 250 allowed). Consider refactoring.
Open

package de.uniks.networkparser.ext.io;

/*
The MIT License

Severity: Major
Found in src/main/java/de/uniks/networkparser/ext/io/RabbitMessage.java - About 1 day to fix

    File GraphTest.java has 758 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    package de.uniks.networkparser.test;
    
    import static org.junit.Assert.assertEquals;
    import java.io.BufferedWriter;
    import java.io.File;
    Severity: Major
    Found in src/test/java/de/uniks/networkparser/test/GraphTest.java - About 1 day to fix

      Space has 92 methods (exceeds 20 allowed). Consider refactoring.
      Open

      public class Space extends SendableItem implements ObjectCondition, SendableEntityCreator {
          private final String[] properties = new String[] { Space.PROPERTY_NAME, Space.PROPERTY_PATH, Space.PROPERTY_HISTORY,
                  Space.PROPERTY_PROXY };
          public static final String PROPERTY_MODELROOT = "root";
          public static final String PROPERTY_HISTORY = "history";
      Severity: Major
      Found in src/main/java/de/uniks/networkparser/ext/petaf/Space.java - About 1 day to fix

        Function ./layouts/DagreLayoutMin.ts has 350 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        /***/ (function(module, exports, __webpack_require__) {
        
        "use strict";
        
        Object.defineProperty(exports, "__esModule", { value: true });
        Severity: Major
        Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

          Method addI18N has a Cognitive Complexity of 87 (exceeds 5 allowed). Consider refactoring.
          Open

              private boolean addI18N(Object root, TextItems i18n, SimpleSet<Object> items, String key, List<?> subElements) {
                  if (items == null || i18n == null || items.add(root) == false) {
                      return false;
                  }
                  SendableEntityCreator creator = this.getCreatorClass(root);
          Severity: Minor
          Found in src/main/java/de/uniks/networkparser/IdMap.java - About 1 day to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          File JsonTest.java has 746 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          package de.uniks.networkparser.test;
          
          import static org.junit.Assert.assertEquals;
          import static org.junit.Assert.assertNotNull;
          import static org.junit.Assert.assertTrue;
          Severity: Major
          Found in src/test/java/de/uniks/networkparser/test/JsonTest.java - About 1 day to fix

            Method compareEntity has a Cognitive Complexity of 85 (exceeds 5 allowed). Consider refactoring.
            Open

                public static final boolean compareEntity(Object entityA, Object entityB, TextDiff diffList, BaseItem sameObject) {
                    if (sameObject == null) {
                        if (entityA instanceof Entity) {
                            sameObject = ((BaseItem) entityA).getNewList(true);
                        } else if (entityB instanceof Entity) {
            Severity: Minor
            Found in src/main/java/de/uniks/networkparser/EntityUtil.java - About 1 day to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function ./PropertiesPanel.ts has a Cognitive Complexity of 85 (exceeds 5 allowed). Consider refactoring.
            Open

            /***/ (function(module, exports, __webpack_require__) {
            
            "use strict";
            
            var __extends = (this && this.__extends) || (function () {
            Severity: Minor
            Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function ./handlers/ImportFile.ts has a Cognitive Complexity of 84 (exceeds 5 allowed). Consider refactoring.
            Open

            /***/ (function(module, exports, __webpack_require__) {
            
            "use strict";
            
            Object.defineProperty(exports, "__esModule", { value: true });
            Severity: Minor
            Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function ./elements/nodes/InfoText.ts has a Cognitive Complexity of 84 (exceeds 5 allowed). Consider refactoring.
            Open

            /***/ (function(module, exports, __webpack_require__) {
            
            "use strict";
            
            var __extends = (this && this.__extends) || (function () {
            Severity: Minor
            Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            IdMap has 88 methods (exceeds 20 allowed). Consider refactoring.
            Open

            public class IdMap implements BaseItem, Iterable<SendableEntityCreator>, SendableEntityCreator {
                /** The Constant VALUE. */
                public static final String VALUE = "value";
            
                /** The Constant ID. */
            Severity: Major
            Found in src/main/java/de/uniks/networkparser/IdMap.java - About 1 day to fix

              Function Bridge has 332 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              var Bridge = (function (_super) {
                  __extends(Bridge, _super);
                  function Bridge(viewRoot) {
                      var _this = _super.call(this) || this;
                      _this.controlFactory = {};
              Severity: Major
              Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

                Method setValueItem has a Cognitive Complexity of 83 (exceeds 5 allowed). Consider refactoring.
                Open

                    @SuppressWarnings("unchecked")
                    public SimpleKeyValueList<K, V> setValueItem(Object key, Object value) {
                        int pos = indexOf(key);
                        if (pos >= 0) {
                            this.setValue(pos, (V) value);
                Severity: Minor
                Found in src/main/java/de/uniks/networkparser/list/SimpleKeyValueList.java - About 1 day to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function ./PropertiesPanel.ts has 330 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                /***/ (function(module, exports, __webpack_require__) {
                
                "use strict";
                
                var __extends = (this && this.__extends) || (function () {
                Severity: Major
                Found in src/main/resources/de/uniks/networkparser/graph/diagram.js - About 1 day to fix

                  Method getCloneByEntity has a Cognitive Complexity of 82 (exceeds 5 allowed). Consider refactoring.
                  Open

                      private Object getCloneByEntity(Object reference, MapEntity map) {
                          if (map == null || map.contains(reference)) {
                              return null;
                          }
                          SendableEntityCreator creator = getCreatorClass(reference);
                  Severity: Minor
                  Found in src/main/java/de/uniks/networkparser/IdMap.java - About 1 day to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  Method parseSheet has a Cognitive Complexity of 82 (exceeds 5 allowed). Consider refactoring.
                  Open

                      public ExcelSheet parseSheet(CharSequence stringFile, CharSequence sheetFile) {
                          ExcelSheet data = new ExcelSheet();
                          SimpleKeyValueList<String, ExcelCell> cells = new SimpleKeyValueList<String, ExcelCell>();
                          SimpleKeyValueList<String, String> mergeCellPos = new SimpleKeyValueList<String, String>();
                  
                  
                  Severity: Minor
                  Found in src/main/java/de/uniks/networkparser/parser/ExcelParser.java - About 1 day to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  Method diffModel has a Cognitive Complexity of 82 (exceeds 5 allowed). Consider refactoring.
                  Open

                      public GraphPatternMatch diffModel(Object master, Object slave, MapEntity map) {
                          if (map == null || map.add(master) == false) {
                              return null;
                          }
                          GraphPatternMatch result = new GraphPatternMatch();
                  Severity: Minor
                  Found in src/main/java/de/uniks/networkparser/graph/GraphTokener.java - About 1 day to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  File NodeProxyTCP.java has 706 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  package de.uniks.networkparser.ext.petaf.proxy;
                  
                  /*
                  The MIT License
                  
                  
                    Severity
                    Category
                    Status
                    Source
                    Language