angelakuo/citydogshare

View on GitHub

Showing 2,136 of 3,976 total issues

File carousel-5f77aa051ee2f35168c30e604c294173a3d9c9f19ac5b6dc0a3c9cf0ea39c697.js has 354 lines of code (exceeds 250 allowed). Consider refactoring.
Open

(function ($) {

  var methods = {

    init : function(options) {

    Function toThrowError has 111 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      function toThrowError () {
        return {
          compare: function(actual) {
            var threw = false,
              pass = {pass: true},

      Function load has 110 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          load: function(src, size, callback) {
      
              if ( typeof size == 'function' ) {
                  callback = size;
                  size = null;

        Function Clock has 108 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        getJasmineRequireObj().Clock = function() {
          function Clock(global, delayedFunctionSchedulerFactory, mockDate) {
            var self = this,
              realTimingFunctions = {
                setTimeout: global.setTimeout,

          Function Spec has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
          Open

          getJasmineRequireObj().Spec = function(j$) {
            function Spec(attrs) {
              this.expectationFactory = attrs.expectationFactory;
              this.resultCallback = attrs.resultCallback || function() {};
              this.id = attrs.id;

          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 Clock has 105 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            function Clock(global, delayedFunctionSchedulerFactory, mockDate) {
              var self = this,
                realTimingFunctions = {
                  setTimeout: global.setTimeout,
                  clearTimeout: global.clearTimeout,

            Function defaultPrefilter has 105 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            function defaultPrefilter( elem, props, opts ) {
                /* jshint validthis: true */
                var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
                    anim = this,
                    orig = {},

              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,

                Function base has 101 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                getJasmineRequireObj().base = function(j$, jasmineGlobal) {
                  j$.unimplementedMethod_ = function() {
                    throw new Error('unimplemented method');
                  };
                
                

                  File ExpectationSpec-1b4b045bde9abb78e2600f612408b2a2ed8eb303c81b2fe3c6a6f8b39db3bd4c.js has 335 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  describe("Expectation", function() {
                    it("makes custom matchers available to this expectation", function() {
                      var matchers = {
                          toFoo: function() {},
                          toBar: function() {}

                    File SpecSpec-9c794c40a2fa9bb73c6c4c7107819de63f9055b606db6b9238dc4d14c3ee97fd.js has 334 lines of code (exceeds 250 allowed). Consider refactoring.
                    Open

                    describe("Spec", function() {
                    
                      it("#isPendingSpecException returns true for a pending spec exception", function() {
                        var e = new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage);
                    
                    

                      Function defaultPrefilter has 99 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      function defaultPrefilter( elem, props, opts ) {
                          /* jshint validthis: true */
                          var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
                              anim = this,
                              orig = {},

                        Function _run has 98 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            _run : function() {
                        
                                var self = this;
                        
                                self._createThumbnails();

                          File matchersUtilSpec-57f374e442cb7e9489d64900f4b4ecbf0b7e973f77ef0dcdb5eb532549c50168.js has 329 lines of code (exceeds 250 allowed). Consider refactoring.
                          Open

                          describe("matchersUtil", function() {
                            describe("equals", function() {
                              it("passes for literals that are triple-equal", function() {
                                expect(jasmineUnderTest.matchersUtil.equals(null, null)).toBe(true);
                                expect(jasmineUnderTest.matchersUtil.equals(void 0, void 0)).toBe(true);

                            `` has 31 functions (exceeds 20 allowed). Consider refactoring.
                            Open

                            {
                                def: 'easeOutQuad',
                                swing: function (x, t, b, c, d) {
                                    //alert(jQuery.easing.default);
                                    return jQuery.easing[jQuery.easing.def](x, t, b, c, d);

                              `` has 31 functions (exceeds 20 allowed). Consider refactoring.
                              Open

                              {
                                  def: 'easeOutQuad',
                                  swing: function (x, t, b, c, d) {
                                      //alert(jQuery.easing.default);
                                      return jQuery.easing[jQuery.easing.def](x, t, b, c, d);

                                `` has 31 functions (exceeds 20 allowed). Consider refactoring.
                                Open

                                {
                                    def: 'easeOutQuad',
                                    swing: function (x, t, b, c, d) {
                                        //alert(jQuery.easing.default);
                                        return jQuery.easing[jQuery.easing.def](x, t, b, c, d);

                                  Function Clock has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  getJasmineRequireObj().Clock = function() {
                                    function Clock(global, delayedFunctionSchedulerFactory, mockDate) {
                                      var self = this,
                                        realTimingFunctions = {
                                          setTimeout: global.setTimeout,

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

                                  ;Materialize.toast = function (message, displayLength, className, completeCallback) {
                                      className = className || "";
                                  
                                      var container = document.getElementById('toast-container');
                                  
                                  

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

                                  Materialize.toast = function (message, displayLength, className, completeCallback) {
                                      className = className || "";
                                  
                                      var container = document.getElementById('toast-container');
                                  
                                  

                                  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

                                  Severity
                                  Category
                                  Status
                                  Source
                                  Language