Semantic-Org/Semantic-UI

View on GitHub
src/definitions/modules/sidebar.js

Summary

Maintainability
F
2 wks
Test Coverage

Function sidebar has 846 lines of code (exceeds 25 allowed). Consider refactoring.
Open

$.fn.sidebar = function(parameters) {
  var
    $allModules     = $(this),
    $window         = $(window),
    $document       = $(document),
Severity: Major
Found in src/definitions/modules/sidebar.js - About 4 days to fix

    File sidebar.js has 925 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /*!
     * # Semantic UI - Sidebar
     * http://github.com/semantic-org/semantic-ui/
     *
     *
    Severity: Major
    Found in src/definitions/modules/sidebar.js - About 2 days to fix

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

                inlineCSS: function() {
                  var
                    width     = module.cache.width  || $module.outerWidth(),
                    height    = module.cache.height || $module.outerHeight(),
                    isRTL     = module.is.rtl(),
      Severity: Major
      Found in src/definitions/modules/sidebar.js - About 2 hrs to fix

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

                invoke: function(query, passedArguments, context) {
                  var
                    object = instance,
                    maxDepth,
                    found,
        Severity: Major
        Found in src/definitions/modules/sidebar.js - About 2 hrs to fix

          Function pushPage has 41 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                  pushPage: function(callback) {
                    var
                      transition = module.get.transition(),
                      $transition = (transition === 'overlay' || module.othersActive())
                        ? $module
          Severity: Minor
          Found in src/definitions/modules/sidebar.js - About 1 hr to fix

            Function pullPage has 38 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    pullPage: function(callback) {
                      var
                        transition = module.get.transition(),
                        $transition = (transition == 'overlay' || module.othersActive())
                          ? $module
            Severity: Minor
            Found in src/definitions/modules/sidebar.js - About 1 hr to fix

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

                      show: function(callback) {
                        callback = $.isFunction(callback)
                          ? callback
                          : function(){}
                        ;
              Severity: Minor
              Found in src/definitions/modules/sidebar.js - About 1 hr to fix

                Function display has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                          display: function() {
                            var
                              title = settings.name + ':',
                              totalTime = 0
                            ;
                Severity: Minor
                Found in src/definitions/modules/sidebar.js - About 1 hr to fix

                  Similar blocks of code found in 12 locations. Consider refactoring.
                  Open

                          invoke: function(query, passedArguments, context) {
                            var
                              object = instance,
                              maxDepth,
                              found,
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 11 other locations - About 2 days to fix
                  src/definitions/behaviors/api.js on lines 950..1003
                  src/definitions/behaviors/visibility.js on lines 1132..1185
                  src/definitions/globals/site.js on lines 351..404
                  src/definitions/modules/accordion.js on lines 482..535
                  src/definitions/modules/checkbox.js on lines 698..751
                  src/definitions/modules/dimmer.js on lines 580..633
                  src/definitions/modules/dropdown.js on lines 3621..3674
                  src/definitions/modules/embed.js on lines 501..554
                  src/definitions/modules/nag.js on lines 365..418
                  src/definitions/modules/progress.js on lines 769..822
                  src/definitions/modules/tab.js on lines 802..855

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 465.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 11 locations. Consider refactoring.
                  Open

                          performance: {
                            log: function(message) {
                              var
                                currentTime,
                                executionTime,
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 10 other locations - About 2 days to fix
                  src/definitions/behaviors/visibility.js on lines 1081..1131
                  src/definitions/modules/accordion.js on lines 431..481
                  src/definitions/modules/checkbox.js on lines 647..697
                  src/definitions/modules/dropdown.js on lines 3570..3620
                  src/definitions/modules/modal.js on lines 826..876
                  src/definitions/modules/nag.js on lines 314..364
                  src/definitions/modules/popup.js on lines 1200..1250
                  src/definitions/modules/progress.js on lines 718..768
                  src/definitions/modules/sticky.js on lines 780..830
                  src/definitions/modules/tab.js on lines 751..801

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 445.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Identical blocks of code found in 14 locations. Consider refactoring.
                  Open

                          setting: function(name, value) {
                            module.debug('Changing setting', name, value);
                            if( $.isPlainObject(name) ) {
                              $.extend(true, settings, name);
                            }
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 13 other locations - About 4 hrs to fix
                  src/definitions/behaviors/api.js on lines 843..859
                  src/definitions/modules/accordion.js on lines 372..388
                  src/definitions/modules/checkbox.js on lines 591..607
                  src/definitions/modules/dimmer.js on lines 470..486
                  src/definitions/modules/dropdown.js on lines 3514..3530
                  src/definitions/modules/embed.js on lines 391..407
                  src/definitions/modules/modal.js on lines 770..786
                  src/definitions/modules/nag.js on lines 258..274
                  src/definitions/modules/progress.js on lines 662..678
                  src/definitions/modules/rating.js on lines 266..282
                  src/definitions/modules/shape.js on lines 673..689
                  src/definitions/modules/tab.js on lines 695..711
                  src/definitions/modules/transition.js on lines 836..852

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 127.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Identical blocks of code found in 19 locations. Consider refactoring.
                  Open

                          verbose: function() {
                            if(!settings.silent && settings.verbose && settings.debug) {
                              if(settings.performance) {
                                module.performance.log(arguments);
                              }
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 18 other locations - About 4 hrs to fix
                  src/definitions/behaviors/api.js on lines 882..892
                  src/definitions/behaviors/form.js on lines 1070..1080
                  src/definitions/behaviors/visibility.js on lines 1064..1074
                  src/definitions/modules/accordion.js on lines 414..424
                  src/definitions/modules/checkbox.js on lines 630..640
                  src/definitions/modules/dimmer.js on lines 509..519
                  src/definitions/modules/dropdown.js on lines 3553..3563
                  src/definitions/modules/embed.js on lines 430..440
                  src/definitions/modules/modal.js on lines 809..819
                  src/definitions/modules/nag.js on lines 297..307
                  src/definitions/modules/popup.js on lines 1183..1193
                  src/definitions/modules/progress.js on lines 701..711
                  src/definitions/modules/rating.js on lines 305..315
                  src/definitions/modules/search.js on lines 1067..1077
                  src/definitions/modules/shape.js on lines 712..722
                  src/definitions/modules/sticky.js on lines 763..773
                  src/definitions/modules/tab.js on lines 734..744
                  src/definitions/modules/transition.js on lines 875..885

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 126.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Identical blocks of code found in 19 locations. Consider refactoring.
                  Open

                          debug: function() {
                            if(!settings.silent && settings.debug) {
                              if(settings.performance) {
                                module.performance.log(arguments);
                              }
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 18 other locations - About 4 hrs to fix
                  src/definitions/behaviors/api.js on lines 871..881
                  src/definitions/behaviors/form.js on lines 1059..1069
                  src/definitions/behaviors/visibility.js on lines 1053..1063
                  src/definitions/modules/accordion.js on lines 403..413
                  src/definitions/modules/checkbox.js on lines 619..629
                  src/definitions/modules/dimmer.js on lines 498..508
                  src/definitions/modules/dropdown.js on lines 3542..3552
                  src/definitions/modules/embed.js on lines 419..429
                  src/definitions/modules/modal.js on lines 798..808
                  src/definitions/modules/nag.js on lines 286..296
                  src/definitions/modules/popup.js on lines 1172..1182
                  src/definitions/modules/progress.js on lines 690..700
                  src/definitions/modules/rating.js on lines 294..304
                  src/definitions/modules/search.js on lines 1056..1066
                  src/definitions/modules/shape.js on lines 701..711
                  src/definitions/modules/sticky.js on lines 752..762
                  src/definitions/modules/tab.js on lines 723..733
                  src/definitions/modules/transition.js on lines 864..874

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 118.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 3 locations. Consider refactoring.
                  Open

                            transitionEvent: function() {
                              var
                                element     = document.createElement('element'),
                                transitions = {
                                  'transition'       :'transitionend',
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 2 other locations - About 2 hrs to fix
                  src/definitions/modules/progress.js on lines 289..305
                  src/definitions/modules/shape.js on lines 487..503

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 89.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Identical blocks of code found in 19 locations. Consider refactoring.
                  Open

                          error: function() {
                            if(!settings.silent) {
                              module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                              module.error.apply(console, arguments);
                            }
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 18 other locations - About 2 hrs to fix
                  src/definitions/behaviors/api.js on lines 893..898
                  src/definitions/behaviors/form.js on lines 1081..1086
                  src/definitions/behaviors/visibility.js on lines 1075..1080
                  src/definitions/modules/accordion.js on lines 425..430
                  src/definitions/modules/checkbox.js on lines 641..646
                  src/definitions/modules/dimmer.js on lines 520..525
                  src/definitions/modules/dropdown.js on lines 3564..3569
                  src/definitions/modules/embed.js on lines 441..446
                  src/definitions/modules/modal.js on lines 820..825
                  src/definitions/modules/nag.js on lines 308..313
                  src/definitions/modules/popup.js on lines 1194..1199
                  src/definitions/modules/progress.js on lines 712..717
                  src/definitions/modules/rating.js on lines 316..321
                  src/definitions/modules/search.js on lines 1078..1083
                  src/definitions/modules/shape.js on lines 723..728
                  src/definitions/modules/sticky.js on lines 774..779
                  src/definitions/modules/tab.js on lines 745..750
                  src/definitions/modules/transition.js on lines 886..891

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 80.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 16 locations. Consider refactoring.
                  Open

                      if(methodInvoked) {
                        if(instance === undefined) {
                          module.initialize();
                        }
                        module.invoke(query);
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 15 other locations - About 2 hrs to fix
                  src/definitions/behaviors/api.js on lines 1006..1017
                  src/definitions/modules/accordion.js on lines 537..548
                  src/definitions/modules/checkbox.js on lines 754..765
                  src/definitions/modules/dimmer.js on lines 638..649
                  src/definitions/modules/dropdown.js on lines 3677..3688
                  src/definitions/modules/embed.js on lines 557..568
                  src/definitions/modules/modal.js on lines 932..943
                  src/definitions/modules/nag.js on lines 421..432
                  src/definitions/modules/popup.js on lines 1306..1317
                  src/definitions/modules/progress.js on lines 825..836
                  src/definitions/modules/rating.js on lines 430..441
                  src/definitions/modules/search.js on lines 1192..1203
                  src/definitions/modules/shape.js on lines 838..849
                  src/definitions/modules/sticky.js on lines 886..897
                  src/definitions/modules/tab.js on lines 857..868

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 75.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 25 locations. Consider refactoring.
                  Open

                          internal: function(name, value) {
                            if( $.isPlainObject(name) ) {
                              $.extend(true, module, name);
                            }
                            else if(value !== undefined) {
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 24 other locations - About 1 hr to fix
                  src/definitions/behaviors/api.js on lines 860..870
                  src/definitions/behaviors/form.js on lines 1037..1047
                  src/definitions/behaviors/form.js on lines 1048..1058
                  src/definitions/behaviors/visibility.js on lines 1031..1041
                  src/definitions/behaviors/visibility.js on lines 1042..1052
                  src/definitions/globals/site.js on lines 255..265
                  src/definitions/globals/site.js on lines 266..276
                  src/definitions/modules/checkbox.js on lines 608..618
                  src/definitions/modules/dimmer.js on lines 487..497
                  src/definitions/modules/dropdown.js on lines 3531..3541
                  src/definitions/modules/embed.js on lines 408..418
                  src/definitions/modules/modal.js on lines 787..797
                  src/definitions/modules/nag.js on lines 275..285
                  src/definitions/modules/popup.js on lines 1150..1160
                  src/definitions/modules/popup.js on lines 1161..1171
                  src/definitions/modules/progress.js on lines 679..689
                  src/definitions/modules/rating.js on lines 283..293
                  src/definitions/modules/search.js on lines 1034..1044
                  src/definitions/modules/search.js on lines 1045..1055
                  src/definitions/modules/shape.js on lines 690..700
                  src/definitions/modules/sticky.js on lines 730..740
                  src/definitions/modules/sticky.js on lines 741..751
                  src/definitions/modules/tab.js on lines 712..722
                  src/definitions/modules/transition.js on lines 853..863

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 74.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 4 locations. Consider refactoring.
                  Open

                            id: function() {
                              id = (Math.random().toString(16) + '000000000').substr(2,8);
                              elementNamespace = '.' + id;
                              module.verbose('Creating unique id for element', id);
                            }
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 3 other locations - About 1 hr to fix
                  src/definitions/modules/dropdown.js on lines 188..192
                  src/definitions/modules/modal.js on lines 133..137
                  src/definitions/modules/popup.js on lines 302..306

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 68.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                                style  += ''
                                  + ' .ui.visible.' + direction + '.sidebar ~ .fixed,'
                                  + ' .ui.visible.' + direction + '.sidebar ~ .pusher {'
                                  + '   -webkit-transform: translate3d(0, ' + distance[direction] + 'px, 0);'
                                  + '           transform: translate3d(0, ' + distance[direction] + 'px, 0);'
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 1 hr to fix
                  src/definitions/modules/sidebar.js on lines 236..242

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 67.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                                style  += ''
                                  + ' .ui.visible.' + direction + '.sidebar ~ .fixed,'
                                  + ' .ui.visible.' + direction + '.sidebar ~ .pusher {'
                                  + '   -webkit-transform: translate3d('+ distance[direction] + 'px, 0, 0);'
                                  + '           transform: translate3d('+ distance[direction] + 'px, 0, 0);'
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 1 hr to fix
                  src/definitions/modules/sidebar.js on lines 245..251

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 67.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 16 locations. Consider refactoring.
                  Open

                          settings        = ( $.isPlainObject(parameters) )
                            ? $.extend(true, {}, $.fn.sidebar.settings, parameters)
                            : $.extend({}, $.fn.sidebar.settings),
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 15 other locations - About 1 hr to fix
                  src/definitions/behaviors/api.js on lines 44..46
                  src/definitions/behaviors/visibility.js on lines 42..44
                  src/definitions/modules/accordion.js on lines 44..46
                  src/definitions/modules/dimmer.js on lines 39..41
                  src/definitions/modules/dropdown.js on lines 42..44
                  src/definitions/modules/embed.js on lines 42..44
                  src/definitions/modules/modal.js on lines 50..52
                  src/definitions/modules/nag.js on lines 38..40
                  src/definitions/modules/popup.js on lines 44..46
                  src/definitions/modules/progress.js on lines 49..51
                  src/definitions/modules/rating.js on lines 38..40
                  src/definitions/modules/search.js on lines 38..40
                  src/definitions/modules/shape.js on lines 47..49
                  src/definitions/modules/sticky.js on lines 39..41
                  src/definitions/modules/tab.js on lines 46..48

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 65.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 18 locations. Consider refactoring.
                  Open

                  window = (typeof window != 'undefined' && window.Math == Math)
                    ? window
                    : (typeof self != 'undefined' && self.Math == Math)
                      ? self
                      : Function('return this')()
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 17 other locations - About 1 hr to fix
                  src/definitions/behaviors/form.js on lines 15..20
                  src/definitions/behaviors/visibility.js on lines 15..20
                  src/definitions/modules/accordion.js on lines 15..20
                  src/definitions/modules/checkbox.js on lines 15..20
                  src/definitions/modules/dimmer.js on lines 15..20
                  src/definitions/modules/dropdown.js on lines 15..20
                  src/definitions/modules/embed.js on lines 15..20
                  src/definitions/modules/modal.js on lines 15..20
                  src/definitions/modules/nag.js on lines 15..20
                  src/definitions/modules/popup.js on lines 15..20
                  src/definitions/modules/progress.js on lines 15..20
                  src/definitions/modules/rating.js on lines 15..20
                  src/definitions/modules/search.js on lines 15..20
                  src/definitions/modules/shape.js on lines 15..20
                  src/definitions/modules/sticky.js on lines 15..20
                  src/definitions/modules/tab.js on lines 15..20
                  src/definitions/modules/transition.js on lines 15..20

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 62.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                    className         : {
                      active    : 'active',
                      animating : 'animating',
                      dimmed    : 'dimmed',
                      ios       : 'ios',
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 1 hr to fix
                  tasks/config/project/install.js on lines 239..251

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 58.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                                  style  += ''
                                    + ' body.pushable > .ui.visible.' + direction + '.sidebar ~ .pusher:after {'
                                    + '   -webkit-transform: translate3d('+ distance[direction] + 'px, 0, 0);'
                                    + '           transform: translate3d('+ distance[direction] + 'px, 0, 0);'
                                    + ' }'
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 1 hr to fix
                  src/definitions/modules/sidebar.js on lines 267..272

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 55.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                                  style  += ''
                                    + ' body.pushable > .ui.visible.' + direction + '.sidebar ~ .pusher:after {'
                                    + '   -webkit-transform: translate3d(0, ' + distance[direction] + 'px, 0);'
                                    + '           transform: translate3d(0, ' + distance[direction] + 'px, 0);'
                                    + ' }'
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 1 hr to fix
                  src/definitions/modules/sidebar.js on lines 259..264

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 55.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Identical blocks of code found in 8 locations. Consider refactoring.
                  Open

                      requestAnimationFrame = window.requestAnimationFrame
                        || window.mozRequestAnimationFrame
                        || window.webkitRequestAnimationFrame
                        || window.msRequestAnimationFrame
                        || function(callback) { setTimeout(callback, 0); },
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 7 other locations - About 50 mins to fix
                  src/definitions/behaviors/visibility.js on lines 64..68
                  src/definitions/modules/accordion.js on lines 33..37
                  src/definitions/modules/modal.js on lines 38..42
                  src/definitions/modules/nag.js on lines 73..77
                  src/definitions/modules/shape.js on lines 34..38
                  src/definitions/modules/sticky.js on lines 59..63
                  src/definitions/modules/transition.js on lines 35..39

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 51.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 3 locations. Consider refactoring.
                  Open

                              if(settings.closable) {
                                $context
                                  .on('click'    + elementNamespace, module.event.clickaway)
                                  .on('touchend' + elementNamespace, module.event.clickaway)
                                ;
                  Severity: Major
                  Found in src/definitions/modules/sidebar.js and 2 other locations - About 40 mins to fix
                  src/definitions/modules/dropdown.js on lines 611..621
                  src/definitions/modules/popup.js on lines 1004..1009

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 49.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                            direction: function(direction) {
                              direction = direction || module.get.direction();
                              $module.removeClass(className[direction]);
                            },
                  Severity: Minor
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 40 mins to fix
                  src/definitions/modules/sidebar.js on lines 597..600

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 48.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                            direction: function(direction) {
                              direction = direction || module.get.direction();
                              $module.addClass(className[direction]);
                            },
                  Severity: Minor
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 40 mins to fix
                  src/definitions/modules/sidebar.js on lines 641..644

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 48.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                            ie: function() {
                              var
                                isIE11 = (!(window.ActiveXObject) && 'ActiveXObject' in window),
                                isIE   = ('ActiveXObject' in window)
                              ;
                  Severity: Minor
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 35 mins to fix
                  src/definitions/modules/modal.js on lines 632..638

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 47.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                          othersAnimating: function() {
                            return ($sidebars.not($module).filter('.' + className.animating).length > 0);
                          },
                  Severity: Minor
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 30 mins to fix
                  src/definitions/modules/sidebar.js on lines 425..427

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 45.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 2 locations. Consider refactoring.
                  Open

                          othersVisible: function() {
                            return ($sidebars.not($module).filter('.' + className.visible).length > 0);
                          },
                  Severity: Minor
                  Found in src/definitions/modules/sidebar.js and 1 other location - About 30 mins to fix
                  src/definitions/modules/sidebar.js on lines 422..424

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 45.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  There are no issues that match your filters.

                  Category
                  Status