gopheracademy/gcon

View on GitHub
assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js

Summary

Maintainability
F
1 mo
Test Coverage

File jquery.cubeportfolio.js has 3633 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
 * Cube Portfolio - Responsive jQuery Grid Plugin
 *
 * version: 3.5.2 (11 February, 2016)
 * require: jQuery v1.7+

    Function dragSlider has 111 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

            dragSlider: function() {
                var t = this,
                    $document = $(document),
                    posInitial,
                    pos,
    Severity: Major
    Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 4 hrs to fix

      Function openSinglePageInline has 104 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              openSinglePageInline: function(blocks, currentBlock, fromOpen) {
                  var t = this,
                      start = 0,
                      currentBlockHref,
                      tempCurrent,
      Severity: Major
      Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 4 hrs to fix

        Function init has 103 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

                init: function(cubeportfolio, type) {
                    var t = this,
                        currentBlock;
        
                    // remember cubeportfolio instance
        Severity: Major
        Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 4 hrs to fix

          Function close has 96 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                  close: function(method, data) {
                      var t = this;
          
                      function finishClose() {
                          // reset content
          Severity: Major
          Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 3 hrs to fix

            Function openSinglePage has 95 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    openSinglePage: function(blocks, currentBlock) {
                        var t = this,
                            i = 0,
                            currentBlockHref, tempHref = [];
            
            Severity: Major
            Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 3 hrs to fix

              Function run has 90 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  Plugin.prototype.run = function() {
                      var t = this,
                          p = t.parent,
                          body = $(document.body);
              
              Severity: Major
              Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 3 hrs to fix

                Function openLightbox has 89 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                        openLightbox: function(blocks, currentBlock) {
                            var t = this,
                                i = 0,
                                currentBlockHref, tempHref = [],
                                element;
                Severity: Major
                Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 3 hrs to fix

                  Function createMarkup has 89 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                          createMarkup: function() {
                              var t = this,
                                  animationCls = '';
                  
                              if (t.type === 'singlePage') {
                  Severity: Major
                  Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 3 hrs to fix

                    Function auto has 81 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        Plugin.prototype.auto = function() {
                            var t = this;
                    
                            t.parent.$obj.on('initComplete.cbp', function() {
                                Object.create({
                    Severity: Major
                    Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 3 hrs to fix

                      Function sliderMarkup has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          Plugin.prototype.sliderMarkup = function() {
                              var t = this;
                      
                              t.sliderStopEvents = false;
                      
                      Severity: Major
                      Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 2 hrs to fix

                        Function registerFilter has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            Plugin.prototype.registerFilter = function() {
                                var t = this,
                                    parent = t.parent,
                                    filtersCallback,
                                    arr = parent.defaultFilter.split('|');
                        Severity: Major
                        Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 2 hrs to fix

                          Function getNewItems has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                                          getNewItems: function() {
                                              var self = this,
                                                  topLoadMore, topWindow;
                          
                                              if (self.isActive || t.loadMore.hasClass('cbp-l-loadMore-stop')) {

                            Function Plugin has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                function Plugin(parent) {
                                    var t = this;
                            
                                    t.parent = parent;
                            

                              Function browserInfo has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                      browserInfo: function() {
                                          var t = CubePortfolio.private,
                                              appVersion = navigator.appVersion,
                                              transition, animation, perspective;
                              

                                Function responsiveLayout has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                        responsiveLayout: function() {
                                            var t = this;
                                
                                            // calculate numbers of cols
                                            t.cols = t[($.isArray(t.options.mediaQueries) ? 'getColumnsBreakpoints' : 'getColumnsAuto')]();

                                  Function CubePortfolio has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      function CubePortfolio(obj, options, callback) {
                                          /*jshint validthis: true */
                                          var t = this,
                                              initialCls = 'cbp',
                                              children;

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

                                        Plugin.prototype.filterLayout = function() {
                                            var t = this,
                                                ulClone = t.$ul.clone(true, true);
                                    
                                            ulClone[0].setAttribute('class', 'cbp-wrapper-helper');

                                      Function filterLayout has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                          Plugin.prototype.filterLayout = function() {
                                              var t = this;
                                      
                                              t.$obj.addClass('cbp-animation-' + t.options.animationType);
                                      

                                        Function runEvent has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            Plugin.prototype.runEvent = function(el) {
                                                var t = this,
                                                    value = el.val(),
                                                    searchData = el.data('searchData'),
                                                    reg = new RegExp(value, 'i');

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

                                              Plugin.prototype.click = function() {
                                                  var t = this,
                                                      numberOfClicks = 0;
                                          
                                                  t.loadMore.on('click.cbp', function(e) {

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

                                                Plugin.prototype.filterLayout = function() {
                                                    var t = this,
                                                        ulClone = t.$ul[0].cloneNode(true);
                                            
                                                    ulClone.setAttribute('class', 'cbp-wrapper-helper');

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

                                                      enableDisableNavSlider: function() {
                                                          var t = this,
                                                              page,
                                                              method;
                                              

                                                Function singlePageInlineIsOpen has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                        singlePageInlineIsOpen: function() {
                                                            var t = this;
                                                
                                                            function finishLoading() {
                                                                t.wrap.addClass('cbp-popup-singlePageInline-ready');

                                                  Function loadImages has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                          loadImages: function(elems, callback) {
                                                              var t = this;
                                                  
                                                              // wait a frame (Safari bug)
                                                              requestAnimationFrame(function() {

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

                                                            filter: function(param, callback) {
                                                                var t = CubePortfolio.private.checkInstance.call(this, 'filter'),
                                                                    expression;
                                                    
                                                                if (t.isAnimating) {

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

                                                              updateSinglePageIsOpen: function() {
                                                                  var t = this,
                                                                      selectorSlider;
                                                      
                                                                  t.wrap.addClass('cbp-popup-ready');

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

                                                                appendScriptsToWrap: function(scripts) {
                                                                    var t = this,
                                                                        index = 0,
                                                                        loadScripts = function(item) {
                                                                            var script = document.createElement('script'),

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

                                                                  resizeMainContainer: function() {
                                                                      var t = this,
                                                                          height = Math.max(t.freeSpaces.slice(-1)[0].topStart - t.options.gapHorizontal, 0),
                                                                          maxWidth;
                                                          

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

                                                                    getSpaceIndexAndBlock: function() {
                                                                        var t = this,
                                                                            spaceIndexAndBlock = null;
                                                            
                                                                        $.each(t.freeSpaces, function(index1, space) {

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

                                                                  function Plugin(parent) {
                                                                      var t = this;
                                                              
                                                                      t.parent = parent;
                                                              

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

                                                                    Plugin.prototype.filterLayout = function() {
                                                                        var t = this,
                                                                            ulClone = t.$ul[0].cloneNode(true);
                                                                
                                                                        ulClone.setAttribute('class', 'cbp-wrapper-helper');

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

                                                                      function InitSlider(slider) {
                                                                          var t = this;
                                                                  
                                                                          if (slider.hasClass('cbp-slider-inline-ready')) {
                                                                              return;

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

                                                                            destroy: function(callback) {
                                                                                var t = CubePortfolio.private.checkInstance.call(this, 'destroy');
                                                                    
                                                                                t.triggerEvent('beforeDestroy');
                                                                    

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

                                                                              sortBlocksToPreventGaps: function() {
                                                                                  var t = this;
                                                                      
                                                                                  t.blocksAreSorted = true;
                                                                      

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

                                                                                        loadScripts = function(item) {
                                                                                            var script = document.createElement('script'),
                                                                                                src = item.src;
                                                                        
                                                                                            script.type = 'text/javascript';

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

                                                                                  intersectSpaces: function(space1, block) {
                                                                                      var t = this,
                                                                                          space2 = {
                                                                                              leftStart: block.leftNew,
                                                                                              leftEnd: block.leftNew + block.widthAndGap,

                                                                            Avoid deeply nested control flow statements.
                                                                            Open

                                                                                                    if (href.indexOf('|') !== -1) {
                                                                                                        // create new href
                                                                                                        src = href.split('|');
                                                                                                    } else {
                                                                                                        // create new href
                                                                            Severity: Major
                                                                            Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 45 mins to fix

                                                                              Avoid deeply nested control flow statements.
                                                                              Open

                                                                                                                  if ($(el2).attr('data-cbp-singlePage') === gallery) {
                                                                                                                      blocks.push(el2);
                                                                                                                  }
                                                                              Severity: Major
                                                                              Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 45 mins to fix

                                                                                Avoid deeply nested control flow statements.
                                                                                Open

                                                                                                                    if ($(el2).attr('data-cbp-lightbox') === gallery) {
                                                                                                                        blocks.push(el2);
                                                                                                                    }
                                                                                Severity: Major
                                                                                Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 45 mins to fix

                                                                                  Avoid deeply nested control flow statements.
                                                                                  Open

                                                                                                                  if (item.not('.cbp-item-off')) {
                                                                                                                      item.find(t.options.singlePageDelegate).each(function(index2, el2) {
                                                                                                                          if (!$(el2).attr('data-cbp-singlePage')) {
                                                                                                                              blocks.push(el2);
                                                                                                                          }
                                                                                  Severity: Major
                                                                                  Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 45 mins to fix

                                                                                    Avoid deeply nested control flow statements.
                                                                                    Open

                                                                                                        } else if (/\.mp3$/i.test(href)) {
                                                                                                            src = href;
                                                                                                            type = 'isSelfHostedAudio';
                                                                                                        }
                                                                                    Severity: Major
                                                                                    Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 45 mins to fix

                                                                                      Avoid too many return statements within this function.
                                                                                      Open

                                                                                                                  return -1;
                                                                                      Severity: Major
                                                                                      Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 30 mins to fix

                                                                                        Avoid too many return statements within this function.
                                                                                        Open

                                                                                                                return 0;
                                                                                        Severity: Major
                                                                                        Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 30 mins to fix

                                                                                          Avoid too many return statements within this function.
                                                                                          Open

                                                                                                                      return 1;
                                                                                          Severity: Major
                                                                                          Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 30 mins to fix

                                                                                            Avoid too many return statements within this function.
                                                                                            Open

                                                                                                                    return 0;
                                                                                            Severity: Major
                                                                                            Found in assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js - About 30 mins to fix

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

                                                                                                      if (p.options.singlePageDelegate && !singlePageInit) {
                                                                                                          // init only one time @todo
                                                                                                          singlePageInit = true;
                                                                                              
                                                                                                          p.singlePage = Object.create(popup);
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5209..5252

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

                                                                                              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 (p.options.lightboxDelegate && !lightboxInit) {
                                                                                                          // init only one time @todo
                                                                                                          lightboxInit = true;
                                                                                              
                                                                                                          p.lightbox = Object.create(popup);
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5258..5301

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

                                                                                              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

                                                                                              (function($, window, document, undefined) {
                                                                                                  'use strict';
                                                                                              
                                                                                                  var CubePortfolio = $.fn.cubeportfolio.constructor;
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3065..3103

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

                                                                                              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

                                                                                              (function($, window, document, undefined) {
                                                                                                  'use strict';
                                                                                              
                                                                                                  var CubePortfolio = $.fn.cubeportfolio.constructor;
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2955..2993

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

                                                                                              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

                                                                                                  function Plugin(parent) {
                                                                                                      var deferred = $.Deferred();
                                                                                              
                                                                                                      parent.pushQueue('delayFrame', deferred);
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3000..3019

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

                                                                                              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

                                                                                                  function Plugin(parent) {
                                                                                                      var deferred = $.Deferred();
                                                                                              
                                                                                                      parent.pushQueue('delayFrame', deferred);
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3035..3054

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

                                                                                              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 (t.blocksOn.length) {
                                                                                                              t.blocksOn.last().data('cbp').wrapper.one(CubePortfolio.private.animationend, animationend);
                                                                                                          } else if (t.blocksOnInitial.length) {
                                                                                                              t.blocksOnInitial.last().data('cbp').wrapper.one(CubePortfolio.private.animationend, animationend);
                                                                                                          } else {
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2575..2581

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

                                                                                              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 (t.blocksOn2Off.length) {
                                                                                                          t.blocksOn2Off.last().data('cbp').wrapper.one(CubePortfolio.private.animationend, animationend);
                                                                                                      } else if (t.blocksOff2On.length) {
                                                                                                          t.blocksOff2On.last().data('cbp').wrapper.one(CubePortfolio.private.animationend, animationend);
                                                                                                      } else {
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2663..2669

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

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.blocksOn.removeClass('cbp-item-off')
                                                                                                              .each(function(index, el) {
                                                                                                                  var data = $(el).data('cbp');
                                                                                              
                                                                                                                  data.left = data.leftNew;
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2819..2828

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

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.blocksOn.removeClass('cbp-item-off')
                                                                                                              .each(function(index, el) {
                                                                                                                  var data = $(el).data('cbp');
                                                                                              
                                                                                                                  data.left = data.leftNew;
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 415..424

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

                                                                                              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

                                                                                                                  $.each(links, function(index, link) {
                                                                                                                      t.cubeportfolio.blocksOn.each(function(index1, el) {
                                                                                                                          var singlePageInline = $(el).find(t.options.singlePageInlineDelegate + '[href="' + link + '"]');
                                                                                              
                                                                                                                          if (singlePageInline.length) {
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3819..3832

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

                                                                                              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

                                                                                                                  $.each(links, function(index, link) {
                                                                                                                      t.cubeportfolio.blocksOn.each(function(index1, el) {
                                                                                                                          var singlePage = $(el).find(t.options.singlePageDelegate + '[href="' + link + '"]');
                                                                                              
                                                                                                                          if (singlePage.length) {
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3765..3778

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

                                                                                              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 (t.options.scrollByPage) {
                                                                                                                  page = Math.ceil(t.sliderActive / t.cols);
                                                                                                              } else {
                                                                                                                  if (t.isEndSlider()) {
                                                                                                                      page = t.customPaginationItems.length - 1;
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2217..2225

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

                                                                                              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 (t.options.scrollByPage) {
                                                                                                                  page = Math.ceil(t.sliderActive / t.cols);
                                                                                                              } else {
                                                                                                                  if (t.isEndSlider()) {
                                                                                                                      page = t.navPaginationItems.length - 1;
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2234..2242

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

                                                                                              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

                                                                                                      window.requestAnimationFrame = function(callback, element) {
                                                                                                          var currTime = new Date().getTime();
                                                                                                          var timeToCall = Math.max(0, 16 - (currTime - lastTime));
                                                                                                          var id = window.setTimeout(function() {
                                                                                                                  callback(currTime + timeToCall);
                                                                                              assets/admin/global/plugins/ion.rangeslider/js/ion.rangeSlider.js on lines 1993..2000

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

                                                                                              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

                                                                                                  for (var x = 0; x < vendors.length && !window.requestAnimationFrame; x++) {
                                                                                                      window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
                                                                                                      window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] || window[vendors[x] + 'CancelRequestAnimationFrame'];
                                                                                                  }
                                                                                              assets/admin/global/plugins/ion.rangeslider/js/ion.rangeSlider.js on lines 1986..1990

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 99.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                                  } else if (/vimeo\.com/i.test(href)) {
                                                                                                                      videoLink = href.substring(href.lastIndexOf('/') + 1);
                                                                                              
                                                                                                                      if (!(/autoplay=/i.test(videoLink))) {
                                                                                                                          videoLink += '&autoplay=1';
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4105..4154

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

                                                                                              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 (/youtube/i.test(href)) {
                                                                                                                      videoLink = href.substring(href.lastIndexOf('v=') + 2);
                                                                                              
                                                                                                                      if (!(/autoplay=/i.test(videoLink))) {
                                                                                                                          videoLink += '&autoplay=1';
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4118..4154

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

                                                                                              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 (t.options.singlePageInlineDeeplinking) {
                                                                                                              // ignore old #cbpi from href
                                                                                                              t.url = t.url.split('#cbpi=')[0];
                                                                                                              location.href = t.url + '#cbpi=' + t.dataArray[t.current].url;
                                                                                                          }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4346..4350

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 87.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                              blocks.each(function(index, el) {
                                                                                                                  var data = $(el).data('cbp');
                                                                                              
                                                                                                                  if ((data.top + data.height) > t.top) {
                                                                                                                      t.blocksToMove = t.blocksToMove.add(el);
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4437..4443

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 87.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          if (t.options.singlePageDeeplinking) {
                                                                                                              // ignore old #cbp from href
                                                                                                              t.url = t.url.split('#cbp=')[0];
                                                                                                              location.href = t.url + '#cbp=' + t.dataArray[t.current].url;
                                                                                                          }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4496..4500

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 87.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                              blocks.each(function(index, el) {
                                                                                                                  var data = $(el).data('cbp');
                                                                                              
                                                                                                                  if ((data.top + data.height) >= t.top) {
                                                                                                                      t.blocksToMove = t.blocksToMove.add(el);
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4452..4458

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 87.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                              if (CubePortfolio.private.modernBrowser) {
                                                                                                                  t.$ul[0].style[CubePortfolio.private.transform] = 'translate3d(' + value + 'px, 0px, 0)';
                                                                                                              } else {
                                                                                                                  t.$ul[0].style.left = value + 'px';
                                                                                                              }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2317..2321

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 85.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          if (CubePortfolio.private.modernBrowser) {
                                                                                                              t.$ul[0].style[CubePortfolio.private.transform] = 'translate3d(' + value + 'px, 0px, 0)';
                                                                                                          } else {
                                                                                                              t.$ul[0].style.left = value + 'px';
                                                                                                          }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2438..2442

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 85.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                      generateG2: function(space, intersectSpace, spaces) {
                                                                                                          if (space.leftEnd === intersectSpace.leftEnd) {
                                                                                                              return;
                                                                                                          }
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1082..1093
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1116..1127
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1133..1144

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

                                                                                              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

                                                                                                      generateG4: function(space, intersectSpace, spaces) {
                                                                                                          if (space.leftStart === intersectSpace.leftStart) {
                                                                                                              return;
                                                                                                          }
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1082..1093
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1099..1110
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1116..1127

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

                                                                                              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

                                                                                                      generateG1: function(space, intersectSpace, spaces) {
                                                                                                          if (space.topStart === intersectSpace.topStart) {
                                                                                                              return;
                                                                                                          }
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1099..1110
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1116..1127
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1133..1144

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

                                                                                              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

                                                                                                      generateG3: function(space, intersectSpace, spaces) {
                                                                                                          if (space.topEnd === intersectSpace.topEnd) {
                                                                                                              return;
                                                                                                          }
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1082..1093
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1099..1110
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1133..1144

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

                                                                                              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 (space1.topStart > space2.topStart) {
                                                                                                                  return 1;
                                                                                                              } else if (space1.topStart < space2.topStart) {
                                                                                                                  return -1;
                                                                                                              } else {
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1338..1350

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

                                                                                              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 (data1[compare] > data2[compare]) {
                                                                                                                  return 1;
                                                                                                              } else if (data1[compare] < data2[compare]) {
                                                                                                                  return -1;
                                                                                                              } else {
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1156..1168

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

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.storeBlocks.each(function(index, el) {
                                                                                                              if (CubePortfolio.private.modernBrowser) {
                                                                                                                  el.style[CubePortfolio.private.transform] = '';
                                                                                                              } else {
                                                                                                                  el.style.marginTop = '';
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4538..4544

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

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.storeBlocks.each(function(index, el) {
                                                                                                              if (CubePortfolio.private.modernBrowser) {
                                                                                                                  el.style[CubePortfolio.private.transform] = '';
                                                                                                              } else {
                                                                                                                  el.style.marginTop = '';
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4513..4519

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

                                                                                              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 ($.isFunction(t.options.singlePageCallback)) {
                                                                                                              t.options.singlePageCallback.call(t, t.dataArray[t.current].url, t.dataArray[t.current].element);
                                                                                                          }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4503..4505

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

                                                                                              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 ($.isFunction(t.options.singlePageInlineCallback)) {
                                                                                                              t.options.singlePageInlineCallback.call(t, t.dataArray[t.current].url, t.dataArray[t.current].element);
                                                                                                          }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4353..4355

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

                                                                                              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 (space2.leftStart <= space1.leftStart &&
                                                                                                                      space2.leftEnd >= space1.leftEnd &&
                                                                                                                      space2.topStart <= space1.topStart &&
                                                                                                                      space2.topEnd >= space1.topEnd) {
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1235..1242

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

                                                                                              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 (space2.leftStart === space1.leftStart &&
                                                                                                                      space2.leftEnd === space1.leftEnd &&
                                                                                                                      space2.topStart === space1.topStart &&
                                                                                                                      space2.topEnd === space1.topEnd) {
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 1211..1218

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

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.wrap = $('<div/>', {
                                                                                                              'class': 'cbp-popup-wrap cbp-popup-' + t.type + animationCls,
                                                                                                              'data-action': (t.type === 'lightbox') ? 'close' : ''
                                                                                                          }).on('click.cbp', function(e) {
                                                                                                              if (t.stopEvents) {
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4299..4313

                                                                                              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

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

                                                                                                                      t.navigationMobile = $('<div/>', {
                                                                                                                          'class': 'cbp-popup-singlePage cbp-popup-singlePage-sticky',
                                                                                                                          'id': t.wrap.attr('id')
                                                                                                                      }).on('click.cbp', function(e) {
                                                                                                                          if (t.stopEvents) {
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3881..3895

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

                                                                                                      isYoutube: function(el) {
                                                                                                          var t = this;
                                                                                                          t.updateVideoMarkup(el.src, el.title, t.getCounterMarkup(t.options.lightboxCounter, t.current + 1, t.counterTotal));
                                                                                              
                                                                                                      },
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4789..4792
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4800..4803
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4805..4808
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4810..4813
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4815..4818

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

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

                                                                                                      isSelfHostedVideo: function(el) {
                                                                                                          var t = this;
                                                                                                          t.updateSelfHostedVideo(el.src, el.title, t.getCounterMarkup(t.options.lightboxCounter, t.current + 1, t.counterTotal));
                                                                                                      },
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4789..4792
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4794..4798
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4800..4803
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4805..4808
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4815..4818

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

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

                                                                                                      isSelfHostedAudio: function(el) {
                                                                                                          var t = this;
                                                                                                          t.updateSelfHostedAudio(el.src, el.title, t.getCounterMarkup(t.options.lightboxCounter, t.current + 1, t.counterTotal));
                                                                                                      },
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4789..4792
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4794..4798
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4800..4803
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4805..4808
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4810..4813

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

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

                                                                                                      isVimeo: function(el) {
                                                                                                          var t = this;
                                                                                                          t.updateVideoMarkup(el.src, el.title, t.getCounterMarkup(t.options.lightboxCounter, t.current + 1, t.counterTotal));
                                                                                                      },
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4794..4798
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4800..4803
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4805..4808
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4810..4813
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4815..4818

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

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

                                                                                                      isSoundCloud: function(el) {
                                                                                                          var t = this;
                                                                                                          t.updateVideoMarkup(el.src, el.title, t.getCounterMarkup(t.options.lightboxCounter, t.current + 1, t.counterTotal));
                                                                                                      },
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4789..4792
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4794..4798
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4800..4803
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4810..4813
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4815..4818

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

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

                                                                                                      isTed: function(el) {
                                                                                                          var t = this;
                                                                                                          t.updateVideoMarkup(el.src, el.title, t.getCounterMarkup(t.options.lightboxCounter, t.current + 1, t.counterTotal));
                                                                                                      },
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4789..4792
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4794..4798
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4805..4808
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4810..4813
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4815..4818

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

                                                                                              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

                                                                                                      createGooglePlusShare: function(item) {
                                                                                                          if (item.length && !item.attr('onclick')) {
                                                                                                              item.attr('onclick', "window.open('https://plus.google.com/share?url=" + encodeURIComponent(window.location.href) + "', '_blank', 'top=100,left=100,toolbar=0,status=0,width=620,height=450'); return false;");
                                                                                                          }
                                                                                                      },
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4680..4684

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 68.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                      createFacebookShare: function(item) {
                                                                                                          if (item.length && !item.attr('onclick')) {
                                                                                                              item.attr('onclick', "window.open('http://www.facebook.com/sharer.php?u=" + encodeURIComponent(window.location.href) + "', '_blank', 'top=100,left=100,toolbar=0,status=0,width=620,height=400'); return false;");
                                                                                                          }
                                                                                                      },
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4692..4696

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 68.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.blocks.each(function(index, el) {
                                                                                                              $(el).data('cbp').wrapper[0].style[CubePortfolio.private.animationDelay] = '';
                                                                                                          });
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2679..2681

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

                                                                                                              t.blocksOn.each(function(index, el) {
                                                                                                                  $(el).data('cbp').wrapper[0].style[CubePortfolio.private.animationDelay] = '';
                                                                                                              });
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2771..2773

                                                                                              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

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

                                                                                                  Plugin.prototype.destroy = function() {
                                                                                                      var parent = this.parent;
                                                                                                      parent.$obj.removeClass('cbp-animation-' + parent.options.animationType);
                                                                                                  };
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2608..2611
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2690..2693
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2851..2854

                                                                                              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

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

                                                                                                  Plugin.prototype.destroy = function() {
                                                                                                      var parent = this.parent;
                                                                                                      parent.$obj.removeClass('cbp-animation-' + parent.options.animationType);
                                                                                                  };
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2690..2693
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2779..2782
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2851..2854

                                                                                              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

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

                                                                                                  Plugin.prototype.destroy = function() {
                                                                                                      var parent = this.parent;
                                                                                                      parent.$obj.removeClass('cbp-animation-' + parent.options.animationType);
                                                                                                  };
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2608..2611
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2779..2782
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2851..2854

                                                                                              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

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

                                                                                                  Plugin.prototype.destroy = function() {
                                                                                                      var parent = this.parent;
                                                                                                      parent.$obj.removeClass('cbp-animation-' + parent.options.animationType);
                                                                                                  };
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2608..2611
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2690..2693
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2779..2782

                                                                                              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

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

                                                                                                                  if (t.url.slice(-1) === '#') {
                                                                                                                      t.url = t.url.slice(0, -1);
                                                                                                                  }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3812..3814

                                                                                              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

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

                                                                                                                  if (t.url.slice(-1) === '#') {
                                                                                                                      t.url = t.url.slice(0, -1);
                                                                                                                  }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3758..3760

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

                                                                                                  CubePortfolio.plugins.filters = function(parent) {
                                                                                                      if (parent.options.filters === '') {
                                                                                                          return null;
                                                                                                      }
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2944..2951
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3699..3705
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5488..5494
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5653..5659

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

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

                                                                                                  CubePortfolio.plugins.search = function(parent) {
                                                                                                      if (parent.options.search === '') {
                                                                                                          return null;
                                                                                                      }
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2944..2951
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3232..3238
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3699..3705
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5653..5659

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

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

                                                                                                  CubePortfolio.plugins.loadMore = function(parent) {
                                                                                                      if (parent.options.loadMore === '') {
                                                                                                          return null;
                                                                                                      }
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2944..2951
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3232..3238
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5488..5494
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5653..5659

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

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

                                                                                                  CubePortfolio.plugins.captionExpand = function(parent) {
                                                                                              
                                                                                                      if (parent.options.caption !== 'expand') {
                                                                                                          return null;
                                                                                                      }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3232..3238
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3699..3705
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5488..5494
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5653..5659

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

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

                                                                                                  CubePortfolio.plugins.slider = function(parent) {
                                                                                                      if (parent.options.layoutMode !== 'slider') {
                                                                                                          return null;
                                                                                                      }
                                                                                              
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 2944..2951
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3232..3238
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3699..3705
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 5488..5494

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

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                              if (endBlock === -1) {
                                                                                                                  end = items.lastIndexOf('</');
                                                                                                              } else {
                                                                                                                  end = items.lastIndexOf('</', endBlock);
                                                                                                              }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3659..3663

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

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                                          if (endBlock === -1) {
                                                                                                                              end = items.lastIndexOf('</');
                                                                                                                          } else {
                                                                                                                              end = items.lastIndexOf('</', endBlock);
                                                                                                                          }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3535..3539

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

                                                                                              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

                                                                                                          t.closeButton = $('<div/>', {
                                                                                                              'class': 'cbp-popup-close',
                                                                                                              'title': 'Close (Esc arrow key)',
                                                                                                              'data-action': 'close'
                                                                                                          }).appendTo(t.navigation);
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3933..3937

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 48.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.nextButton = $('<div/>', {
                                                                                                              'class': 'cbp-popup-next',
                                                                                                              'title': 'Next (Right arrow key)',
                                                                                                              'data-action': 'next'
                                                                                                          }).appendTo(t.navigation);
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3926..3930

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 48.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                              if (typeof Object.create !== 'function') {
                                                                                                  Object.create = function(obj) {
                                                                                                      function F() {}
                                                                                                      F.prototype = obj;
                                                                                                      return new F();
                                                                                              assets/admin/global/plugins/owl-carousel/owl.carousel.js on lines 15..21

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.prevButton = $('<div/>', {
                                                                                                              'class': 'cbp-popup-prev',
                                                                                                              'title': 'Previous (Left arrow key)',
                                                                                                              'data-action': 'prev'
                                                                                                          }).appendTo(t.navigation);
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4033..4037

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          if (t.type === 'singlePageInline' && t.options.singlePageInlineDeeplinking) {
                                                                                                              location.href = t.url + '#';
                                                                                                          }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4973..4975

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          if (t.type === 'singlePage' && t.options.singlePageDeeplinking) {
                                                                                                              location.href = t.url + '#';
                                                                                                          }
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4977..4979

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          t.closeButton = $('<div/>', {
                                                                                                              'class': 'cbp-popup-close',
                                                                                                              'title': 'Close (Esc arrow key)',
                                                                                                              'data-action': 'close'
                                                                                                          }).appendTo(t.navigation);
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 3941..3945

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                          $('html').css({
                                                                                                              overflow: 'hidden',
                                                                                                              marginRight: window.innerWidth - $(document).width()
                                                                                                          });
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4283..4286

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 45.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

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

                                                                                                              $('html').css({
                                                                                                                  overflow: 'hidden',
                                                                                                                  marginRight: window.innerWidth - $(document).width()
                                                                                                              });
                                                                                              assets/admin/global/plugins/cubeportfolio/js/jquery.cubeportfolio.js on lines 4188..4191

                                                                                              Duplicated Code

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

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

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

                                                                                              Tuning

                                                                                              This issue has a mass of 45.

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

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

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

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

                                                                                              Refactorings

                                                                                              Further Reading

                                                                                              There are no issues that match your filters.

                                                                                              Category
                                                                                              Status