Showing 272 of 400 total issues
File analyzer.table.js
has 4498 lines of code (exceeds 250 allowed). Consider refactoring. Open
/* ../../libs/bem-core/node_modules/ym/modules.js begin */
/**
* Modules
*
* Copyright (c) 2013 Filatov Dmitry (dfilatov@yandex-team.ru)
File inflate.js
has 1683 lines of code (exceeds 250 allowed). Consider refactoring. Open
/*
Copyright (c) 2013 Gildas Lormeau. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Function Deflate
has 853 lines of code (exceeds 25 allowed). Consider refactoring. Open
function Deflate() {
var that = this;
var strm; // pointer back to this zlib stream
var status; // as the name implies
File deflate.js
has 1295 lines of code (exceeds 250 allowed). Consider refactoring. Open
/*
Copyright (c) 2013 Gildas Lormeau. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Function xml2json
has a Cognitive Complexity of 152 (exceeds 5 allowed). Consider refactoring. Open
function xml2json(xml, tab) {
var X = {
toObj: function(xml) {
var o = {};
if (xml.nodeType==1) { // element node ..
- 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 init
has 541 lines of code (exceeds 25 allowed). Consider refactoring. Open
}(this, function init($, undefined) {
"use strict";
// the base DOM structure needed to create a modal
Function InfCodes
has 521 lines of code (exceeds 25 allowed). Consider refactoring. Open
function InfCodes() {
var that = this;
var mode; // current inflate_codes mode
Function InfBlocks
has 483 lines of code (exceeds 25 allowed). Consider refactoring. Open
function InfBlocks(z, w) {
var that = this;
var mode = TYPE; // current inflate_block mode
File mime-types.js
has 970 lines of code (exceeds 250 allowed). Consider refactoring. Open
/*
Copyright (c) 2013 Gildas Lormeau. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Function proc
has 404 lines of code (exceeds 25 allowed). Consider refactoring. Open
that.proc = function(z, r) {
var t; // temporary storage
var b; // bit buffer
var k; // bits in bit buffer
var p; // input data pointer
Function init
has a Cognitive Complexity of 91 (exceeds 5 allowed). Consider refactoring. Open
}(this, function init($, undefined) {
"use strict";
// the base DOM structure needed to create a modal
- 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 zip.js
has 677 lines of code (exceeds 250 allowed). Consider refactoring. Open
/*
Copyright (c) 2013 Gildas Lormeau. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Function proc
has 302 lines of code (exceeds 25 allowed). Consider refactoring. Open
that.proc = function(s, z, r) {
var j; // temporary storage
var tindex; // temporary pointer
var e; // extra bits or operation
var b = 0; // bit buffer
Function InfTree
has 234 lines of code (exceeds 25 allowed). Consider refactoring. Open
function InfTree() {
var that = this;
var hn; // hufts used in space
var v; // work area for huft_build
File bootbox.js
has 553 lines of code (exceeds 250 allowed). Consider refactoring. Open
/**
* bootbox.js [master branch]
*
* http://bootboxjs.com/license.txt
*/
Function create
has 220 lines of code (exceeds 25 allowed). Consider refactoring. Open
create = function() {
var curOptions = {
trackCircularDependencies : true,
allowMultipleDeclarations : true,
onError : function(e) {
Function Inflate
has 202 lines of code (exceeds 25 allowed). Consider refactoring. Open
function Inflate() {
var that = this;
that.mode = 0; // current inflate mode
Function inflate_fast
has 190 lines of code (exceeds 25 allowed). Consider refactoring. Open
function inflate_fast(bl, bd, tl, tl_index, td, td_index, s, z) {
var t; // temporary pointer
var tp; // temporary pointer
var tp_index; // temporary pointer
var e; // extra bits or operation
File zip-fs.js
has 458 lines of code (exceeds 250 allowed). Consider refactoring. Open
/*
Copyright (c) 2013 Gildas Lormeau. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Function startExecutor
has a Cognitive Complexity of 44 (exceeds 5 allowed). Consider refactoring. Open
private function startExecutor()
{
$view = new View();
$healer = new Healer();
- 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"