LearnPAd/learnpad

View on GitHub

Showing 2,438 of 4,261 total issues

File ZSchema-browser.js has 1698 lines of code (exceeds 250 allowed). Consider refactoring.
Open

// This comes from https://github.com/zaggino/z-schema Version 3.1.2
// with ZSchema variable imported to global scope ready to be used by "new ZSchema()" call.
require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
// shim for using process in browser

    Method init has a Cognitive Complexity of 216 (exceeds 5 allowed). Consider refactoring.
    Open

      @Override
      @SuppressWarnings("deprecation")
      public Resource init() throws ResourceInstantiationException {
        // list of namespaces to be ignored when creating gazetteer list
        List<String> nsToIgnore = new ArrayList<String>();

    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 Gaze.java has 1524 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /* Gaze.java
     * borislav popov
     */
    package com.ontotext.gate.vr;
    
    

      File SuperBoxSelect.js has 1483 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      Ext.namespace('Ext.ux.form');
      /**
       * <p>SuperBoxSelect is an extension of the ComboBox component that displays selected items as labelled boxes within the form field. As seen on facebook, hotmail and other sites.</p>
       * 
       * @author <a href="mailto:dan.humphrey@technomedia.co.uk">Dan Humphrey</a>

        XwikiPackageImpl has 196 methods (exceeds 20 allowed). Consider refactoring.
        Open

        public class XwikiPackageImpl extends EPackageImpl implements XwikiPackage {
            /**
             * <!-- begin-user-doc -->
             * <!-- end-user-doc -->
             * @generated

          XwikiPackage has 192 methods (exceeds 20 allowed). Consider refactoring.
          Open

          public interface XwikiPackage extends EPackage {
              /**
               * The package name.
               * <!-- begin-user-doc -->
               * <!-- end-user-doc -->

            Method generateReducedNet has a Cognitive Complexity of 187 (exceeds 5 allowed). Consider refactoring.
            Open

                public static PetriNet generateReducedNet(PetriNet pn) throws Exception{
                    //FIXME: Riadattare la regola considerando gli arc weight!
                    /* Applica regole piu complesse che generano una petri net minima (potrebbe renderne piu' difficile la lettura)
                     Regole:
                     - T1->P->T2 = posso togliere p ed unire le T (copiare tutti i next di T2 in T1 e i previous di T2 in T1 e rimuovere T2 e P) solo se p ha un solo next ed un solo previous e (T2 ha un solo previous o T1 ha un solo next): questa modalita riduce di piu gli stati ma in questo caso bisogna anche controllare che non esista una connessione tra un previous di t2 e t1. Se esiste non si puo applicare perche andrebbe a eliminare deadlock: Es: in questo caso non si puo ridurre: p0->t1->p->t2->p1, p0->t2

            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 AbstractOntologyImpl.java has 1348 lines of code (exceeds 250 allowed). Consider refactoring.
            Open

            /*
             *  Copyright (c) 1995-2012, The University of Sheffield. See the file
             *  COPYRIGHT.txt in the software or at http://gate.ac.uk/gate/COPYRIGHT.txt
             *
             *  This file is part of GATE (see http://gate.ac.uk/), and is free

              OntologyServiceImplSesame has 177 methods (exceeds 20 allowed). Consider refactoring.
              Open

              public class OntologyServiceImplSesame implements OntologyService {
              
                // ***************************************************************************
                // **** CONSTANTS ************************************************************
                // ***************************************************************************

                Function swfobject has 664 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                var swfobject = function() {
                    
                    var UNDEF = "undefined",
                        OBJECT = "object",
                        SHOCKWAVE_FLASH = "Shockwave Flash",

                  Function DomQuery has 650 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  Ext.DomQuery = function(){
                      var cache = {}, 
                          simpleCache = {}, 
                          valueCache = {},
                          nonSpace = /\S/,

                    File pkg-charts-debug.js has 1176 lines of code (exceeds 250 allowed). Consider refactoring.
                    Open

                    /*!
                     * Ext JS Library 3.4.0
                     * Copyright(c) 2006-2011 Sencha Inc.
                     * licensing@sencha.com
                     * http://www.sencha.com/license

                      File window-debug.js has 1166 lines of code (exceeds 250 allowed). Consider refactoring.
                      Open

                      /*!
                       * Ext JS Library 3.4.0
                       * Copyright(c) 2006-2011 Sencha Inc.
                       * licensing@sencha.com
                       * http://www.sencha.com/license

                        Function DomHelper has a Cognitive Complexity of 145 (exceeds 5 allowed). Consider refactoring.
                        Open

                        Ext.DomHelper = function(){
                            var tempTableEl = null,
                                emptyTags = /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i,
                                tableRe = /^table|tbody|tr|td$/i,
                                confRe = /tag|children|cn|html$/i,

                        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 generateFromAdoxxBPMN has a Cognitive Complexity of 140 (exceeds 5 allowed). Consider refactoring.
                        Open

                            public static PetriNet[] generateFromAdoxxBPMN(Document adoxxXml) throws Exception{
                                /* To Remember:
                                 * - id are unique between all the models
                                 * - name are unique only inside a model. Es: 2 model can have a task with the same name.
                                 * */

                        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

                        AdoPackageImpl has 137 methods (exceeds 20 allowed). Consider refactoring.
                        Open

                        public class AdoPackageImpl extends EPackageImpl implements AdoPackage {
                            /**
                             * <!-- begin-user-doc -->
                             * <!-- end-user-doc -->
                             * @generated

                          File pkg-menu-debug.js has 1059 lines of code (exceeds 250 allowed). Consider refactoring.
                          Open

                          /*!
                           * Ext JS Library 3.4.0
                           * Copyright(c) 2006-2011 Sencha Inc.
                           * licensing@sencha.com
                           * http://www.sencha.com/license

                            Function DragDropMgr has 531 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            Ext.dd.DragDropMgr = function() {
                            
                                var Event = Ext.EventManager;
                            
                                return {

                              AdoPackage has 133 methods (exceeds 20 allowed). Consider refactoring.
                              Open

                              public interface AdoPackage extends EPackage {
                                  /**
                                   * The package name.
                                   * <!-- begin-user-doc -->
                                   * <!-- end-user-doc -->

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

                                    public void actionPerformed(ActionEvent ae) {
                                
                                      if(ae.getSource() == otherAS) {
                                        annotationSetsNamesCB.setEnabled(true);
                                        if(annotationSetsNamesCB.getSelectedItem() == null

                                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

                                Severity
                                Category
                                Status
                                Source
                                Language