Semantic-Org/Semantic-UI

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

Summary

Maintainability
F
1 mo
Test Coverage

Function shape has 775 lines of code (exceeds 25 allowed). Consider refactoring.
Open

$.fn.shape = function(parameters) {
  var
    $allModules     = $(this),
    $body           = $('body'),

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

    File shape.js has 815 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /*!
     * # Semantic UI - Shape
     * http://github.com/semantic-org/semantic-ui/
     *
     *
    Severity: Major
    Found in src/definitions/modules/shape.js - About 1 day 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/shape.js - About 2 hrs to fix

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

                animate: function(propertyObject, callback) {
                  module.verbose('Animating box with properties', propertyObject);
                  callback = callback || function(event) {
                    module.verbose('Executing animation callback');
                    if(event !== undefined) {
        Severity: Minor
        Found in src/definitions/modules/shape.js - About 1 hr to fix

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

                    stageSize: function() {
                      var
                        $clone      = $module.clone().addClass(className.loading),
                        $activeSide = $clone.find('.' + settings.className.active),
                        $nextSide   = (nextIndex)
          Severity: Minor
          Found in src/definitions/modules/shape.js - About 1 hr to fix

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

                      left: function() {
                        var
                          height = {
                            active : $activeSide.outerWidth(true),
                            next   : $nextSide.outerWidth(true)
            Severity: Minor
            Found in src/definitions/modules/shape.js - About 1 hr to fix

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

                        right: function() {
                          var
                            height = {
                              active : $activeSide.outerWidth(true),
                              next   : $nextSide.outerWidth(true)
              Severity: Minor
              Found in src/definitions/modules/shape.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/shape.js - About 1 hr to fix

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

                            below: function() {
                              var
                                box = {
                                  origin : (($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                  depth  : {
                  Severity: Minor
                  Found in src/definitions/modules/shape.js - About 1 hr to fix

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

                              above: function() {
                                var
                                  box = {
                                    origin : (($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                    depth  : {
                    Severity: Minor
                    Found in src/definitions/modules/shape.js - About 1 hr to fix

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

                                behind: function() {
                                  var
                                    height = {
                                      active : $activeSide.outerWidth(true),
                                      next   : $nextSide.outerWidth(true)
                      Severity: Minor
                      Found in src/definitions/modules/shape.js - About 1 hr 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/shape.js and 6 other locations - About 2 days to fix
                        src/definitions/behaviors/form.js on lines 1087..1140
                        src/definitions/modules/dimmer.js on lines 526..579
                        src/definitions/modules/embed.js on lines 447..500
                        src/definitions/modules/rating.js on lines 322..375
                        src/definitions/modules/search.js on lines 1084..1137
                        src/definitions/modules/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/shape.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/search.js on lines 1138..1190
                        src/definitions/modules/sticky.js on lines 831..883

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 449.

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

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

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

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

                        Refactorings

                        Further Reading

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

                                  left: function() {
                                    var
                                      height = {
                                        active : $activeSide.outerWidth(true),
                                        next   : $nextSide.outerWidth(true)
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 1 other location - About 1 day to fix
                        src/definitions/modules/shape.js on lines 610..642

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

                        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

                                  right: function() {
                                    var
                                      height = {
                                        active : $activeSide.outerWidth(true),
                                        next   : $nextSide.outerWidth(true)
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 1 other location - About 1 day to fix
                        src/definitions/modules/shape.js on lines 576..608

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

                        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

                                  below: function() {
                                    var
                                      box = {
                                        origin : (($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                        depth  : {
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 1 other location - About 1 day to fix
                        src/definitions/modules/shape.js on lines 516..544

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

                        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

                                  above: function() {
                                    var
                                      box = {
                                        origin : (($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                        depth  : {
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 1 other location - About 1 day to fix
                        src/definitions/modules/shape.js on lines 546..574

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                                  up: function() {
                                    if(module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                                      module.debug('Side already visible', $nextSide);
                                      return;
                                    }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 3 other locations - About 7 hrs to fix
                        src/definitions/modules/shape.js on lines 322..339
                        src/definitions/modules/shape.js on lines 341..358
                        src/definitions/modules/shape.js on lines 360..377

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                                  down: function() {
                                    if(module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                                      module.debug('Side already visible', $nextSide);
                                      return;
                                    }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 3 other locations - About 7 hrs to fix
                        src/definitions/modules/shape.js on lines 303..320
                        src/definitions/modules/shape.js on lines 341..358
                        src/definitions/modules/shape.js on lines 360..377

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                                  left: function() {
                                    if(module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                                      module.debug('Side already visible', $nextSide);
                                      return;
                                    }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 3 other locations - About 7 hrs to fix
                        src/definitions/modules/shape.js on lines 303..320
                        src/definitions/modules/shape.js on lines 322..339
                        src/definitions/modules/shape.js on lines 360..377

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                                  right: function() {
                                    if(module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                                      module.debug('Side already visible', $nextSide);
                                      return;
                                    }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 3 other locations - About 7 hrs to fix
                        src/definitions/modules/shape.js on lines 303..320
                        src/definitions/modules/shape.js on lines 322..339
                        src/definitions/modules/shape.js on lines 341..358

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 176.

                        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

                                  over: function() {
                                    if(module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                                      module.debug('Side already visible', $nextSide);
                                      return;
                                    }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 1 other location - About 6 hrs to fix
                        src/definitions/modules/shape.js on lines 395..409

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

                        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

                                  back: function() {
                                    if(module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                                      module.debug('Side already visible', $nextSide);
                                      return;
                                    }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 1 other location - About 6 hrs to fix
                        src/definitions/modules/shape.js on lines 379..393

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                                setting: function(name, value) {
                                  module.debug('Changing setting', name, value);
                                  if( $.isPlainObject(name) ) {
                                    $.extend(true, settings, name);
                                  }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 13 other locations - About 4 hrs to fix
                        src/definitions/behaviors/api.js on lines 843..859
                        src/definitions/modules/accordion.js on lines 372..388
                        src/definitions/modules/checkbox.js on lines 591..607
                        src/definitions/modules/dimmer.js on lines 470..486
                        src/definitions/modules/dropdown.js on lines 3514..3530
                        src/definitions/modules/embed.js on lines 391..407
                        src/definitions/modules/modal.js on lines 770..786
                        src/definitions/modules/nag.js on lines 258..274
                        src/definitions/modules/progress.js on lines 662..678
                        src/definitions/modules/rating.js on lines 266..282
                        src/definitions/modules/sidebar.js on lines 766..782
                        src/definitions/modules/tab.js on lines 695..711
                        src/definitions/modules/transition.js on lines 836..852

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 127.

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

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

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

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

                        Refactorings

                        Further Reading

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

                                verbose: function() {
                                  if(!settings.silent && settings.verbose && settings.debug) {
                                    if(settings.performance) {
                                      module.performance.log(arguments);
                                    }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 18 other locations - About 4 hrs to fix
                        src/definitions/behaviors/api.js on lines 882..892
                        src/definitions/behaviors/form.js on lines 1070..1080
                        src/definitions/behaviors/visibility.js on lines 1064..1074
                        src/definitions/modules/accordion.js on lines 414..424
                        src/definitions/modules/checkbox.js on lines 630..640
                        src/definitions/modules/dimmer.js on lines 509..519
                        src/definitions/modules/dropdown.js on lines 3553..3563
                        src/definitions/modules/embed.js on lines 430..440
                        src/definitions/modules/modal.js on lines 809..819
                        src/definitions/modules/nag.js on lines 297..307
                        src/definitions/modules/popup.js on lines 1183..1193
                        src/definitions/modules/progress.js on lines 701..711
                        src/definitions/modules/rating.js on lines 305..315
                        src/definitions/modules/search.js on lines 1067..1077
                        src/definitions/modules/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/shape.js and 18 other locations - About 4 hrs to fix
                        src/definitions/behaviors/api.js on lines 871..881
                        src/definitions/behaviors/form.js on lines 1059..1069
                        src/definitions/behaviors/visibility.js on lines 1053..1063
                        src/definitions/modules/accordion.js on lines 403..413
                        src/definitions/modules/checkbox.js on lines 619..629
                        src/definitions/modules/dimmer.js on lines 498..508
                        src/definitions/modules/dropdown.js on lines 3542..3552
                        src/definitions/modules/embed.js on lines 419..429
                        src/definitions/modules/modal.js on lines 798..808
                        src/definitions/modules/nag.js on lines 286..296
                        src/definitions/modules/popup.js on lines 1172..1182
                        src/definitions/modules/progress.js on lines 690..700
                        src/definitions/modules/rating.js on lines 294..304
                        src/definitions/modules/search.js on lines 1056..1066
                        src/definitions/modules/sidebar.js on lines 794..804
                        src/definitions/modules/sticky.js on lines 752..762
                        src/definitions/modules/tab.js on lines 723..733
                        src/definitions/modules/transition.js on lines 864..874

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 118.

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

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

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

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

                        Refactorings

                        Further Reading

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

                                    right: function() {
                                      var
                                        translate = {
                                          x : -(($activeSide.outerWidth(true) - $nextSide.outerWidth(true)) / 2),
                                          z : -($activeSide.outerWidth(true) / 2)
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 3 other locations - About 3 hrs to fix
                        src/definitions/modules/shape.js on lines 416..426
                        src/definitions/modules/shape.js on lines 428..438
                        src/definitions/modules/shape.js on lines 440..450

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                                    left: function() {
                                      var
                                        translate = {
                                          x : -(($activeSide.outerWidth(true) - $nextSide.outerWidth(true)) / 2),
                                          z : -($activeSide.outerWidth(true) / 2)
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 3 other locations - About 3 hrs to fix
                        src/definitions/modules/shape.js on lines 416..426
                        src/definitions/modules/shape.js on lines 428..438
                        src/definitions/modules/shape.js on lines 452..462

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                                    down: function() {
                                      var
                                        translate = {
                                          y: -(($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                          z: -($activeSide.outerHeight(true) / 2)
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 3 other locations - About 3 hrs to fix
                        src/definitions/modules/shape.js on lines 416..426
                        src/definitions/modules/shape.js on lines 440..450
                        src/definitions/modules/shape.js on lines 452..462

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                                    up: function() {
                                      var
                                        translate = {
                                          y: -(($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                          z: -($activeSide.outerHeight(true) / 2)
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 3 other locations - About 3 hrs to fix
                        src/definitions/modules/shape.js on lines 428..438
                        src/definitions/modules/shape.js on lines 440..450
                        src/definitions/modules/shape.js on lines 452..462

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

                        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

                                  transitionEvent: function() {
                                    var
                                      element     = document.createElement('element'),
                                      transitions = {
                                        'transition'       :'transitionend',
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 2 other locations - About 2 hrs to fix
                        src/definitions/modules/progress.js on lines 289..305
                        src/definitions/modules/sidebar.js on lines 682..698

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

                        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/shape.js and 18 other locations - About 2 hrs to fix
                        src/definitions/behaviors/api.js on lines 893..898
                        src/definitions/behaviors/form.js on lines 1081..1086
                        src/definitions/behaviors/visibility.js on lines 1075..1080
                        src/definitions/modules/accordion.js on lines 425..430
                        src/definitions/modules/checkbox.js on lines 641..646
                        src/definitions/modules/dimmer.js on lines 520..525
                        src/definitions/modules/dropdown.js on lines 3564..3569
                        src/definitions/modules/embed.js on lines 441..446
                        src/definitions/modules/modal.js on lines 820..825
                        src/definitions/modules/nag.js on lines 308..313
                        src/definitions/modules/popup.js on lines 1194..1199
                        src/definitions/modules/progress.js on lines 712..717
                        src/definitions/modules/rating.js on lines 316..321
                        src/definitions/modules/search.js on lines 1078..1083
                        src/definitions/modules/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/shape.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/search.js on lines 1192..1203
                        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/shape.js and 24 other locations - About 1 hr to fix
                        src/definitions/behaviors/api.js on lines 860..870
                        src/definitions/behaviors/form.js on lines 1037..1047
                        src/definitions/behaviors/form.js on lines 1048..1058
                        src/definitions/behaviors/visibility.js on lines 1031..1041
                        src/definitions/behaviors/visibility.js on lines 1042..1052
                        src/definitions/globals/site.js on lines 255..265
                        src/definitions/globals/site.js on lines 266..276
                        src/definitions/modules/checkbox.js on lines 608..618
                        src/definitions/modules/dimmer.js on lines 487..497
                        src/definitions/modules/dropdown.js on lines 3531..3541
                        src/definitions/modules/embed.js on lines 408..418
                        src/definitions/modules/modal.js on lines 787..797
                        src/definitions/modules/nag.js on lines 275..285
                        src/definitions/modules/popup.js on lines 1150..1160
                        src/definitions/modules/popup.js on lines 1161..1171
                        src/definitions/modules/progress.js on lines 679..689
                        src/definitions/modules/rating.js on lines 283..293
                        src/definitions/modules/search.js on lines 1034..1044
                        src/definitions/modules/search.js on lines 1045..1055
                        src/definitions/modules/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

                                    over: function() {
                                      var
                                        translate = {
                                          x : -(($activeSide.outerWidth(true) - $nextSide.outerWidth(true)) / 2)
                                        }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 1 other location - About 1 hr to fix
                        src/definitions/modules/shape.js on lines 475..484

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

                        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

                                    back: function() {
                                      var
                                        translate = {
                                          x : -(($activeSide.outerWidth(true) - $nextSide.outerWidth(true)) / 2)
                                        }
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 1 other location - About 1 hr to fix
                        src/definitions/modules/shape.js on lines 464..473

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

                        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.shape.settings, parameters)
                                  : $.extend({}, $.fn.shape.settings),
                        Severity: Major
                        Found in src/definitions/modules/shape.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/search.js on lines 38..40
                        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/shape.js and 17 other locations - About 1 hr to fix
                        src/definitions/behaviors/form.js on lines 15..20
                        src/definitions/behaviors/visibility.js on lines 15..20
                        src/definitions/modules/accordion.js on lines 15..20
                        src/definitions/modules/checkbox.js on lines 15..20
                        src/definitions/modules/dimmer.js on lines 15..20
                        src/definitions/modules/dropdown.js on lines 15..20
                        src/definitions/modules/embed.js on lines 15..20
                        src/definitions/modules/modal.js on lines 15..20
                        src/definitions/modules/nag.js on lines 15..20
                        src/definitions/modules/popup.js on lines 15..20
                        src/definitions/modules/progress.js on lines 15..20
                        src/definitions/modules/rating.js on lines 15..20
                        src/definitions/modules/search.js on lines 15..20
                        src/definitions/modules/sidebar.js on lines 15..20
                        src/definitions/modules/sticky.js on lines 15..20
                        src/definitions/modules/tab.js on lines 15..20
                        src/definitions/modules/transition.js on lines 15..20

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 62.

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

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

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

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

                        Refactorings

                        Further Reading

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

                                        : ( $activeSide.next(selector.side).length > 0 )
                                          ? $activeSide.next(selector.side)
                                          : $clone.find(selector.side).first(),
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 2 other locations - About 1 hr to fix
                        src/definitions/modules/shape.js on lines 200..202
                        src/definitions/modules/shape.js on lines 506..508

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

                        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

                                    $nextSide   = ( $activeSide.next(selector.side).length > 0 )
                                      ? $activeSide.next(selector.side)
                                      : $module.find(selector.side).first()
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 2 other locations - About 1 hr to fix
                        src/definitions/modules/shape.js on lines 249..251
                        src/definitions/modules/shape.js on lines 506..508

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

                        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

                                    return ( $activeSide.next(selector.side).length > 0 )
                                      ? $activeSide.next(selector.side)
                                      : $module.find(selector.side).first()
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 2 other locations - About 1 hr to fix
                        src/definitions/modules/shape.js on lines 200..202
                        src/definitions/modules/shape.js on lines 249..251

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

                        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

                                      newWidth    = (settings.width == 'next')
                                        ? $nextSide.outerWidth(true)
                                        : (settings.width == 'initial')
                                          ? $module.width()
                                          : settings.width,
                        Severity: Minor
                        Found in src/definitions/modules/shape.js and 1 other location - About 50 mins to fix
                        src/definitions/modules/shape.js on lines 257..261

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

                        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

                                      newHeight    = (settings.height == 'next')
                                        ? $nextSide.outerHeight(true)
                                        : (settings.height == 'initial')
                                          ? $module.height()
                                          : settings.height
                        Severity: Minor
                        Found in src/definitions/modules/shape.js and 1 other location - About 50 mins to fix
                        src/definitions/modules/shape.js on lines 252..256

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

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

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

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

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

                        Refactorings

                        Further Reading

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

                            requestAnimationFrame = window.requestAnimationFrame
                              || window.mozRequestAnimationFrame
                              || window.webkitRequestAnimationFrame
                              || window.msRequestAnimationFrame
                              || function(callback) { setTimeout(callback, 0); },
                        Severity: Major
                        Found in src/definitions/modules/shape.js and 7 other locations - About 50 mins to fix
                        src/definitions/behaviors/visibility.js on lines 64..68
                        src/definitions/modules/accordion.js on lines 33..37
                        src/definitions/modules/modal.js on lines 38..42
                        src/definitions/modules/nag.js on lines 73..77
                        src/definitions/modules/sidebar.js on lines 39..43
                        src/definitions/modules/sticky.js on lines 59..63
                        src/definitions/modules/transition.js on lines 35..39

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 51.

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

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

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

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

                        Refactorings

                        Further Reading

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

                                    if(settings.height != 'auto') {
                                      $module.css('height', newHeight + settings.jitter);
                                      module.verbose('Specifying height during animation', newHeight);
                                    }
                        Severity: Minor
                        Found in src/definitions/modules/shape.js and 1 other location - About 35 mins to fix
                        src/definitions/modules/shape.js on lines 267..270

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 47.

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

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

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

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

                        Refactorings

                        Further Reading

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

                                    if(settings.width != 'auto') {
                                      $module.css('width', newWidth + settings.jitter);
                                      module.verbose('Specifying width during animation', newWidth);
                                    }
                        Severity: Minor
                        Found in src/definitions/modules/shape.js and 1 other location - About 35 mins to fix
                        src/definitions/modules/shape.js on lines 271..274

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 47.

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

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

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

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

                        Refactorings

                        Further Reading

                        There are no issues that match your filters.

                        Category
                        Status