angelakuo/citydogshare

View on GitHub

Showing 3,976 of 3,976 total issues

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

    parse: function( red, green, blue, alpha ) {
        if ( red === undefined ) {
            this._rgba = [ null, null, null, null ];
            return this;
        }

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

        parse: function( red, green, blue, alpha ) {
            if ( red === undefined ) {
                this._rgba = [ null, null, null, null ];
                return this;
            }

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

                  keydown: function( event ) {
                      if ( this.element.prop( "readOnly" ) ) {
                          suppressKeyPress = true;
                          suppressInput = true;
                          suppressKeyPressRepeat = true;

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

            function createToast(html) {
        
                // Create toast
                var toast = document.createElement('div');
                toast.classList.add('toast');

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

              var Finger = function(elem, options) {
          
                  // default options
                  this.config = {
                      start: 0,

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

                function createToast(html) {
            
                    // Create toast
                    var toast = document.createElement('div');
                    toast.classList.add('toast');

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

                          keydown: function( event ) {
                              if ( this.element.prop( "readOnly" ) ) {
                                  suppressKeyPress = true;
                                  suppressInput = true;
                                  suppressKeyPressRepeat = true;

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

                    parse: function( red, green, blue, alpha ) {
                        if ( red === undefined ) {
                            this._rgba = [ null, null, null, null ];
                            return this;
                        }

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

                  getJasmineRequireObj().util = function() {
                  
                    var util = {};
                  
                    util.inherit = function(childClass, parentClass) {

                  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 ObjectContaining has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                  Open

                  getJasmineRequireObj().ObjectContaining = function(j$) {
                  
                    function ObjectContaining(sample) {
                      this.sample = sample;
                    }

                  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 toThrow has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                  Open

                  getJasmineRequireObj().toThrow = function(j$) {
                  
                    var getErrorMsg = j$.formatErrorMsg('<toThrow>', 'expect(function() {<expectation>}).toThrow()');
                  
                    function toThrow(util) {

                  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 QueryString has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                  Open

                  jasmineRequire.QueryString = function() {
                    function QueryString(options) {
                  
                      this.navigateWithNewParam = function(key, value) {
                        options.getWindowLocation().search = this.fullStringWithNewParam(key, value);

                  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,

                    Function invoke has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                            invoke: function(query, passedArguments, context) {
                              var
                                object = instance,
                                maxDepth,
                                found,

                      Function invoke has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          invoke: function(query, passedArguments, context) {
                            var
                              object = instance,
                              maxDepth,
                              found,

                        Function invoke has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                                invoke: function(query, passedArguments, context) {
                                  var
                                    object = instance,
                                    maxDepth,
                                    found,

                          Function invoke has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                                  invoke: function(query, passedArguments, context) {
                                    var
                                      object = instance,
                                      maxDepth,
                                      found,

                            Function invoke has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                    invoke: function(query, passedArguments, context) {
                                      var
                                        object = instance,
                                        maxDepth,
                                        found,

                              Function invoke has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                      invoke: function(query, passedArguments, context) {
                                        var
                                          object = instance,
                                          maxDepth,
                                          found,

                                Function invoke has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                        invoke: function(query, passedArguments, context) {
                                          var
                                            object = instance,
                                            maxDepth,
                                            found,
                                  Severity
                                  Category
                                  Status
                                  Source
                                  Language