Semantic-Org/Semantic-UI

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

Summary

Maintainability
F
3 wks
Test Coverage

Function search has 1124 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

    File search.js has 1369 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

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

      Function handleKeyboard has 76 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              handleKeyboard: function(event) {
                var
                  // force selector refresh
                  $result         = $module.find(selector.result),
                  $category       = $module.find(selector.category),
      Severity: Major
      Found in src/definitions/modules/search.js - About 3 hrs to fix

        Function category has 56 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            category: function(response, fields) {
              var
                html = '',
                escape = $.fn.search.settings.templates.escape
              ;
        Severity: Major
        Found in src/definitions/modules/search.js - About 2 hrs to fix

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

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

            Function object has 50 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                      object: function(searchTerm, source, searchFields) {
                        var
                          results      = [],
                          exactResults = [],
                          fuzzyResults = [],
            Severity: Minor
            Found in src/definitions/modules/search.js - About 2 hrs to fix

              Function standard has 42 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  standard: function(response, fields) {
                    var
                      html = ''
                    ;
                    if(response[fields.results] !== undefined) {
              Severity: Minor
              Found in src/definitions/modules/search.js - About 1 hr to fix

                Function click has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                            click: function(event) {
                              module.debug('Search result selected');
                              var
                                $result = $(this),
                                $title  = $result.find(selector.title).eq(0),
                Severity: Minor
                Found in src/definitions/modules/search.js - About 1 hr to fix

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

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

                    Function id has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                              id: function(results) {
                                module.debug('Injecting unique ids into results');
                                var
                                  // since results may be object, we must use counters
                                  categoryIndex = 0,
                    Severity: Minor
                    Found in src/definitions/modules/search.js - About 1 hr to fix

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

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

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

                                  blur: function(event) {
                                    var
                                      pageLostFocus = (document.activeElement === this),
                                      callback      = function() {
                                        module.cancel.query();
                        Severity: Minor
                        Found in src/definitions/modules/search.js - About 1 hr to fix

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

                                  generateResults: function(response) {
                                    module.debug('Generating html from response', response);
                                    var
                                      template       = settings.templates[settings.type],
                                      isProperObject = ($.isPlainObject(response[fields.results]) && !$.isEmptyObject(response[fields.results])),
                          Severity: Minor
                          Found in src/definitions/modules/search.js - About 1 hr to fix

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

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

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

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

                                Function result has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                          result: function(value, results) {
                                            var
                                              lookupFields = ['title', 'id'],
                                              result       = false
                                            ;
                                Severity: Minor
                                Found in src/definitions/modules/search.js - About 1 hr to fix

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

                                          fuzzySearch: function(query, term) {
                                            var
                                              termLength  = term.length,
                                              queryLength = query.length
                                            ;
                                  Severity: Minor
                                  Found in src/definitions/modules/search.js - About 1 hr to fix

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

                                              api: function(searchTerm, callback) {
                                                var
                                                  apiSettings = {
                                                    debug             : settings.debug,
                                                    on                : false,
                                    Severity: Minor
                                    Found in src/definitions/modules/search.js - About 1 hr to fix

                                      Avoid too many return statements within this function.
                                      Open

                                                return true;
                                      Severity: Major
                                      Found in src/definitions/modules/search.js - About 30 mins to fix

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

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

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 483.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

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

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 449.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

                                                $.each(response[fields.results], function(index, result) {
                                                  if(result[fields.url]) {
                                                    html  += '<a class="result" href="' + result[fields.url] + '">';
                                                  }
                                                  else {
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 1 day to fix
                                        src/definitions/modules/search.js on lines 1410..1438

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

                                        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

                                                    $.each(category.results, function(index, result) {
                                                      if(result[fields.url]) {
                                                        html  += '<a class="result" href="' + result[fields.url] + '">';
                                                      }
                                                      else {
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 1 day to fix
                                        src/definitions/modules/search.js on lines 1462..1490

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

                                        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.visible() ) {
                                                    if( module.can.transition() ) {
                                                      module.debug('Hiding results with css animations');
                                                      $results
                                                        .transition({
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 6 hrs to fix
                                        src/definitions/modules/search.js on lines 936..960

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

                                        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.visible() && module.has.results()) {
                                                    if( module.can.transition() ) {
                                                      module.debug('Showing results with css animations');
                                                      $results
                                                        .transition({
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 6 hrs to fix
                                        src/definitions/modules/search.js on lines 967..991

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

                                        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/search.js and 18 other locations - About 4 hrs to fix
                                        src/definitions/behaviors/api.js on lines 882..892
                                        src/definitions/behaviors/form.js on lines 1070..1080
                                        src/definitions/behaviors/visibility.js on lines 1064..1074
                                        src/definitions/modules/accordion.js on lines 414..424
                                        src/definitions/modules/checkbox.js on lines 630..640
                                        src/definitions/modules/dimmer.js on lines 509..519
                                        src/definitions/modules/dropdown.js on lines 3553..3563
                                        src/definitions/modules/embed.js on lines 430..440
                                        src/definitions/modules/modal.js on lines 809..819
                                        src/definitions/modules/nag.js on lines 297..307
                                        src/definitions/modules/popup.js on lines 1183..1193
                                        src/definitions/modules/progress.js on lines 701..711
                                        src/definitions/modules/rating.js on lines 305..315
                                        src/definitions/modules/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/search.js and 18 other locations - About 4 hrs to fix
                                        src/definitions/behaviors/api.js on lines 871..881
                                        src/definitions/behaviors/form.js on lines 1059..1069
                                        src/definitions/behaviors/visibility.js on lines 1053..1063
                                        src/definitions/modules/accordion.js on lines 403..413
                                        src/definitions/modules/checkbox.js on lines 619..629
                                        src/definitions/modules/dimmer.js on lines 498..508
                                        src/definitions/modules/dropdown.js on lines 3542..3552
                                        src/definitions/modules/embed.js on lines 419..429
                                        src/definitions/modules/modal.js on lines 798..808
                                        src/definitions/modules/nag.js on lines 286..296
                                        src/definitions/modules/popup.js on lines 1172..1182
                                        src/definitions/modules/progress.js on lines 690..700
                                        src/definitions/modules/rating.js on lines 294..304
                                        src/definitions/modules/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 2 locations. Consider refactoring.
                                        Open

                                            escape: function(string) {
                                              var
                                                badChars     = /[&<>"'`]/g,
                                                shouldEscape = /[&<>"'`]/,
                                                escape       = {
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 3 hrs to fix
                                        src/definitions/modules/popup.js on lines 1489..1509

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

                                        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/search.js and 6 other locations - About 2 hrs to fix
                                        src/definitions/modules/checkbox.js on lines 23..34
                                        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/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

                                                  search: for (var characterIndex = 0, nextCharacterIndex = 0; characterIndex < queryLength; characterIndex++) {
                                                    var
                                                      queryCharacter = query.charCodeAt(characterIndex)
                                                    ;
                                                    while(nextCharacterIndex < termLength) {
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 2 hrs to fix
                                        src/definitions/modules/dropdown.js on lines 861..871

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

                                        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/search.js and 18 other locations - About 2 hrs to fix
                                        src/definitions/behaviors/api.js on lines 893..898
                                        src/definitions/behaviors/form.js on lines 1081..1086
                                        src/definitions/behaviors/visibility.js on lines 1075..1080
                                        src/definitions/modules/accordion.js on lines 425..430
                                        src/definitions/modules/checkbox.js on lines 641..646
                                        src/definitions/modules/dimmer.js on lines 520..525
                                        src/definitions/modules/dropdown.js on lines 3564..3569
                                        src/definitions/modules/embed.js on lines 441..446
                                        src/definitions/modules/modal.js on lines 820..825
                                        src/definitions/modules/nag.js on lines 308..313
                                        src/definitions/modules/popup.js on lines 1194..1199
                                        src/definitions/modules/progress.js on lines 712..717
                                        src/definitions/modules/rating.js on lines 316..321
                                        src/definitions/modules/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/search.js and 15 other locations - About 2 hrs to fix
                                        src/definitions/behaviors/api.js on lines 1006..1017
                                        src/definitions/modules/accordion.js on lines 537..548
                                        src/definitions/modules/checkbox.js on lines 754..765
                                        src/definitions/modules/dimmer.js on lines 638..649
                                        src/definitions/modules/dropdown.js on lines 3677..3688
                                        src/definitions/modules/embed.js on lines 557..568
                                        src/definitions/modules/modal.js on lines 932..943
                                        src/definitions/modules/nag.js on lines 421..432
                                        src/definitions/modules/popup.js on lines 1306..1317
                                        src/definitions/modules/progress.js on lines 825..836
                                        src/definitions/modules/rating.js on lines 430..441
                                        src/definitions/modules/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/search.js and 24 other locations - About 1 hr to fix
                                        src/definitions/behaviors/api.js on lines 860..870
                                        src/definitions/behaviors/form.js on lines 1037..1047
                                        src/definitions/behaviors/form.js on lines 1048..1058
                                        src/definitions/behaviors/visibility.js on lines 1031..1041
                                        src/definitions/behaviors/visibility.js on lines 1042..1052
                                        src/definitions/globals/site.js on lines 255..265
                                        src/definitions/globals/site.js on lines 266..276
                                        src/definitions/modules/checkbox.js on lines 608..618
                                        src/definitions/modules/dimmer.js on lines 487..497
                                        src/definitions/modules/dropdown.js on lines 3531..3541
                                        src/definitions/modules/embed.js on lines 408..418
                                        src/definitions/modules/modal.js on lines 787..797
                                        src/definitions/modules/nag.js on lines 275..285
                                        src/definitions/modules/popup.js on lines 1150..1160
                                        src/definitions/modules/popup.js on lines 1161..1171
                                        src/definitions/modules/progress.js on lines 679..689
                                        src/definitions/modules/rating.js on lines 283..293
                                        src/definitions/modules/search.js on lines 1034..1044
                                        src/definitions/modules/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

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

                                                if(response[fields.action]) {
                                                  html += ''
                                                  + '<a href="' + response[fields.action][fields.actionURL] + '" class="action">'
                                                  +   response[fields.action][fields.actionText]
                                                  + '</a>';
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 1 hr to fix
                                        src/definitions/modules/search.js on lines 1492..1497

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

                                                setting: function(name, value) {
                                                  if( $.isPlainObject(name) ) {
                                                    $.extend(true, settings, name);
                                                  }
                                                  else if(value !== undefined) {
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 24 other locations - About 1 hr to fix
                                        src/definitions/behaviors/api.js on lines 860..870
                                        src/definitions/behaviors/form.js on lines 1037..1047
                                        src/definitions/behaviors/form.js on lines 1048..1058
                                        src/definitions/behaviors/visibility.js on lines 1031..1041
                                        src/definitions/behaviors/visibility.js on lines 1042..1052
                                        src/definitions/globals/site.js on lines 255..265
                                        src/definitions/globals/site.js on lines 266..276
                                        src/definitions/modules/checkbox.js on lines 608..618
                                        src/definitions/modules/dimmer.js on lines 487..497
                                        src/definitions/modules/dropdown.js on lines 3531..3541
                                        src/definitions/modules/embed.js on lines 408..418
                                        src/definitions/modules/modal.js on lines 787..797
                                        src/definitions/modules/nag.js on lines 275..285
                                        src/definitions/modules/popup.js on lines 1150..1160
                                        src/definitions/modules/popup.js on lines 1161..1171
                                        src/definitions/modules/progress.js on lines 679..689
                                        src/definitions/modules/rating.js on lines 283..293
                                        src/definitions/modules/search.js on lines 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

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

                                                if(response[fields.action]) {
                                                  html += ''
                                                  + '<a href="' + response[fields.action][fields.actionURL] + '" class="action">'
                                                  +   response[fields.action][fields.actionText]
                                                  + '</a>';
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 1 hr to fix
                                        src/definitions/modules/search.js on lines 1445..1450

                                        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

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

                                                exactSearch: function (query, term) {
                                                  query = query.toLowerCase();
                                                  term  = term.toLowerCase();
                                                  if(term.indexOf(query) > -1) {
                                                     return true;
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 1 hr to fix
                                        src/definitions/modules/dropdown.js on lines 874..881

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 67.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

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

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 65.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

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

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 62.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

                                                      $result
                                                        .removeClass(className.active)
                                                        .eq(newIndex)
                                                          .addClass(className.active)
                                                          .closest($category)
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 1 hr to fix
                                        src/definitions/modules/search.js on lines 295..301

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 55.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

                                                      $result
                                                        .removeClass(className.active)
                                                        .eq(newIndex)
                                                          .addClass(className.active)
                                                          .closest($category)
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 1 other location - About 1 hr to fix
                                        src/definitions/modules/search.js on lines 313..319

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 55.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

                                          error : {
                                            source          : 'Cannot search. No source used, and Semantic API module was not included',
                                            noResults       : 'Your search returned no results',
                                            logging         : 'Error in debug logging, exiting.',
                                            noEndpoint      : 'No search endpoint was specified',
                                        Severity: Major
                                        Found in src/definitions/modules/search.js and 2 other locations - About 50 mins to fix
                                        src/definitions/modules/tab.js on lines 922..932
                                        src/definitions/modules/transition.js on lines 1072..1082

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 51.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

                                                refreshResults: function() {
                                                  $results = $module.find(selector.results);
                                                  $result  = $module.find(selector.result);
                                                },
                                        Severity: Minor
                                        Found in src/definitions/modules/search.js and 1 other location - About 40 mins to fix
                                        src/definitions/modules/accordion.js on lines 93..96

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 48.

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

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

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

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

                                        Refactorings

                                        Further Reading

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

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

                                        Duplicated Code

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

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

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

                                        Tuning

                                        This issue has a mass of 46.

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

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

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

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

                                        Refactorings

                                        Further Reading

                                        There are no issues that match your filters.

                                        Category
                                        Status