codenothing/CSSCompressor

View on GitHub

Showing 179 of 254 total issues

Function callback has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
Open

    callback: function( value, position, compressor ) {
        var m = rdecimal.exec( value ),
            before = value,
            n;

Severity: Minor
Found in lib/rules/Trailing Zeroes.js - About 1 hr 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

Function callback has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
Open

    callback: function( branch, compressor ) {
        if ( ! branch.rules || ! branch.rules.length ) {
            return;
        }

Severity: Minor
Found in lib/rules/Border Combinations.js - About 1 hr 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

Function callback has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
Open

    callback: function( value, position, compressor ) {
        var m = rcalc.exec( value ),
            before = value,
            prefix = ( m || [] )[ 1 ] || '',
            iter = new StringIterator( ( m || [] )[ 3 ] || '' ),
Severity: Minor
Found in lib/rules/Calc Units.js - About 1 hr 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

Function addClass has 27 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    addClass: function( value ) {
        if ( jQuery.isFunction(value) ) {
            return this.each(function(i) {
                var self = jQuery(this);
                self.addClass( value.call(this, i, self.attr("class")) );
Severity: Minor
Found in demo/rules/js/jquery.js - About 1 hr to fix

    Function html has 27 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        html: function( value ) {
            if ( value === undefined ) {
                return this[0] && this[0].nodeType === 1 ?
                    this[0].innerHTML.replace(rinlinejQuery, "") :
                    null;
    Severity: Minor
    Found in demo/rules/js/jquery.js - About 1 hr to fix

      Function cleanData has 27 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          cleanData: function( elems ) {
              var data, id, cache = jQuery.cache,
                  special = jQuery.event.special,
                  deleteExpando = jQuery.support.deleteExpando;
              
      Severity: Minor
      Found in demo/rules/js/jquery.js - About 1 hr to fix

        Function callback has 27 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            callback: function( branches, compressor ) {
                var index = -1, subindex = -1, branch, next;
        
                for ( ; ++index < branches.length; ) {
                    branch = branches[ index ];
        Severity: Minor
        Found in lib/rules/Common Rules.js - About 1 hr to fix

          Function callback has 27 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              callback: function( branches, compressor ) {
                  function strip( array ) {
                      for ( var i = -1, branch; ++i < array.length; ) {
                          branch = array[ i ];
          
          
          Severity: Minor
          Found in lib/rules/Strip Empty Branches.js - About 1 hr to fix

            Function > has 26 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    ">": function( checkSet, part ) {
                        var elem,
                            isPartStr = typeof part === "string",
                            i = 0,
                            l = checkSet.length;
            Severity: Minor
            Found in demo/rules/js/jquery.js - About 1 hr to fix

              Function callback has 26 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  callback: function( branch, compressor ) {
                      if ( ! branch.rules || ! branch.rules.length ) {
                          return;
                      }
              
              
              Severity: Minor
              Found in lib/rules/Sort Properties.js - About 1 hr to fix

                Function callback has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    callback: function( branches, compressor ) {
                        var index = -1, subindex = -1, branch, next;
                
                        for ( ; ++index < branches.length; ) {
                            branch = branches[ index ];
                Severity: Minor
                Found in lib/rules/Common Selectors.js - About 1 hr to fix

                  Function type has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      jQuery.fn[ type ] = function( size ) {
                          // Get window width or height
                          var elem = this[0];
                          if ( !elem ) {
                              return size == null ? null : this;
                  Severity: Minor
                  Found in demo/rules/js/jquery.js - About 1 hr to fix

                    Function toggleClass has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        toggleClass: function( value, stateVal ) {
                            var type = typeof value,
                                isBool = typeof stateVal === "boolean";
                    
                            if ( jQuery.isFunction( value ) ) {
                    Severity: Minor
                    Found in demo/rules/js/jquery.js - About 1 hr to fix

                      Consider simplifying this complex logical expression.
                      Open

                          if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
                              !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
                      
                              cacheable = true;
                              cacheresults = jQuery.fragments[ args[0] ];
                      Severity: Major
                      Found in demo/rules/js/jquery.js - About 1 hr to fix

                        Function callback has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                        Open

                            callback: function( branch, compressor ) {
                                if ( ! branch.selector || ! branch.parts || ! branch.parts.length ) {
                                    return;
                                }
                        
                        
                        Severity: Minor
                        Found in lib/rules/Lowercase Selectors.js - About 55 mins 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

                        Function callback has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                        Open

                            callback: function( branch, compressor ) {
                                if ( ! branch.selector || ! branch.parts || ! branch.parts.length ) {
                                    return;
                                }
                        
                        
                        Severity: Minor
                        Found in lib/rules/Trim Selector Attribute Quotes.js - About 55 mins 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

                        Avoid deeply nested control flow statements.
                        Open

                                                if ( elem.id !== match[2] ) {
                                                    return rootjQuery.find( selector );
                                                }
                        Severity: Major
                        Found in demo/rules/js/jquery.js - About 45 mins to fix

                          Avoid deeply nested control flow statements.
                          Open

                                              if ( copyIsArray ) {
                                                  copyIsArray = false;
                                                  clone = src && jQuery.isArray(src) ? src : [];
                          
                                              } else {
                          Severity: Major
                          Found in demo/rules/js/jquery.js - About 45 mins to fix

                            Avoid deeply nested control flow statements.
                            Open

                                            } else if ( copy !== undefined ) {
                                                target[ name ] = copy;
                                            }
                            Severity: Major
                            Found in demo/rules/js/jquery.js - About 45 mins to fix

                              Avoid deeply nested control flow statements.
                              Open

                                                  for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
                                                      if ( item ) {
                                                          found = filter( item, match, i, curLoop );
                                                          var pass = not ^ !!found;
                              
                              
                              Severity: Major
                              Found in demo/rules/js/jquery.js - About 45 mins to fix
                                Severity
                                Category
                                Status
                                Source
                                Language