jquery/jquery

View on GitHub

Showing 250 of 250 total issues

Function then has 102 lines of code (exceeds 25 allowed). Consider refactoring.
Open

                then: function( onFulfilled, onRejected, onProgress ) {
                    var maxDepth = 0;
                    function resolve( depth, deferred, handler, special ) {
                        return function() {
                            var that = this,
Severity: Major
Found in src/deferred.js - About 4 hrs to fix

    Function exports has 97 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    module.exports = function( Release, files, complete ) {
    
        var
            fs = require( "fs" ),
            shell = require( "shelljs" ),
    Severity: Major
    Found in build/release/dist.js - About 3 hrs to fix

      Function callPlugin has 96 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

                  callPlugin: function () {
                      var map = this.map,
                          id = map.id,
                          //Map already normalized the prefix.
                          pluginMap = makeModuleMap(map.prefix);
      Severity: Major
      Found in external/requirejs/require.js - About 3 hrs to fix

        Function Animation has 95 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        function Animation( elem, properties, options ) {
            var result,
                stopped,
                index = 0,
                length = Animation.prefilters.length,
        Severity: Major
        Found in src/effects.js - About 3 hrs to fix

          Function TestReport has 95 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            var TestReport = function () {
                function TestReport(name, suite, options) {
                    classCallCheck(this, TestReport);
          
                    this.name = name;
          Severity: Major
          Found in external/qunit/qunit.js - About 3 hrs to fix

            Function trigger has 94 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                trigger: function( event, data, elem, onlyHandlers ) {
            
                    var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
                        eventPath = [ elem || document ],
                        type = hasOwn.call( event, "type" ) ? event.type : event,
            Severity: Major
            Found in src/event/trigger.js - About 3 hrs to fix

              Function diffCleanupMerge has 87 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                    DiffMatchPatch.prototype.diffCleanupMerge = function (diffs) {
                        var pointer, countDelete, countInsert, textInsert, textDelete, commonlength, changes, diffPointer, position;
                        diffs.push([DIFF_EQUAL, ""]); // Add a dummy entry at the end.
                        pointer = 0;
                        countDelete = 0;
              Severity: Major
              Found in external/qunit/qunit.js - About 3 hrs to fix

                Function makeRequire has 86 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                            makeRequire: function (relMap, options) {
                                options = options || {};
                
                                function localRequire(deps, callback, errback) {
                                    var id, map, requireMod;
                Severity: Major
                Found in external/requirejs/require.js - About 3 hrs to fix

                  Function Enumerator has 84 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    var Enumerator = function () {
                      function Enumerator(Constructor, input) {
                        classCallCheck(this, Enumerator);
                  
                        this._instanceConstructor = Constructor;
                  Severity: Major
                  Found in external/qunit/qunit.js - About 3 hrs to fix

                    Function finish has 82 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                          finish: function finish() {
                              config.current = this;
                    
                              // Release the test callback to ensure that anything referenced has been
                              // released to be garbage collected.
                    Severity: Major
                    Found in external/qunit/qunit.js - About 3 hrs to fix

                      Function diffBisect has 82 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                            DiffMatchPatch.prototype.diffBisect = function (text1, text2, deadline) {
                                var text1Length, text2Length, maxD, vOffset, vLength, v1, v2, x, delta, front, k1start, k1end, k2start, k2end, k2Offset, k1Offset, x1, x2, y1, y2, d, k1, k2;
                      
                                // Cache the text lengths to prevent multiple calls.
                                text1Length = text1.length;
                      Severity: Major
                      Found in external/qunit/qunit.js - About 3 hrs to fix

                        File Gruntfile.js has 289 lines of code (exceeds 250 allowed). Consider refactoring.
                        Open

                        module.exports = function( grunt ) {
                            "use strict";
                        
                            function readOptionalJSON( filepath ) {
                                var stripJSONComments = require( "strip-json-comments" ),
                        Severity: Minor
                        Found in Gruntfile.js - About 2 hrs to fix

                          Function CHILD has 73 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                                  "CHILD": function( type, what, _argument, first, last ) {
                                      var simple = type.slice( 0, 3 ) !== "nth",
                                          forward = type.slice( -4 ) !== "last",
                                          ofType = what === "of-type";
                          
                          
                          Severity: Major
                          Found in src/selector.js - About 2 hrs to fix

                            Function find has 73 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            function find( selector, context, results, seed ) {
                                var m, i, elem, nid, match, groups, newSelector,
                                    newContext = context && context.ownerDocument,
                            
                                    // nodeType defaults to 9, since context defaults to document
                            Severity: Major
                            Found in src/selector.js - About 2 hrs to fix

                              Function configure has 73 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                          configure: function (cfg) {
                                              //Make sure the baseUrl ends in a slash.
                                              if (cfg.baseUrl) {
                                                  if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
                                                      cfg.baseUrl += '/';
                              Severity: Major
                              Found in external/requirejs/require.js - About 2 hrs to fix

                                Function add has 72 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                    add: function( elem, types, handler, data, selector ) {
                                
                                        var handleObjIn, eventHandle, tmp,
                                            events, t, handleObj,
                                            special, handlers, type, namespaces, origType,
                                Severity: Major
                                Found in src/event.js - About 2 hrs to fix

                                  Function matcherFromGroupMatchers has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
                                      var bySet = setMatchers.length > 0,
                                          byElement = elementMatchers.length > 0,
                                          superMatcher = function( seed, context, xml, results, outermost ) {
                                              var elem, j, matcher,
                                  Severity: Major
                                  Found in src/selector.js - About 2 hrs to fix

                                    Function diffCleanupSemantic has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                          DiffMatchPatch.prototype.diffCleanupSemantic = function (diffs) {
                                              var changes, equalities, equalitiesLength, lastequality, pointer, lengthInsertions2, lengthDeletions2, lengthInsertions1, lengthDeletions1, deletion, insertion, overlapLength1, overlapLength2;
                                              changes = false;
                                              equalities = []; // Stack of indices where equalities are found.
                                              equalitiesLength = 0; // Keeping our own length var is faster in JS.
                                    Severity: Major
                                    Found in external/qunit/qunit.js - About 2 hrs to fix

                                      Function resolve has 69 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                                          function resolve( depth, deferred, handler, special ) {
                                                              return function() {
                                                                  var that = this,
                                                                      args = arguments,
                                                                      mightThrow = function() {
                                      Severity: Major
                                      Found in src/deferred.js - About 2 hrs to fix

                                        Function setMatcher has 68 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                        function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
                                            if ( postFilter && !postFilter[ expando ] ) {
                                                postFilter = setMatcher( postFilter );
                                            }
                                            if ( postFinder && !postFinder[ expando ] ) {
                                        Severity: Major
                                        Found in src/selector.js - About 2 hrs to fix
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language