beevelop/corci-monitor

View on GitHub

Showing 256 of 374 total issues

Function 6 has 56 lines of code (exceeds 25 allowed). Consider refactoring.
Open

},{}],6:[function(require,module,exports){
var hasOwn = Object.prototype.hasOwnProperty;
var toString = Object.prototype.toString;
var undefined;

Severity: Major
Found in www/js/bundle.js - About 2 hrs to fix

    Function memoization has 56 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    ko.memoization = (function () {
        var memos = {};
    
        function randomMax8HexChars() {
            return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);
    Severity: Major
    Found in www/js/bundle.js - About 2 hrs to fix

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

          'init': function (element, valueAccessor, allBindings) {
              var checkedValue = ko.pureComputed(function() {
                  // Treat "value" like "checkedValue" when it is included with "checked" binding
                  if (allBindings['has']('checkedValue')) {
                      return ko.utils.unwrapObservable(allBindings.get('checkedValue'));
      Severity: Major
      Found in www/js/bundle.js - About 2 hrs to fix

        Function compareSmallArrayToBigArray has 53 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, options) {
                var myMin = Math.min,
                    myMax = Math.max,
                    editDistanceMatrix = [],
                    smlIndex, smlIndexMax = smlArray.length,
        Severity: Major
        Found in www/js/bundle.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 www/js/bundle.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 create has 51 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          Request.prototype.create = function(){
            var xhr = this.xhr = new XMLHttpRequest({ agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR });
            var self = this;
          
            try {
          Severity: Major
          Found in www/js/bundle.js - About 2 hrs to fix

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

              function checkBadness() {
                var b, b1, bad, big, bw, count, h, x, y;
                bad = bw = count = 0;
            
                // Blocks of same colour.
            Severity: Major
            Found in www/js/qr-js/qr.js - About 2 hrs to fix

              Function define has 50 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  Function_prototype.define = function define(prototype, mixins) {
                      /// <summary>Define members on the prototype of the given function with the custom methods and fields specified in the prototype parameter.</summary>
                      /// <param name="prototype" type="Function || Plain Object">{} or function(prototype, ctor) {}<br/>A custom object with the methods or properties to be added on Extendee.prototype</param>
                      /// <param name="mixins"  type="Function || Plain Object" optional="true" parameterArray="true">Specify one ore more mixins to be added to this function's prototype. <br/>A Mixin is either a function which returns a plain object, or a plan object in itself. It contains method or properties to be added to this function's prototype</param>
                      var constructor = this;
              Severity: Minor
              Found in www/js/bundle.js - About 2 hrs to fix

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

                },{}],54:[function(require,module,exports){
                (function(g) {
                    var FORMAT_RE = /({+)([^:{\|}]+)(\|([^:}]+))?(:(-?\d*)([ij]?))?(}+)/g,
                        defined = function(x) { return typeof x !== 'undefined' },
                        format = function() {
                Severity: Minor
                Found in www/js/bundle.js - About 2 hrs to fix

                  Function show has 50 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: Minor
                  Found in www/js/bootstrap.js - About 2 hrs to fix

                    Function jqueryTmplTemplateEngine has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        ko.jqueryTmplTemplateEngine = function () {
                            // Detect which version of jquery-tmpl you're using. Unfortunately jquery-tmpl
                            // doesn't expose a version number, so we have to infer it.
                            // Note that as of Knockout 1.3, we only support jQuery.tmpl 1.0.0pre and later,
                            // which KO internally refers to as version "2", so older versions are no longer detected.
                    Severity: Minor
                    Found in www/js/bundle.js - About 1 hr to fix

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

                      },{"../transport":21,"component-inherit":28,"debug":9,"engine.io-parser":29,"parseqs":39,"ws":41}],27:[function(require,module,exports){
                      // browser shim for xmlhttprequest module
                      var hasCORS = require('has-cors');
                      
                      module.exports = function(opts) {
                      Severity: Minor
                      Found in www/js/bundle.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 45 has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                      Open

                      },{}],45:[function(require,module,exports){
                      
                      /**
                       * HOP ref.
                       */
                      Severity: Minor
                      Found in www/js/bundle.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 templateRewriting has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      ko.templateRewriting = (function () {
                          var memoizeDataBindingAttributeSyntaxRegex = /(<([a-z]+\d*)(?:\s+(?!data-bind\s*=\s*)[a-z0-9\-]+(?:=(?:\"[^\"]*\"|\'[^\']*\'))?)*\s+)data-bind\s*=\s*(["'])([\s\S]*?)\3/gi;
                          var memoizeVirtualContainerBindingSyntaxRegex = /<!--\s*ko\b\s*([\s\S]*?)\s*-->/g;
                      
                          function validateDataBindValuesForRewriting(keyValueArray) {
                      Severity: Minor
                      Found in www/js/bundle.js - About 1 hr to fix

                        Function encodePayloadAsArrayBuffer has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        exports.encodePayloadAsArrayBuffer = function(packets, callback) {
                          if (!packets.length) {
                            return callback(new ArrayBuffer(0));
                          }
                        
                        
                        Severity: Minor
                        Found in www/js/bundle.js - About 1 hr to fix

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

                          },{}],5:[function(require,module,exports){
                          function Elapsed (from, to) {
                              this.from = from;
                              this.to = to || new Date();
                              if (!(this.from instanceof Date && this.to instanceof Date)) return;
                          Severity: Minor
                          Found in www/js/bundle.js - About 1 hr to fix

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

                                function decodeSymbol() {
                                    var byte1;
                                    var byte2;
                                    var byte3;
                                    var byte4;
                            Severity: Minor
                            Found in www/js/bundle.js - About 1 hr to fix

                              Function bindingContext has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  ko.bindingContext = function(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback) {
                              
                                      // The binding context object includes static properties for the current, parent, and root view models.
                                      // If a view model is actually stored in an observable, the corresponding binding context object, and
                                      // any child contexts, must be updated when the view model is changed.
                              Severity: Minor
                              Found in www/js/bundle.js - About 1 hr to fix

                                Function Socket has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                function Socket(uri, opts){
                                  if (!(this instanceof Socket)) return new Socket(uri, opts);
                                
                                  opts = opts || {};
                                
                                
                                Severity: Minor
                                Found in www/js/bundle.js - About 1 hr to fix

                                  Function decodeString has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  function decodeString(str) {
                                    var p = {};
                                    var i = 0;
                                  
                                    // look up type
                                  Severity: Minor
                                  Found in www/js/bundle.js - About 1 hr to fix
                                    Severity
                                    Category
                                    Status
                                    Source
                                    Language