laboiteproject/lenuage

View on GitHub

Showing 179 of 384 total issues

Function setMatcher has 66 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 static/dist/js/site-70bd78197e.js - About 2 hrs to fix

    Function superMatcher has 65 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

            superMatcher = function( seed, context, xml, results, outermost ) {
                var elem, j, matcher,
                    matchedCount = 0,
                    i = "0",
                    unmatched = seed && [],
    Severity: Major
    Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

      Function Deferred has 62 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          Deferred: function( func ) {
              var tuples = [
      
                      // action, add listener, listener list, final state
                      [ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
      Severity: Major
      Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

        Function 10 has 61 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        },{}],10:[function(require,module,exports){
        /* ========================================================================
         * Bootstrap: popover.js v3.3.7
         * http://getbootstrap.com/javascript/#popovers
         * ========================================================================
        Severity: Major
        Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

          Function 4 has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
          Open

          },{}],4:[function(require,module,exports){
          /* ========================================================================
           * Bootstrap: alert.js v3.3.7
           * http://getbootstrap.com/javascript/#alerts
           * ========================================================================
          Severity: Minor
          Found in static/dist/js/site-70bd78197e.js - About 2 hrs 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 10 has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
          Open

          },{}],10:[function(require,module,exports){
          /* ========================================================================
           * Bootstrap: popover.js v3.3.7
           * http://getbootstrap.com/javascript/#popovers
           * ========================================================================
          Severity: Minor
          Found in static/dist/js/site-70bd78197e.js - About 2 hrs 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 init has 60 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              init = jQuery.fn.init = function( selector, context, root ) {
                  var match, elem;
          
                  // HANDLE: $(""), $(null), $(undefined), $(false)
                  if ( !selector ) {
          Severity: Major
          Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

            Function ajaxConvert has 59 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            function ajaxConvert( s, response, jqXHR, isSuccess ) {
                var conv2, current, conv, tmp, prev,
                    converters = {},
            
                    // Work with a copy of dataTypes in case we need to modify it for conversion
            Severity: Major
            Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

              Function domManip has 58 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              function domManip( collection, args, callback, ignored ) {
              
                  // Flatten any nested arrays
                  args = concat.apply( [], args );
              
              
              Severity: Major
              Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

                Function data has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    data: function( key, value ) {
                        var i, name, data,
                            elem = this[ 0 ],
                            attrs = elem && elem.attributes;
                
                
                Severity: Major
                Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

                  Function show has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    Tooltip.prototype.show = function () {
                      var e = $.Event('show.bs.' + this.type)
                  
                      if (this.hasContent() && this.enabled) {
                        this.$element.trigger(e)
                  Severity: Major
                  Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

                    Function e has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                    Open

                    (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);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.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){
                    Severity: Minor
                    Found in static/dist/js/site-70bd78197e.js - About 2 hrs 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 remove has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        remove: function( elem, types, handler, selector, mappedTypes ) {
                    
                            var j, origCount, tmp,
                                events, t, handleObj,
                                special, handlers, type, namespaces, origType,
                    Severity: Major
                    Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

                      Function buildFragment has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      function buildFragment( elems, context, scripts, selection, ignored ) {
                          var elem, tmp, tag, wrap, contains, j,
                              fragment = context.createDocumentFragment(),
                              nodes = [],
                              i = 0,
                      Severity: Major
                      Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

                        Function _labelHandlers has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                              value: function _labelHandlers() {
                                var _this7 = this;
                        
                                var handlers = {
                                  click: function click(event) {
                        Severity: Major
                        Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

                          Consider simplifying this complex logical expression.
                          Open

                                          if ( ( mappedTypes || origType === handleObj.origType ) &&
                                              ( !handler || handler.guid === handleObj.guid ) &&
                                              ( !tmp || tmp.test( handleObj.namespace ) ) &&
                                              ( !selector || selector === handleObj.selector ||
                                                  selector === "**" && handleObj.selector ) ) {
                          Severity: Critical
                          Found in static/dist/js/site-70bd78197e.js - About 2 hrs to fix

                            Function 4 has 49 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            },{}],4:[function(require,module,exports){
                            /* ========================================================================
                             * Bootstrap: alert.js v3.3.7
                             * http://getbootstrap.com/javascript/#alerts
                             * ========================================================================
                            Severity: Minor
                            Found in static/dist/js/site-70bd78197e.js - About 1 hr to fix

                              Function apps_view has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                              Open

                              def apps_view(request, pk):
                                  boite = get_object_or_404(Boite, pk=pk, user=request.user)
                              
                                  # update apps data
                                  boite.get_apps_dictionary()
                              Severity: Minor
                              Found in boites/views.py - 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 select has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                              select = Sizzle.select = function( selector, context, results, seed ) {
                                  var i, tokens, token, type, find,
                                      compiled = typeof selector === "function" && selector,
                                      match = !seed && tokenize( (selector = compiled.selector || selector) );
                              
                              
                              Severity: Minor
                              Found in static/dist/js/site-70bd78197e.js - About 1 hr to fix

                                Function matcherFromTokens has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                function matcherFromTokens( tokens ) {
                                    var checkContext, matcher, j,
                                        len = tokens.length,
                                        leadingRelative = Expr.relative[ tokens[0].type ],
                                        implicitRelative = leadingRelative || Expr.relative[" "],
                                Severity: Minor
                                Found in static/dist/js/site-70bd78197e.js - About 1 hr to fix
                                  Severity
                                  Category
                                  Status
                                  Source
                                  Language