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>();
- Read upRead up
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
- Read upRead up
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,
- Read upRead up
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.
* */
- Read upRead up
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
- Read upRead up
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"