Sign upLogin

Semantic-Org/Semantic-UI

View on GitHub
Star
src/definitions/modules/checkbox.js

Summary

Maintainability
F
2 wks
Test Coverage

Function checkbox has 704 lines of code (exceeds 25 allowed). Consider refactoring.
Open

$.fn.checkbox = function(parameters) {
  var
    $allModules    = $(this),
    moduleSelector = $allModules.selector || '',
Severity: Major
Found in src/definitions/modules/checkbox.js - About 3 days to fix

    File checkbox.js has 755 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /*!
 * # Semantic UI - Checkbox
 * http://github.com/semantic-org/semantic-ui/
 *
 *
    Severity: Major
    Found in src/definitions/modules/checkbox.js - About 1 day to fix

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

              invoke: function(query, passedArguments, context) {
          var
            object = instance,
            maxDepth,
            found,
      Severity: Major
      Found in src/definitions/modules/checkbox.js - About 2 hrs 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/checkbox.js - About 1 hr to fix

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

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

          Duplicated Code

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

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

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

          Tuning

          This issue has a mass of 465.

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

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

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

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

          Refactorings

          Further Reading

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

                  performance: {
          log: function(message) {
            var
              currentTime,
              executionTime,
          Severity: Major
          Found in src/definitions/modules/checkbox.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/dropdown.js on lines 3570..3620
          src/definitions/modules/modal.js on lines 826..876
          src/definitions/modules/nag.js on lines 314..364
          src/definitions/modules/popup.js on lines 1200..1250
          src/definitions/modules/progress.js on lines 718..768
          src/definitions/modules/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/checkbox.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/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
          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/checkbox.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/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
          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/checkbox.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/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
          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 2 locations. Consider refactoring.
          Open

                  indeterminate: function() {
          if( module.should.allowIndeterminate() ) {
            module.debug('Checkbox is already indeterminate');
            return;
          }
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 4 hrs to fix
          src/definitions/modules/checkbox.js on lines 257..268

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

          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

                  determinate: function() {
          if( module.should.allowDeterminate() ) {
            module.debug('Checkbox is already determinate');
            return;
          }
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 4 hrs to fix
          src/definitions/modules/checkbox.js on lines 244..255

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

          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

                    allowCheck: function() {
            if(module.is.determinate() && module.is.checked() && !module.should.forceCallbacks() ) {
              module.debug('Should not allow check, checkbox is already checked');
              return false;
            }
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 3 hrs to fix
          src/definitions/modules/checkbox.js on lines 348..358

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

          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

                    allowUncheck: function() {
            if(module.is.determinate() && module.is.unchecked() && !module.should.forceCallbacks() ) {
              module.debug('Should not allow uncheck, checkbox is already unchecked');
              return false;
            }
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 3 hrs to fix
          src/definitions/modules/checkbox.js on lines 337..347

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

          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

                    indeterminate: function() {
            module.verbose('Setting class to indeterminate');
            $module
              .addClass(className.indeterminate)
            ;
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 3 hrs to fix
          src/definitions/modules/checkbox.js on lines 486..498

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

          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

                    enabled: function() {
            module.verbose('Removing disabled class');
            $module.removeClass(className.disabled);
            if( module.is.enabled() ) {
              module.debug('Input is already enabled, skipping input property change');
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 3 hrs to fix
          src/definitions/modules/checkbox.js on lines 442..456

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

          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

                    allowIndeterminate: function() {
            if(module.is.indeterminate() && !module.should.forceCallbacks() ) {
              module.debug('Should not allow indeterminate, checkbox is already indeterminate');
              return false;
            }
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 3 hrs to fix
          src/definitions/modules/checkbox.js on lines 370..380

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

          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

                    allowDeterminate: function() {
            if(module.is.determinate() && !module.should.forceCallbacks() ) {
              module.debug('Should not allow determinate, checkbox is already determinate');
              return false;
            }
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 3 hrs to fix
          src/definitions/modules/checkbox.js on lines 359..369

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

          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

                  disable: function() {
          if( module.is.disabled() ) {
            module.debug('Checkbox is already disabled');
            return;
          }
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 3 hrs to fix
          src/definitions/modules/checkbox.js on lines 270..280

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

          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

                  enable: function() {
          if( module.is.enabled() ) {
            module.debug('Checkbox is already enabled');
            return;
          }
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 3 hrs to fix
          src/definitions/modules/checkbox.js on lines 282..292

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

          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, updating selector cache');
              module.refresh();
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 2 other locations - About 2 hrs to fix
          src/definitions/modules/accordion.js on lines 98..110
          src/definitions/modules/modal.js on lines 155..167

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

            var
    $allModules    = $(this),
    moduleSelector = $allModules.selector || '',

    time           = new Date().getTime(),
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 6 other locations - About 2 hrs to fix
          src/definitions/modules/embed.js on lines 24..37
          src/definitions/modules/nag.js on lines 23..34
          src/definitions/modules/progress.js on lines 31..44
          src/definitions/modules/rating.js on lines 23..34
          src/definitions/modules/search.js on lines 23..34
          src/definitions/modules/sticky.js on lines 23..34

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

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

                  trigger: {
          change: function() {
            var
              events       = document.createEvent('HTMLEvents'),
              inputElement = $input[0]
          Severity: Major
          Found in src/definitions/modules/checkbox.js and 1 other location - About 2 hrs to fix
          src/definitions/modules/dropdown.js on lines 1535..1547

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

          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/checkbox.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/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
          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/checkbox.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/dimmer.js on lines 638..649
          src/definitions/modules/dropdown.js on lines 3677..3688
          src/definitions/modules/embed.js on lines 557..568
          src/definitions/modules/modal.js on lines 932..943
          src/definitions/modules/nag.js on lines 421..432
          src/definitions/modules/popup.js on lines 1306..1317
          src/definitions/modules/progress.js on lines 825..836
          src/definitions/modules/rating.js on lines 430..441
          src/definitions/modules/search.js on lines 1192..1203
          src/definitions/modules/shape.js on lines 838..849
          src/definitions/modules/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/checkbox.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/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
          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 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/checkbox.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/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
          src/definitions/modules/transition.js on lines 15..20

          Duplicated Code

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

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

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

          Tuning

          This issue has a mass of 62.

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

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

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

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

          Refactorings

          Further Reading

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

                      if(!module.is.indeterminate() && module.is.checked()) {
              module.debug('Input is already checked, skipping input property change');
              return;
            }
          Severity: Minor
          Found in src/definitions/modules/checkbox.js and 1 other location - About 35 mins to fix
          src/definitions/modules/checkbox.js on lines 431..434

          Duplicated Code

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

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

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

          Tuning

          This issue has a mass of 47.

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

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

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

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

          Refactorings

          Further Reading

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

                      if(!module.is.indeterminate() &&  module.is.unchecked() ) {
              module.debug('Input is already unchecked');
              return;
            }
          Severity: Minor
          Found in src/definitions/modules/checkbox.js and 1 other location - About 35 mins to fix
          src/definitions/modules/checkbox.js on lines 414..417

          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

          There are no issues that match your filters.

          Category
          Status