Sign upLogin

SiLeBAT/FSK-Lab

View on GitHub
Star

Showing 6,856 of 14,752 total issues

Method actionPerformed has a Cognitive Complexity of 92 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == modelButton) {
            Integer id;
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/xlsmodelreader/XLSModelReaderNodeDialog.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 run has a Cognitive Complexity of 91 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public void run() {
        try {
            List<KnimeTuple> tuples = PmmUtilities.getTuples(inTable, schema);
            List<String> miscParams = PmmUtilities.getMiscParams(tuples);
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/modelestimation/SecondaryEstimationThread.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 CombinedFskPortObject.java has 769 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
Severity: Major
Found in de.bund.bfr.knime.fsklab.nodes/src/de/bund/bfr/knime/fsklab/v2_0/CombinedFskPortObject.java - About 1 day to fix

File MyDBPanel.java has 766 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 org.hsh.bfr.db/src/org/hsh/bfr/db/gui/dbtable/MyDBPanel.java - About 1 day to fix

MMC_M has 94 methods (exceeds 20 allowed). Consider refactoring.
Open

public class MMC_M extends JPanel {

    /**
     * 
     */
Severity: Major
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/manualmodelconf/ui/MMC_M.java - About 1 day to fix

File CombinedFskPortObject.java has 763 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
Severity: Major
Found in de.bund.bfr.knime.fsklab.deprecatednodes/src-1_9_0/de/bund/bfr/knime/fsklab/v1_9/CombinedFskPortObject.java - About 1 day to fix

File css.js has 761 lines of code (exceeds 250 allowed). Consider refactoring.
Open

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE

(function(mod) {
  if (typeof exports == "object" && typeof module == "object") // CommonJS
Severity: Major
Found in de.bund.bfr.knime.js/js-lib/codemirror-5.49.2/mode/css/css.js - About 1 day to fix

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

public class ParametricModel implements PmmXmlElementConvertable {

    public static final String ELEMENT_PARAMETRICMODEL = "ParametricModel";

    // hier fest verdrahtet und von den zentralen KnimSchema Variablen unabhängig
Severity: Major
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/ParametricModel.java - About 1 day to fix

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

    private List<KnimeTuple> decodeM12DataSchemas(List<JsM12DataSchema> schemas) {

        List<KnimeTuple> tuples = new LinkedList<>();
        KnimeSchema knimeSchema = SchemaFactory.createM12DataSchema();
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/js/modelplotter/modern/ModelPlotterNodeModel.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 insertLiteratureInCase has a Cognitive Complexity of 87 (exceeds 5 allowed). Consider refactoring.
Open

    private void insertLiteratureInCase(PmmXmlDoc lit) {
        try {
            int i = 0;
            for (PmmXmlElementConvertable el : lit.getElementSet()) {
                if (el instanceof LiteratureItem) {
Severity: Minor
Found in de.bund.bfr.knime.pmm.bfrdbiface.lib/src/de/bund/bfr/knime/pmm/bfrdbiface/lib/Bfrdb.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 computePrimary has a Cognitive Complexity of 87 (exceeds 5 allowed). Consider refactoring.
Open

    public static List<KnimeTuple> computePrimary(List<KnimeTuple> tuples,
            boolean perDataSet) {
        Map<String, KnimeTuple> tupleMap = new LinkedHashMap<>();
        Map<String, Set<Integer>> usedCondIDs = new LinkedHashMap<>();
        Map<String, List<Double>> targetValueMap = new LinkedHashMap<>();
Severity: Minor
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/QualityMeasurementComputation.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 Login.java has 744 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 org.hsh.bfr.db/src/org/hsh/bfr/db/gui/Login.java - About 1 day to fix

Method check4Updates_183_184 has a Cognitive Complexity of 86 (exceeds 5 allowed). Consider refactoring.
Open

    public static void check4Updates_183_184() {
        try {
            ResultSet rs = DBKernel.getResultSet(
                    "SELECT MIN(\"Agenzien\".\"Agensname\") AS \"Agensname\", MIN(\"Versuchsbedingungen\") AS \"Versuchsbedingung\" FROM \"Messwerte\"" +
                            " LEFT JOIN \"Versuchsbedingungen\" ON \"Versuchsbedingungen\".\"ID\" = \"Messwerte\".\"Versuchsbedingungen\"" +
Severity: Minor
Found in org.hsh.bfr.db/src/org/hsh/bfr/db/UpdateChecker.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 convertArrays2ParamXmlDoc has a Cognitive Complexity of 86 (exceeds 5 allowed). Consider refactoring.
Open

    public static PmmXmlDoc convertArrays2ParamXmlDoc(LinkedHashMap<String, String> varMap, Array name,
            Array value, Array timeUnit, Array categories, Array units, Array error, Array min, Array max, Array desc, Array paramType, Array P, Array t, Integer modelId, Integer emid) {
        PmmXmlDoc paramDoc = new PmmXmlDoc();
        if (name != null) {
            try {
Severity: Minor
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/DbIo.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 setValueAt has a Cognitive Complexity of 85 (exceeds 5 allowed). Consider refactoring.
Open

        public void setValueAt(Object o, int rowIndex, int columnIndex) {
            if (thePM == null) return;
            if (rowIndex == 0) {
                DepXml dx = thePM.getDepXml();
                if (columnIndex == 1) {
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/manualmodelconf/ui/ModelTableModel.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 fire has a Cognitive Complexity of 85 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public void fire(final int triggerType, final String triggerName, final String tableName, final Object rowBefore[], final Object rowAfter[]) {
        try {
            if (triggerType == Trigger.INSERT_BEFORE_ROW || triggerType == Trigger.UPDATE_BEFORE_ROW || triggerType == Trigger.DELETE_BEFORE_ROW) {
                if (tableName.equals("Users")) {
Severity: Minor
Found in org.hsh.bfr.db/src/org/hsh/bfr/db/MyTrigger.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 initComponents has 339 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    private void initComponents() {
        // JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
        label000 = new JLabel();
        label111 = new JLabel();
        label1 = new JLabel();
Severity: Major
Found in org.hsh.bfr.db/src/org/hsh/bfr/db/gui/dbtable/editoren/MyNewDoubleEditor.java - About 1 day to fix

Function ajv has 338 lines of code (exceeds 25 allowed). Consider refactoring.
Open

},{}],"ajv":[function(require,module,exports){
'use strict';

var compileSchema = require('./compile')
  , resolve = require('./compile/resolve')
Severity: Major
Found in de.bund.bfr.knime.fsklab.deprecatednodes/js-src/de/bund/bfr/knime/fsklab/nodes/joiner/emfbundle/ajv.min.js - About 1 day to fix

File markdown.js has 727 lines of code (exceeds 250 allowed). Consider refactoring.
Open

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE

(function(mod) {
  if (typeof exports == "object" && typeof module == "object") // CommonJS
Severity: Major
Found in de.bund.bfr.knime.js/js-lib/codemirror-5.49.2/mode/markdown/markdown.js - About 1 day to fix

File markdown.js has 727 lines of code (exceeds 250 allowed). Consider refactoring.
Open

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE

(function(mod) {
  if (typeof exports == "object" && typeof module == "object") // CommonJS
Severity: Major
Found in de.bund.bfr.knime.fsklab.deprecatednodes/js-lib/codemirror/markdown.js - About 1 day to fix
Severity
Category
Status
Source
Language