Showing 845 of 1,621 total issues
Function DataTable
has 4212 lines of code (exceeds 25 allowed). Consider refactoring. Open
var DataTable = function( oInit )
{
/**
File fuelux.js
has 6098 lines of code (exceeds 250 allowed). Consider refactoring. Open
/*!
* Fuel UX v3.16.0
* Copyright 2012-2017 ExactTarget
* Licensed under the BSD-3-Clause license (https://github.com/ExactTarget/fuelux/blob/master/LICENSE)
*/
File tests.py
has 5325 lines of code (exceeds 250 allowed). Consider refactoring. Open
#
# Copyright 2013, Junta de Andalucia
# http://www.juntadeandalucia.es/
#
# Authors:
File jquery.dataTables-1.9.4.js
has 4999 lines of code (exceeds 250 allowed). Consider refactoring. Open
/**
* @summary DataTables
* @description Paginate, search and sort HTML tables
* @version 1.9.4
* @file jquery.dataTables.js
File jsonform-b3-1.0.0.js
has 2705 lines of code (exceeds 250 allowed). Consider refactoring. Open
/* Copyright (c) 2012 Joshfire - MIT license */
/**
* @fileoverview Core of the JSON Form client-side library.
*
* Generates an HTML form from a structured data model and a layout description.
Function Marionette
has 1277 lines of code (exceeds 25 allowed). Consider refactoring. Open
var Marionette = (function(global, Backbone, _){
"use strict";
// Define and export the Marionette namespace
var Marionette = {};
File tasks.py
has 2089 lines of code (exceeds 250 allowed). Consider refactoring. Open
#
# Copyright 2013, Junta de Andalucia
# http://www.juntadeandalucia.es/
#
# Authors:
File utils.py
has 1980 lines of code (exceeds 250 allowed). Consider refactoring. Open
# -*- coding: utf-8 -*-
#
# Copyright 2013, Junta de Andalucia
# http://www.juntadeandalucia.es/
Function Marionette
has a Cognitive Complexity of 227 (exceeds 5 allowed). Consider refactoring. Open
var Marionette = (function(global, Backbone, _){
"use strict";
// Define and export the Marionette namespace
var Marionette = {};
- 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 backbone-marionette-1.7.3.js
has 1504 lines of code (exceeds 250 allowed). Consider refactoring. Open
// MarionetteJS (Backbone.Marionette)
// ----------------------------------
// v1.7.3
//
// Copyright (c)2014 Derick Bailey, Muted Solutions, LLC.
Function Paginator
has a Cognitive Complexity of 195 (exceeds 5 allowed). Consider refactoring. Open
Backbone.Paginator = (function ( Backbone, _, $ ) {
"use strict";
var bbVer = _.map(Backbone.VERSION.split('.'), function(digit) {
- 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
Function command
has a Cognitive Complexity of 184 (exceeds 5 allowed). Consider refactoring. Open
def command(self):
# Clean the database if necessary
if self.options.clean:
print('Cleaning MongoDB data before importing...')
self.db.packages.drop()
- 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
Function Paginator
has 692 lines of code (exceeds 25 allowed). Consider refactoring. Open
Backbone.Paginator = (function ( Backbone, _, $ ) {
"use strict";
var bbVer = _.map(Backbone.VERSION.split('.'), function(digit) {
Function object_action
has a Cognitive Complexity of 118 (exceeds 5 allowed). Consider refactoring. Open
def object_action(self, user, obj, objold=None, action=None, computers=None,
api=None, cookbook=None, calculate_inheritance=True,
validator=None):
'''
This method try to get the node to make changes in it.
- 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 backbone-1.1.2.js
has 956 lines of code (exceeds 250 allowed). Consider refactoring. Open
// Backbone.js 1.1.2
// (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
// Backbone may be freely distributed under the MIT license.
// For all details and documentation:
File underscore-1.6.0.js
has 932 lines of code (exceeds 250 allowed). Consider refactoring. Open
// Underscore.js 1.6.0
// http://underscorejs.org
// (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
// Underscore may be freely distributed under the MIT license.
File models.py
has 898 lines of code (exceeds 250 allowed). Consider refactoring. Open
#
# Copyright 2013, Junta de Andalucia
# http://www.juntadeandalucia.es/
#
# Authors:
Function post
has a Cognitive Complexity of 91 (exceeds 5 allowed). Consider refactoring. Open
def post(self):
try:
# Initialize report
report = {'inserted': 0,
'updated': 0,
- 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 app.js
has 759 lines of code (exceeds 250 allowed). Consider refactoring. Open
/*jslint browser: true, vars: false, nomen: true */
/*global App: true, Backbone, jQuery, _, gettext, MessageManager */
/*
* Copyright 2013, Junta de Andalucia
Function update_node_from_rules
has a Cognitive Complexity of 87 (exceeds 5 allowed). Consider refactoring. Open
def update_node_from_rules(self, rules, user, computer, obj_ui, obj, objold, action, node, policy, rule_type, parent_id, job_ids_by_computer):
'''
This function update a node from rules.
Rules are the different fields in a policy.
We have different cases:
- 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"