Sign upLogin

SiLeBAT/FSK-Lab

View on GitHub
Star

Showing 6,856 of 14,752 total issues

Method initComponents has 574 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    @SuppressWarnings({"serial"})
    private void initComponents() {
        // JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
        // Generated using JFormDesigner non-commercial license
        panel3 = new JPanel();
Severity: Major
Found in de.bund.bfr.knime.foodprocess/src/de/bund/bfr/knime/foodprocess/ui/FoodProcessUi.java - About 2 days to fix

Method readFskPortObject has a Cognitive Complexity of 141 (exceeds 5 allowed). Consider refactoring.
Open

  private FskPortObject readFskPortObject(CombineArchive archive, List<String> ListOfPaths,
      int readLevel, File currentWorkingDirectory) throws Exception {
    Map<String, URI> URIS = FSKML.getURIS(1, 0, 12);
    // each sub Model has it's own working directory to avoid resource conflict.
    // get current node's and workflow's context
Severity: Minor
Found in de.bund.bfr.knime.fsklab.deprecatednodes/src-1_7_2/de/bund/bfr/knime/fsklab/nodes/v1_7_2/reader/ReaderNodeModel.java - About 2 days 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 getChart has a Cognitive Complexity of 141 (exceeds 5 allowed). Consider refactoring.
Open

    public JFreeChart getChart(List<String> idsToPaint) {
        if (paramX == null || paramY == null) {
            return new JFreeChart(null, JFreeChart.DEFAULT_TITLE_FONT,
                    new XYPlot(), showLegend);
        }
Severity: Minor
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/chart/ChartCreator.java - About 2 days 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 RController.java has 1113 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*
 * ------------------------------------------------------------------ Copyright by KNIME GmbH,
 * Konstanz, Germany Website: http://www.knime.org; Email: contact@knime.org
 *
 * This program is free software; you can redistribute it and/or modify it under the terms of the
Severity: Major
Found in de.bund.bfr.knime.fsklab.r/src/de/bund/bfr/knime/fsklab/r/client/RController.java - About 2 days to fix

Method passesFilter has a Cognitive Complexity of 139 (exceeds 5 allowed). Consider refactoring.
Open

    public static boolean passesFilter(
        final String matrixString,
        final String agentString,
        final String literatureString,
        int matrixID, int agentID, int literatureID,
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/timeseriesreader/MdReaderUi.java - About 2 days 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 TouchSpin has 558 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  $.fn.TouchSpin = function(options) {

    var defaults = {
      min: 0, // If null, there is no minimum enforced
      max: null, // If null, there is no maximum enforced
Severity: Major
Found in de.bund.bfr.knime.js/src/js/lib/bootstrap-touchspin.js - About 2 days to fix

File ModelPlotterNodeModel.java has 1083 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*******************************************************************************
 * Copyright (c) 2015 Federal Institute for Risk Assessment (BfR), Germany
 *
 * This program is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, either version 3 of the
Severity: Major
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/js/modelplotter/modern/ModelPlotterNodeModel.java - About 2 days to fix

Function 3 has 546 lines of code (exceeds 25 allowed). Consider refactoring.
Open

},{"./expressions":3,"./fractions":4,"./helper":5}],3:[function(require,module,exports){
var Fraction = require('./fractions');
var isInt = require('./helper').isInt;
var GREEK_LETTERS = require('./helper').GREEK_LETTERS;
Severity: Major
Found in de.bund.bfr.knime.pmm.nodes/js-src/de/bund/bfr/knime/pmm/js/modelplotter/algebra-0.2.6.min.js - About 2 days to fix

Function createVars has 545 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    function createVars(){
       _WebRepositoryVars = {
        header          : {
            brand           : {
                title           : _representation.title // false or ''
Severity: Major
Found in de.bund.bfr.knime.fsklab.nodes/js-src/de/bund/bfr/knime/fsklab/v2.0/fskdbview/fskdbview.js - About 2 days to fix

File XLSModelReaderNodeDialog.java has 1052 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*******************************************************************************
 * Copyright (c) 2015 Federal Institute for Risk Assessment (BfR), Germany
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
Severity: Major
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/xlsmodelreader/XLSModelReaderNodeDialog.java - About 2 days to fix

Method getTimeSeriesTuples has a Cognitive Complexity of 130 (exceeds 5 allowed). Consider refactoring.
Open

    public Map<String, KnimeTuple> getTimeSeriesTuples(File file, String sheet, Map<String, Object> columnMappings,
            String timeUnit, String concentrationUnit, String agentColumnName, Map<String, AgentXml> agentMappings,
            String matrixColumnName, Map<String, MatrixXml> matrixMappings, boolean preserveIds, List<Integer> usedIds)
                    throws Exception {
        Workbook wb = getWorkbook(file);
Severity: Minor
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/XLSReader.java - About 2 days 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 react.min.js has 1034 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/** @license React v16.3.2
 * react.development.js
 *
 * Copyright (c) 2013-present, Facebook, Inc.
 *
Severity: Major
Found in de.bund.bfr.knime.fsklab.deprecatednodes/js-src/de/bund/bfr/knime/fsklab/nodes/joiner/react/react.min.js - About 2 days to fix

Method setValueAt has a Cognitive Complexity of 127 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

      if (columnIndex == 1) {
        String stringValue = (String) aValue;
Severity: Minor
Found in de.bund.bfr.knime.fsklab.nodes.common/src/de/bund/bfr/knime/fsklab/nodes/common/ui/MetaDataPane2.java - About 2 days 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 doFields has a Cognitive Complexity of 125 (exceeds 5 allowed). Consider refactoring.
Open

    private String doFields(final PreparedStatement ps, final MyTable myT, ResultSet rs, final Statement anfrage, String sql) {
        try {
            String[] fn = myT.getFieldNames();
            String[] ft = myT.getFieldTypes();
            MyTable[] foreigns = myT.getForeignFields();
Severity: Minor
Found in org.hsh.bfr.db/src/org/hsh/bfr/db/MergeDBsAPriori.java - About 2 days 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 execute has a Cognitive Complexity of 124 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    protected BufferedDataTable[] execute(final BufferedDataTable[] inData,
            final ExecutionContext exec) throws Exception {
        //mergeInportNSettings(inData);
        if (doc != null) {
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/manualmodelconf/ManualModelConfNodeModel.java - About 2 days 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 ChartCreator.java has 1000 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*******************************************************************************
 * Copyright (c) 2015 Federal Institute for Risk Assessment (BfR), Germany
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
Severity: Major
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/chart/ChartCreator.java - About 2 days to fix

File Plotable.java has 962 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*******************************************************************************
 * Copyright (c) 2015 Federal Institute for Risk Assessment (BfR), Germany
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
Severity: Major
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/chart/Plotable.java - About 2 days to fix

Function drawWorkflow has 472 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    function drawWorkflow() {
        graph = new joint.dia.Graph;

        paper = new joint.dia.Paper({
Severity: Major
Found in de.bund.bfr.knime.fsklab.deprecatednodes/js-src/de/bund/bfr/knime/fsklab/nodes/joiner/joiner.js - About 2 days to fix

Method setTsIDs has a Cognitive Complexity of 116 (exceeds 5 allowed). Consider refactoring.
Open

    public static HashMap<Integer, Integer> setTsIDs(boolean before, String attr,
            HashMap<Integer, Integer> foreignDbIds, KnimeTuple row, KnimeTuple schemaTuple) throws PmmException {
        int type = schemaTuple.getSchema().getType(row.getIndex(attr));
        if (type == KnimeAttribute.TYPE_XML) {
            PmmXmlDoc x = row.getPmmXml(attr);
Severity: Minor
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/CellIO.java - About 2 days 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 SwaggerGenericSheetImporter.java has 946 lines of code (exceeds 250 allowed). Consider refactoring.
Open

package metadata;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
Severity: Major
Found in de.bund.bfr.knime.fsklab.metadata.model/src/metadata/SwaggerGenericSheetImporter.java - About 2 days to fix
Severity
Category
Status
Source
Language