Semantic-Org/Semantic-UI

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

Summary

Maintainability
F
2 wks
Test Coverage

Function modal has 874 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

    File modal.js has 940 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

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

      Function showModal has 58 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              showModal: function(callback) {
                callback = $.isFunction(callback)
                  ? callback
                  : function(){}
                ;
      Severity: Major
      Found in src/definitions/modules/modal.js - About 2 hrs to fix

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

          Function hideModal has 40 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

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

            Function dimmerSettings has 27 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                      dimmerSettings: function() {
                        if($.fn.dimmer === undefined) {
                          module.error(error.dimmer);
                          return;
                        }
            Severity: Minor
            Found in src/definitions/modules/modal.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/modal.js - About 1 hr to fix

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

                        invoke: function(query, passedArguments, context) {
                          var
                            object = instance,
                            maxDepth,
                            found,
                Severity: Major
                Found in src/definitions/modules/modal.js and 6 other locations - About 2 days to fix
                src/definitions/behaviors/form.js on lines 1141..1193
                src/definitions/modules/popup.js on lines 1251..1303
                src/definitions/modules/rating.js on lines 376..428
                src/definitions/modules/search.js on lines 1138..1190
                src/definitions/modules/shape.js on lines 783..835
                src/definitions/modules/sticky.js on lines 831..883

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

                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/modal.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/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/sidebar.js on lines 822..872
                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/modal.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/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
                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/modal.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/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
                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/modal.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/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
                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

                        observeChanges: function() {
                          if('MutationObserver' in window) {
                            observer = new MutationObserver(function(mutations) {
                              module.debug('DOM tree modified, refreshing');
                              module.refresh();
                Severity: Major
                Found in src/definitions/modules/modal.js and 2 other locations - About 2 hrs to fix
                src/definitions/modules/accordion.js on lines 98..110
                src/definitions/modules/checkbox.js on lines 140..152

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

                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

                          approve: function() {
                            if(ignoreRepeatedEvents || settings.onApprove.call(element, $(this)) === false) {
                              module.verbose('Approve callback returned false cancelling hide');
                              return;
                            }
                Severity: Major
                Found in src/definitions/modules/modal.js and 1 other location - About 2 hrs to fix
                src/definitions/modules/modal.js on lines 248..257

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

                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

                          deny: function() {
                            if(ignoreRepeatedEvents || settings.onDeny.call(element, $(this)) === false) {
                              module.verbose('Deny callback returned false cancelling hide');
                              return;
                            }
                Severity: Major
                Found in src/definitions/modules/modal.js and 1 other location - About 2 hrs to fix
                src/definitions/modules/modal.js on lines 235..244

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

                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

                            $module
                              .on('click' + eventNamespace, selector.close, module.event.close)
                              .on('click' + eventNamespace, selector.approve, module.event.approve)
                              .on('click' + eventNamespace, selector.deny, module.event.deny)
                            ;
                Severity: Major
                Found in src/definitions/modules/modal.js and 1 other location - About 2 hrs to fix
                src/definitions/modules/rating.js on lines 168..172

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

                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/modal.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/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
                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/modal.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/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/sidebar.js on lines 930..941
                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/modal.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/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
                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);
                            elementEventNamespace = '.' + id;
                            module.verbose('Creating unique id for element', id);
                          }
                Severity: Major
                Found in src/definitions/modules/modal.js and 3 other locations - About 1 hr to fix
                src/definitions/modules/dropdown.js on lines 188..192
                src/definitions/modules/popup.js on lines 302..306
                src/definitions/modules/sidebar.js on lines 116..120

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

                        settings    = ( $.isPlainObject(parameters) )
                          ? $.extend(true, {}, $.fn.modal.settings, parameters)
                          : $.extend({}, $.fn.modal.settings),
                Severity: Major
                Found in src/definitions/modules/modal.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/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/sidebar.js on lines 51..53
                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/modal.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/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
                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

                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/modal.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/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
                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 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/modal.js and 1 other location - About 35 mins to fix
                src/definitions/modules/sidebar.js on lines 703..709

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

                  className : {
                    active     : 'active',
                    animating  : 'animating',
                    blurring   : 'blurring',
                    inverted   : 'inverted',
                Severity: Minor
                Found in src/definitions/modules/modal.js and 2 other locations - About 35 mins to fix
                src/definitions/modules/dropdown.js on lines 3792..3801
                src/definitions/modules/search.js on lines 1287..1296

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

                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

                            if(settings.blurring) {
                              $dimmable.addClass(className.blurring);
                            }
                            else {
                              $dimmable.removeClass(className.blurring);
                Severity: Minor
                Found in src/definitions/modules/modal.js and 1 other location - About 30 mins to fix
                src/definitions/modules/modal.js on lines 702..707

                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

                            if(settings.inverted) {
                              $dimmer.addClass(className.inverted);
                            }
                            else {
                              $dimmer.removeClass(className.inverted);
                Severity: Minor
                Found in src/definitions/modules/modal.js and 1 other location - About 30 mins to fix
                src/definitions/modules/modal.js on lines 708..713

                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