Semantic-Org/Semantic-UI

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

Summary

Maintainability
F
2 wks
Test Coverage

Function transition has 912 lines of code (exceeds 25 allowed). Consider refactoring.
Open

$.fn.transition = function() {
  var
    $allModules     = $(this),
    moduleSelector  = $allModules.selector || '',

Severity: Major
Found in src/definitions/modules/transition.js - About 4 days to fix

    File transition.js has 965 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

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

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

                transition: function(forced) {
                  var
                    animation         = settings.animation,
                    transitionExists  = module.get.transitionExists(animation),
                    displayType       = module.get.displayType(false),
      Severity: Major
      Found in src/definitions/modules/transition.js - About 2 hrs to fix

        Function invoke has 54 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/transition.js - About 2 hrs to fix

          Function settings has 32 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                    settings: function(animation, duration, onComplete) {
                      // single settings object
                      if(typeof animation == 'object') {
                        return $.extend(true, {}, $.fn.transition.settings, animation);
                      }
          Severity: Minor
          Found in src/definitions/modules/transition.js - About 1 hr to fix

            Function animate has 31 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    animate: function(overrideSettings) {
                      settings = overrideSettings || settings;
                      if(!module.is.supported()) {
                        module.error(error.support);
                        return false;
            Severity: Minor
            Found in src/definitions/modules/transition.js - About 1 hr to fix

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

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

                Avoid too many return statements within this function.
                Open

                              return $.extend({}, $.fn.transition.settings, {
                                animation  : animation,
                                onComplete : duration
                              });
                Severity: Major
                Found in src/definitions/modules/transition.js - About 30 mins to fix

                  Avoid too many return statements within this function.
                  Open

                                return $.extend({}, $.fn.transition.settings, {
                                  animation : animation
                                });
                  Severity: Major
                  Found in src/definitions/modules/transition.js - About 30 mins to fix

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

                            performance: {
                              log: function(message) {
                                var
                                  currentTime,
                                  executionTime,
                    Severity: Major
                    Found in src/definitions/modules/transition.js and 6 other locations - About 2 days to fix
                    src/definitions/behaviors/form.js on lines 1087..1140
                    src/definitions/modules/dimmer.js on lines 526..579
                    src/definitions/modules/embed.js on lines 447..500
                    src/definitions/modules/rating.js on lines 322..375
                    src/definitions/modules/search.js on lines 1084..1137
                    src/definitions/modules/shape.js on lines 729..782

                    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 483.

                    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/transition.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/sidebar.js on lines 766..782
                    src/definitions/modules/tab.js on lines 695..711

                    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/transition.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/sidebar.js on lines 805..815
                    src/definitions/modules/sticky.js on lines 763..773
                    src/definitions/modules/tab.js on lines 734..744

                    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/transition.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/sidebar.js on lines 794..804
                    src/definitions/modules/sticky.js on lines 752..762
                    src/definitions/modules/tab.js on lines 723..733

                    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 2 locations. Consider refactoring.
                    Open

                              animationEndEvent: function() {
                                var
                                  element     = document.createElement('div'),
                                  animations  = {
                                    'animation'       :'animationend',
                    Severity: Major
                    Found in src/definitions/modules/transition.js and 1 other location - About 2 hrs to fix
                    src/definitions/modules/transition.js on lines 636..653

                    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 92.

                    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

                              animationStartEvent: function() {
                                var
                                  element     = document.createElement('div'),
                                  animations  = {
                                    'animation'       :'animationstart',
                    Severity: Major
                    Found in src/definitions/modules/transition.js and 1 other location - About 2 hrs to fix
                    src/definitions/modules/transition.js on lines 654..671

                    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 92.

                    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/transition.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/sidebar.js on lines 816..821
                    src/definitions/modules/sticky.js on lines 774..779
                    src/definitions/modules/tab.js on lines 745..750

                    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 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/transition.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/sidebar.js on lines 783..793
                    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

                    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 2 locations. Consider refactoring.
                    Open

                            reset: function() {
                              module.debug('Resetting animation to beginning conditions');
                              module.remove.animationCallbacks();
                              module.restore.conditions();
                              module.remove.animating();
                    Severity: Major
                    Found in src/definitions/modules/transition.js and 1 other location - About 1 hr to fix
                    src/definitions/behaviors/visibility.js on lines 851..856

                    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 63.

                    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/transition.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/sidebar.js on lines 15..20
                    src/definitions/modules/sticky.js on lines 15..20
                    src/definitions/modules/tab.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

                    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/transition.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/sidebar.js on lines 39..43
                    src/definitions/modules/sticky.js on lines 59..63

                    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

                      className   : {
                        animating  : 'animating',
                        disabled   : 'disabled',
                        hidden     : 'hidden',
                        inward     : 'in',
                    Severity: Major
                    Found in src/definitions/modules/transition.js and 2 other locations - About 50 mins to fix
                    src/definitions/modules/search.js on lines 1298..1308
                    src/definitions/modules/tab.js on lines 922..932

                    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

                              inward: function() {
                                module.debug('Setting direction to inward');
                                $module
                                  .removeClass(className.outward)
                                  .addClass(className.inward)
                    Severity: Minor
                    Found in src/definitions/modules/transition.js and 2 other locations - About 40 mins to fix
                    src/definitions/modules/dropdown.js on lines 431..437
                    src/definitions/modules/transition.js on lines 376..382

                    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 3 locations. Consider refactoring.
                    Open

                              outward: function() {
                                module.debug('Setting direction to outward');
                                $module
                                  .removeClass(className.inward)
                                  .addClass(className.outward)
                    Severity: Minor
                    Found in src/definitions/modules/transition.js and 2 other locations - About 40 mins to fix
                    src/definitions/modules/dropdown.js on lines 431..437
                    src/definitions/modules/transition.js on lines 369..375

                    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

                    There are no issues that match your filters.

                    Category
                    Status