Semantic-Org/Semantic-UI

View on GitHub
src/definitions/behaviors/api.js

Summary

Maintainability
F
2 wks
Test Coverage

Function api has 914 lines of code (exceeds 25 allowed). Consider refactoring.
Open

$.api = $.fn.api = function(parameters) {

  var
    // use window context if none specified
    $allModules     = $.isFunction(this)
Severity: Major
Found in src/definitions/behaviors/api.js - About 4 days to fix

    File api.js has 1000 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

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

      Function query has 78 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              query: function() {
      
                if(module.is.disabled()) {
                  module.debug('Element is disabled API request aborted');
                  return;
      Severity: Major
      Found in src/definitions/behaviors/api.js - About 3 hrs to fix

        Function urlData has 70 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

                  urlData: function(url, urlData) {
                    var
                      requiredVariables,
                      optionalVariables
                    ;
        Severity: Major
        Found in src/definitions/behaviors/api.js - About 2 hrs to fix

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

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

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

                      mockedXHR: function () {
                        var
                          // xhr does not simulate these properties of xhr but must return them
                          textStatus     = false,
                          status         = false,
            Severity: Minor
            Found in src/definitions/behaviors/api.js - About 1 hr to fix

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

                        settings: function() {
                          var
                            runSettings
                          ;
                          runSettings = settings.beforeSend.call(context, settings);
              Severity: Minor
              Found in src/definitions/behaviors/api.js - About 1 hr to fix

                Function fail has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                            fail: function(xhr, status, httpMessage) {
                              var
                                // pull response from xhr if available
                                response     = module.get.responseFromXHR(xhr),
                                errorMessage = module.get.errorFromRequest(response, status, httpMessage)
                Severity: Minor
                Found in src/definitions/behaviors/api.js - About 1 hr to fix

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

                              done: function(response, textStatus, xhr) {
                                var
                                  context            = this,
                                  elapsedTime        = (new Date().getTime() - requestStartTime),
                                  timeLeft           = (settings.loadingDuration - elapsedTime),
                  Severity: Minor
                  Found in src/definitions/behaviors/api.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/behaviors/api.js - About 1 hr to fix

                      Avoid too many return statements within this function.
                      Open

                                    return settings.on;
                      Severity: Major
                      Found in src/definitions/behaviors/api.js - About 30 mins to fix

                        Avoid too many return statements within this function.
                        Open

                                    return;
                        Severity: Major
                        Found in src/definitions/behaviors/api.js - About 30 mins to fix

                          Avoid too many return statements within this function.
                          Open

                                      return;
                          Severity: Major
                          Found in src/definitions/behaviors/api.js - About 30 mins 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/behaviors/api.js and 11 other locations - About 2 days to fix
                            src/definitions/behaviors/visibility.js on lines 1132..1185
                            src/definitions/globals/site.js on lines 351..404
                            src/definitions/modules/accordion.js on lines 482..535
                            src/definitions/modules/checkbox.js on lines 698..751
                            src/definitions/modules/dimmer.js on lines 580..633
                            src/definitions/modules/dropdown.js on lines 3621..3674
                            src/definitions/modules/embed.js on lines 501..554
                            src/definitions/modules/nag.js on lines 365..418
                            src/definitions/modules/progress.js on lines 769..822
                            src/definitions/modules/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 2 locations. Consider refactoring.
                            Open

                                              var
                                                // allow legacy {/$var} style
                                                variable = (templatedString.indexOf('$') !== -1)
                                                  ? templatedString.substr(3, templatedString.length - 4)
                                                  : templatedString.substr(2, templatedString.length - 3),
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 1 other location - About 6 hrs to fix
                            src/definitions/behaviors/api.js on lines 358..370

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

                            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

                                              var
                                                // allow legacy {$var} style
                                                variable = (templatedString.indexOf('$') !== -1)
                                                  ? templatedString.substr(2, templatedString.length - 3)
                                                  : templatedString.substr(1, templatedString.length - 2),
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 1 other location - About 6 hrs to fix
                            src/definitions/behaviors/api.js on lines 390..402

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

                            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/behaviors/api.js and 13 other locations - About 4 hrs to fix
                            src/definitions/modules/accordion.js on lines 372..388
                            src/definitions/modules/checkbox.js on lines 591..607
                            src/definitions/modules/dimmer.js on lines 470..486
                            src/definitions/modules/dropdown.js on lines 3514..3530
                            src/definitions/modules/embed.js on lines 391..407
                            src/definitions/modules/modal.js on lines 770..786
                            src/definitions/modules/nag.js on lines 258..274
                            src/definitions/modules/progress.js on lines 662..678
                            src/definitions/modules/rating.js on lines 266..282
                            src/definitions/modules/shape.js on lines 673..689
                            src/definitions/modules/sidebar.js on lines 766..782
                            src/definitions/modules/tab.js on lines 695..711
                            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/behaviors/api.js and 18 other locations - About 4 hrs to fix
                            src/definitions/behaviors/form.js on lines 1070..1080
                            src/definitions/behaviors/visibility.js on lines 1064..1074
                            src/definitions/modules/accordion.js on lines 414..424
                            src/definitions/modules/checkbox.js on lines 630..640
                            src/definitions/modules/dimmer.js on lines 509..519
                            src/definitions/modules/dropdown.js on lines 3553..3563
                            src/definitions/modules/embed.js on lines 430..440
                            src/definitions/modules/modal.js on lines 809..819
                            src/definitions/modules/nag.js on lines 297..307
                            src/definitions/modules/popup.js on lines 1183..1193
                            src/definitions/modules/progress.js on lines 701..711
                            src/definitions/modules/rating.js on lines 305..315
                            src/definitions/modules/search.js on lines 1067..1077
                            src/definitions/modules/shape.js on lines 712..722
                            src/definitions/modules/sidebar.js on lines 805..815
                            src/definitions/modules/sticky.js on lines 763..773
                            src/definitions/modules/tab.js on lines 734..744
                            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/behaviors/api.js and 18 other locations - About 4 hrs to fix
                            src/definitions/behaviors/form.js on lines 1059..1069
                            src/definitions/behaviors/visibility.js on lines 1053..1063
                            src/definitions/modules/accordion.js on lines 403..413
                            src/definitions/modules/checkbox.js on lines 619..629
                            src/definitions/modules/dimmer.js on lines 498..508
                            src/definitions/modules/dropdown.js on lines 3542..3552
                            src/definitions/modules/embed.js on lines 419..429
                            src/definitions/modules/modal.js on lines 798..808
                            src/definitions/modules/nag.js on lines 286..296
                            src/definitions/modules/popup.js on lines 1172..1182
                            src/definitions/modules/progress.js on lines 690..700
                            src/definitions/modules/rating.js on lines 294..304
                            src/definitions/modules/search.js on lines 1056..1066
                            src/definitions/modules/shape.js on lines 701..711
                            src/definitions/modules/sidebar.js on lines 794..804
                            src/definitions/modules/sticky.js on lines 752..762
                            src/definitions/modules/tab.js on lines 723..733
                            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

                            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/behaviors/api.js and 18 other locations - About 2 hrs to fix
                            src/definitions/behaviors/form.js on lines 1081..1086
                            src/definitions/behaviors/visibility.js on lines 1075..1080
                            src/definitions/modules/accordion.js on lines 425..430
                            src/definitions/modules/checkbox.js on lines 641..646
                            src/definitions/modules/dimmer.js on lines 520..525
                            src/definitions/modules/dropdown.js on lines 3564..3569
                            src/definitions/modules/embed.js on lines 441..446
                            src/definitions/modules/modal.js on lines 820..825
                            src/definitions/modules/nag.js on lines 308..313
                            src/definitions/modules/popup.js on lines 1194..1199
                            src/definitions/modules/progress.js on lines 712..717
                            src/definitions/modules/rating.js on lines 316..321
                            src/definitions/modules/search.js on lines 1078..1083
                            src/definitions/modules/shape.js on lines 723..728
                            src/definitions/modules/sidebar.js on lines 816..821
                            src/definitions/modules/sticky.js on lines 774..779
                            src/definitions/modules/tab.js on lines 745..750
                            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/behaviors/api.js and 15 other locations - About 2 hrs to fix
                            src/definitions/modules/accordion.js on lines 537..548
                            src/definitions/modules/checkbox.js on lines 754..765
                            src/definitions/modules/dimmer.js on lines 638..649
                            src/definitions/modules/dropdown.js on lines 3677..3688
                            src/definitions/modules/embed.js on lines 557..568
                            src/definitions/modules/modal.js on lines 932..943
                            src/definitions/modules/nag.js on lines 421..432
                            src/definitions/modules/popup.js on lines 1306..1317
                            src/definitions/modules/progress.js on lines 825..836
                            src/definitions/modules/rating.js on lines 430..441
                            src/definitions/modules/search.js on lines 1192..1203
                            src/definitions/modules/shape.js on lines 838..849
                            src/definitions/modules/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/behaviors/api.js and 24 other locations - About 1 hr to fix
                            src/definitions/behaviors/form.js on lines 1037..1047
                            src/definitions/behaviors/form.js on lines 1048..1058
                            src/definitions/behaviors/visibility.js on lines 1031..1041
                            src/definitions/behaviors/visibility.js on lines 1042..1052
                            src/definitions/globals/site.js on lines 255..265
                            src/definitions/globals/site.js on lines 266..276
                            src/definitions/modules/checkbox.js on lines 608..618
                            src/definitions/modules/dimmer.js on lines 487..497
                            src/definitions/modules/dropdown.js on lines 3531..3541
                            src/definitions/modules/embed.js on lines 408..418
                            src/definitions/modules/modal.js on lines 787..797
                            src/definitions/modules/nag.js on lines 275..285
                            src/definitions/modules/popup.js on lines 1150..1160
                            src/definitions/modules/popup.js on lines 1161..1171
                            src/definitions/modules/progress.js on lines 679..689
                            src/definitions/modules/rating.js on lines 283..293
                            src/definitions/modules/search.js on lines 1034..1044
                            src/definitions/modules/search.js on lines 1045..1055
                            src/definitions/modules/shape.js on lines 690..700
                            src/definitions/modules/sidebar.js on lines 783..793
                            src/definitions/modules/sticky.js on lines 730..740
                            src/definitions/modules/sticky.js on lines 741..751
                            src/definitions/modules/tab.js on lines 712..722
                            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 2 locations. Consider refactoring.
                            Open

                                        return $.Deferred()
                                          .always(module.event.request.complete)
                                          .done(module.event.request.done)
                                          .fail(module.event.request.fail)
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 1 other location - About 1 hr to fix
                            src/definitions/behaviors/api.js on lines 620..623

                            Duplicated Code

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

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

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

                            Tuning

                            This issue has a mass of 68.

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

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

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

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

                            Refactorings

                            Further Reading

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

                                        mockedXHR = $.Deferred()
                                          .always(module.event.xhr.complete)
                                          .done(module.event.xhr.done)
                                          .fail(module.event.xhr.fail)
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 1 other location - About 1 hr to fix
                            src/definitions/behaviors/api.js on lines 600..603

                            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.api.settings, parameters)
                                      : $.extend({}, $.fn.api.settings),
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 15 other locations - About 1 hr to fix
                            src/definitions/behaviors/visibility.js on lines 42..44
                            src/definitions/modules/accordion.js on lines 44..46
                            src/definitions/modules/dimmer.js on lines 39..41
                            src/definitions/modules/dropdown.js on lines 42..44
                            src/definitions/modules/embed.js on lines 42..44
                            src/definitions/modules/modal.js on lines 50..52
                            src/definitions/modules/nag.js on lines 38..40
                            src/definitions/modules/popup.js on lines 44..46
                            src/definitions/modules/progress.js on lines 49..51
                            src/definitions/modules/rating.js on lines 38..40
                            src/definitions/modules/search.js on lines 38..40
                            src/definitions/modules/shape.js on lines 47..49
                            src/definitions/modules/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 3 locations. Consider refactoring.
                            Open

                                          if(runSettings.success !== undefined) {
                                            module.debug('Legacy success callback detected', runSettings);
                                            module.error(error.legacyParameters, runSettings.success);
                                            runSettings.onSuccess = runSettings.success;
                                          }
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 2 other locations - About 1 hr to fix
                            src/definitions/behaviors/api.js on lines 727..731
                            src/definitions/behaviors/api.js on lines 732..736

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

                                          if(runSettings.failure !== undefined) {
                                            module.debug('Legacy failure callback detected', runSettings);
                                            module.error(error.legacyParameters, runSettings.failure);
                                            runSettings.onFailure = runSettings.failure;
                                          }
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 2 other locations - About 1 hr to fix
                            src/definitions/behaviors/api.js on lines 722..726
                            src/definitions/behaviors/api.js on lines 732..736

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

                                          if(runSettings.complete !== undefined) {
                                            module.debug('Legacy complete callback detected', runSettings);
                                            module.error(error.legacyParameters, runSettings.complete);
                                            runSettings.onComplete = runSettings.complete;
                                          }
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 2 other locations - About 1 hr to fix
                            src/definitions/behaviors/api.js on lines 722..726
                            src/definitions/behaviors/api.js on lines 727..731

                            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

                            var
                              window = (typeof window != 'undefined' && window.Math == Math)
                                ? window
                                : (typeof self != 'undefined' && self.Math == Math)
                                  ? self
                            Severity: Major
                            Found in src/definitions/behaviors/api.js and 1 other location - About 1 hr to fix
                            src/definitions/modules/progress.js on lines 22..28

                            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

                            There are no issues that match your filters.

                            Category
                            Status