talho/openphin

View on GitHub
app/assets/javascripts/jquery-tooltip/lib/jquery.js

Summary

Maintainability
F
1 mo
Test Coverage

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

(function(){
/*
 * jQuery 1.2.2 - New Wave Javascript
 *
 * Copyright (c) 2007 John Resig (jquery.com)
Severity: Major
Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 6 days to fix

    Function ajax has 146 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        ajax: function( s ) {
            var jsonp, jsre = /=\?(&|$)/g, status, data;
    
            // Extend the settings, but re-extend 's' so that it can be
            // checked again later (in the test suite, specifically)
    Severity: Major
    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 5 hrs to fix

      Function find has 105 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          find: function( t, context ) {
              // Quickly handle non-string expressions
              if ( typeof t != "string" )
                  return [ t ];
      
      
      Severity: Major
      Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 4 hrs to fix

        Consider simplifying this complex logical expression.
        Open

                    if ( typeof elem == "string" ) {
                        // Fix "XHTML"-style tags in all browsers
                        elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
                            return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
                                all :
        Severity: Critical
        Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 4 hrs to fix

          Consider simplifying this complex logical expression.
          Open

                              if ( (type == "" && !!z ||
                                   type == "=" && z == m[5] ||
                                   type == "!=" && z != m[5] ||
                                   type == "^=" && z && !z.indexOf(m[5]) ||
                                   type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
          Severity: Critical
          Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 3 hrs to fix

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

                filter: function(t,r,not) {
                    var last;
            
                    // Look for common filter expressions
                    while ( t && t != last ) {
            Severity: Major
            Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 2 hrs to fix

              Consider simplifying this complex logical expression.
              Open

                      if ( event.pageX == null && event.clientX != null ) {
                          var doc = document.documentElement, body = document.body;
                          event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
                          event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
                      }
              Severity: Critical
              Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 2 hrs to fix

                Function curCSS has 62 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    curCSS: function( elem, name, force ) {
                        var ret;
                
                        // A helper method for determining if an element's values are broken
                        function color( elem ) {
                Severity: Major
                Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 2 hrs to fix

                  Consider simplifying this complex logical expression.
                  Open

                              if ( !requestDone && xml && (xml.readyState == 4 || isTimeout == "timeout") ) {
                                  requestDone = true;
                                  
                                  // clear poll interval
                                  if (ival) {
                  Severity: Critical
                  Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 2 hrs to fix

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

                        clean: function( elems, context ) {
                            var ret = [];
                            context = context || document;
                            // !context.createElement fails in IE with an error but returns typeof 'object'
                            if (typeof context.createElement == 'undefined') 
                    Severity: Major
                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 2 hrs to fix

                      Function offset has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      jQuery.fn.offset = function() {
                          var left = 0, top = 0, elem = this[0], results;
                          
                          if ( elem ) with ( jQuery.browser ) {
                              var parent       = elem.parentNode, 
                      Severity: Minor
                      Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

                        Function val has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            val: function( value ) {
                                if ( value == undefined ) {
                        
                                    if ( this.length ) {
                                        var elem = this[0];
                        Severity: Minor
                        Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

                          Function remove has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              remove: function(elem, types, handler) {
                                  // don't do events on text and comment nodes
                                  if ( elem.nodeType == 3 || elem.nodeType == 8 )
                                      return;
                          
                          
                          Severity: Minor
                          Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                attr: function( elem, name, value ) {
                                    // don't set attributes on text and comment nodes
                                    if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
                                        return undefined;
                            
                            
                            Severity: Minor
                            Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                              function bindReady(){
                                  if ( readyBound ) return;
                                  readyBound = true;
                              
                                  // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
                              Severity: Minor
                              Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

                                Consider simplifying this complex logical expression.
                                Open

                                            } else if ( m[1] == ":" && m[2] == "nth-child" ) {
                                                var merge = {}, tmp = [],
                                                    // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
                                                    test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
                                                        m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
                                Severity: Critical
                                Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                      add: function(elem, types, handler, data) {
                                          if ( elem.nodeType == 3 || elem.nodeType == 8 )
                                              return;
                                  
                                          // For whatever reason, IE has trouble passing the window object
                                  Severity: Minor
                                  Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                        animate: function( prop, speed, easing, callback ) {
                                            var optall = jQuery.speed(speed, easing, callback);
                                    
                                            return this[ optall.queue === false ? "each" : "queue" ](function(){
                                                if ( this.nodeType != 1)
                                    Severity: Minor
                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                          load: function( url, params, callback ) {
                                              if ( jQuery.isFunction( url ) )
                                                  return this.bind("load", url);
                                      
                                              var off = url.indexOf(" ");
                                      Severity: Minor
                                      Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                            step: function(gotoEnd){
                                                var t = (new Date()).getTime();
                                        
                                                if ( gotoEnd || t > this.options.duration + this.startTime ) {
                                                    this.now = this.end;
                                        Severity: Minor
                                        Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

                                          Consider simplifying this complex logical expression.
                                          Open

                                                              if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
                                                                  // Optimization for HTML document case
                                                                  var oid = elem.getElementById(m[2]);
                                                                  
                                                                  // Do a quick check for the existence of the actual ID attribute
                                          Severity: Critical
                                          Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                                trigger: function(type, data, elem, donative, extra) {
                                                    // Clone the incoming data, if any
                                                    data = jQuery.makeArray(data || []);
                                            
                                                    // Handle a global trigger
                                            Severity: Minor
                                            Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                                      var onreadystatechange = function(isTimeout){
                                                          // The transfer is complete and the data is available, or the request timed out
                                                          if ( !requestDone && xml && (xml.readyState == 4 || isTimeout == "timeout") ) {
                                                              requestDone = true;
                                                              
                                              Severity: Minor
                                              Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                                    init: function( selector, context ) {
                                                        // Make sure that a selection was provided
                                                        selector = selector || document;
                                                
                                                        // Handle $(DOMElement)
                                                Severity: Minor
                                                Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

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

                                                      fix: function(event) {
                                                          // store a copy of the original event object 
                                                          // and clone to set read-only properties
                                                          var originalEvent = event;
                                                          event = jQuery.extend({}, originalEvent);
                                                  Severity: Minor
                                                  Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 1 hr to fix

                                                    Avoid deeply nested control flow statements.
                                                    Open

                                                                                if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
                                                                                    if (elem.removeEventListener)
                                                                                        elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
                                                                                    else if (elem.detachEvent)
                                                                                        elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
                                                    Severity: Major
                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                      Avoid deeply nested control flow statements.
                                                      Open

                                                                              if ( option.selected ) {
                                                                                  // Get the specifc value for the option
                                                                                  value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
                                                                                  
                                                                                  // We don't need an array for one selects
                                                      Severity: Major
                                                      Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                        Avoid deeply nested control flow statements.
                                                        Open

                                                                                if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
                                                                                    r.push( c );
                                                        Severity: Major
                                                        Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                          Avoid deeply nested control flow statements.
                                                          Open

                                                                                      for ( handler in events[type] )
                                                                                          // Handle the removal of namespaced events
                                                                                          if ( !parts[1] || events[type][handler].type == parts[1] )
                                                                                              delete events[type][handler];
                                                          Severity: Major
                                                          Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                            Avoid deeply nested control flow statements.
                                                            Open

                                                                                    if ( elem.id != match[3] )
                                                                                        return jQuery().find( selector );
                                                            
                                                                                    // Otherwise, we inject the element directly into the jQuery object
                                                                                    else {
                                                            Severity: Major
                                                            Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                              Avoid deeply nested control flow statements.
                                                              Open

                                                                                      for ( var i = 0; ret[i]; i++ ) {
                                                                                          // Grab the tag name being searched for
                                                                                          var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];
                                                              
                                                                                          // Handle IE7 being really dumb about <object>s
                                                              Severity: Major
                                                              Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                                Avoid deeply nested control flow statements.
                                                                Open

                                                                                    if ( !merge[id] ) {
                                                                                        var c = 1;
                                                                
                                                                                        for ( var n = parentNode.firstChild; n; n = n.nextSibling )
                                                                                            if ( n.nodeType == 1 )
                                                                Severity: Major
                                                                Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                                  Avoid deeply nested control flow statements.
                                                                  Open

                                                                                      if ( first == 0 ) {
                                                                                          if ( node.nodeIndex == last )
                                                                                              add = true;
                                                                                      } else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
                                                                                          add = true;
                                                                  Severity: Major
                                                                  Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                                    Avoid deeply nested control flow statements.
                                                                    Open

                                                                                            if ( m[1] == "#" ) {
                                                                                                var tmp = [];
                                                                    
                                                                                                // Try to find the element with the ID
                                                                                                for ( var i = 0; r[i]; i++ )
                                                                    Severity: Major
                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                                      Avoid deeply nested control flow statements.
                                                                      Open

                                                                                              if ( m[1] == "." )
                                                                                                  r = jQuery.classFilter( r, m[2] );
                                                                      Severity: Major
                                                                      Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                                        Avoid deeply nested control flow statements.
                                                                        Open

                                                                                                for ( ; n; n = n.nextSibling )
                                                                                                    if ( n.nodeType == 1 ) {
                                                                                                        var id = jQuery.data(n);
                                                                        
                                                                                                        if ( m == "~" && merge[id] ) break;
                                                                        Severity: Major
                                                                        Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                                          Avoid deeply nested control flow statements.
                                                                          Open

                                                                                                  if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
                                                                                                      oid = jQuery('[@id="'+m[2]+'"]', elem)[0];
                                                                          Severity: Major
                                                                          Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                                            Avoid deeply nested control flow statements.
                                                                            Open

                                                                                                if ( add ^ not )
                                                                                                    tmp.push( node );
                                                                            Severity: Major
                                                                            Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 45 mins to fix

                                                                              Consider simplifying this complex logical expression.
                                                                              Open

                                                                                          if ( getComputedStyle && !color( elem ) )
                                                                                              ret = getComputedStyle.getPropertyValue( name );
                                                                              
                                                                                          // If the element isn't reporting its values properly in Safari
                                                                                          // then some display: none elements are involved
                                                                              Severity: Major
                                                                              Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 40 mins to fix

                                                                                Function trigger has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                Open

                                                                                    trigger: function(type, data, elem, donative, extra) {
                                                                                Severity: Minor
                                                                                Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 35 mins to fix

                                                                                  Function prop has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                  Open

                                                                                      prop: function( elem, value, type, i, name ) {
                                                                                  Severity: Minor
                                                                                  Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 35 mins to fix

                                                                                    Avoid too many return statements within this function.
                                                                                    Open

                                                                                                    return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
                                                                                                        (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100).toString() :
                                                                                                        "";
                                                                                    Severity: Major
                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 30 mins to fix

                                                                                      Avoid too many return statements within this function.
                                                                                      Open

                                                                                                  return elem.getAttribute( name );
                                                                                      Severity: Major
                                                                                      Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 30 mins to fix

                                                                                        Avoid too many return statements within this function.
                                                                                        Open

                                                                                                return this.setArray(
                                                                                                    // HANDLE: $(array)
                                                                                                    selector.constructor == Array && selector ||
                                                                                        
                                                                                                    // HANDLE: $(arraylike)
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 30 mins to fix

                                                                                          Avoid too many return statements within this function.
                                                                                          Open

                                                                                                  return this.each(function(){
                                                                                                      if ( this.nodeType != 1 )
                                                                                                          return;
                                                                                          
                                                                                                      if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
                                                                                          Severity: Major
                                                                                          Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 30 mins to fix

                                                                                            Avoid too many return statements within this function.
                                                                                            Open

                                                                                                            return elem.getAttribute( name, 2 );
                                                                                            Severity: Major
                                                                                            Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 30 mins to fix

                                                                                              Avoid too many return statements within this function.
                                                                                              Open

                                                                                                          return elem[ name ];
                                                                                              Severity: Major
                                                                                              Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 30 mins to fix

                                                                                                Avoid too many return statements within this function.
                                                                                                Open

                                                                                                            return new jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );
                                                                                                Severity: Major
                                                                                                Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 30 mins to fix

                                                                                                  Avoid too many return statements within this function.
                                                                                                  Open

                                                                                                              return undefined;
                                                                                                  Severity: Major
                                                                                                  Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js - About 30 mins to fix

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

                                                                                                                jQuery.each( prop, function(name, val){
                                                                                                                    var e = new jQuery.fx( self, opt, name );
                                                                                                    
                                                                                                                    if ( /toggle|show|hide/.test(val) )
                                                                                                                        e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 day to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3892..3920

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

                                                                                                    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 ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
                                                                                                                jsonp = "jsonp" + jsc++;
                                                                                                    
                                                                                                                // Replace the =? sequence both in the query string and the data
                                                                                                                if ( s.data )
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 day to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3420..3443

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

                                                                                                    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

                                                                                                        removeData: function( elem, name ) {
                                                                                                            elem = elem == window ?
                                                                                                                windowData :
                                                                                                                elem;
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 day to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 1300..1338

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

                                                                                                    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

                                                                                                            mouseenter: {
                                                                                                                setup: function() {
                                                                                                                    if ( jQuery.browser.msie ) return false;
                                                                                                                    jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
                                                                                                                    return true;
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                    app/assets/javascripts/jquery-tooltip/lib/jquery.js on lines 2159..2179

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

                                                                                                    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

                                                                                                            mouseleave: {
                                                                                                                setup: function() {
                                                                                                                    if ( jQuery.browser.msie ) return false;
                                                                                                                    jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
                                                                                                                    return true;
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                    app/assets/javascripts/jquery-tooltip/lib/jquery.js on lines 2137..2157

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

                                                                                                    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

                                                                                                        text: function( text ) {
                                                                                                            if ( typeof text != "object" && text != null )
                                                                                                                return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
                                                                                                    
                                                                                                            var ret = "";
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 201..217

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

                                                                                                    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

                                                                                                            try {
                                                                                                                // Set the correct header, if data is being sent
                                                                                                                if ( s.data )
                                                                                                                    xml.setRequestHeader("Content-Type", s.contentType);
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 6 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3520..3537

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

                                                                                                    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

                                                                                                        data: function( elem, name, data ) {
                                                                                                            elem = elem == window ?
                                                                                                                windowData :
                                                                                                                elem;
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 6 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 1274..1298

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

                                                                                                    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 ( gotoEnd || t > this.options.duration + this.startTime ) {
                                                                                                                this.now = this.end;
                                                                                                                this.pos = this.state = 1;
                                                                                                                this.update();
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 6 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 4097..4144

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

                                                                                                    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 ( event.pageX == null && event.clientX != null ) {
                                                                                                                var doc = document.documentElement, body = document.body;
                                                                                                                event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
                                                                                                                event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
                                                                                                            }
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 6 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2739..2743

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

                                                                                                    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

                                                                                                        stop: function(clearQueue, gotoEnd){
                                                                                                            var timers = jQuery.timers;
                                                                                                    
                                                                                                            if (clearQueue)
                                                                                                                this.queue([]);
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 6 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3927..3949

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 156.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                                        !tags.indexOf("<opt") &&
                                                                                                                        [ 1, "<select multiple='multiple'>", "</select>" ] ||
                                                                                                                        
                                                                                                                        !tags.indexOf("<leg") &&
                                                                                                                        [ 1, "<fieldset>", "</fieldset>" ] ||
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 885..906

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

                                                                                                    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

                                                                                                        unique: function( array ) {
                                                                                                            var ret = [], done = {};
                                                                                                    
                                                                                                            try {
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 1113..1132

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

                                                                                                    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

                                                                                                        swap: function( elem, options, callback ) {
                                                                                                            var old = {};
                                                                                                            // Remember the old values, and insert the new ones
                                                                                                            for ( var name in options ) {
                                                                                                                old[ name ] = elem.style[ name ];
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 735..748

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

                                                                                                    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 ( this.options.display != null ) {
                                                                                                                        // Reset the overflow
                                                                                                                        this.elem.style.overflow = this.options.overflow;
                                                                                                                    
                                                                                                                        // Reset the display
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 4110..4118

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

                                                                                                    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 ( status == "success" ) {
                                                                                                                        // Cache Last-Modified header, if ifModified mode.
                                                                                                                        var modRes;
                                                                                                                        try {
                                                                                                                            modRes = xml.getResponseHeader("Last-Modified");
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3590..3604

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

                                                                                                    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

                                                                                                    function evalScript( i, elem ) {
                                                                                                        if ( elem.src )
                                                                                                            jQuery.ajax({
                                                                                                                url: elem.src,
                                                                                                                async: false,
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 543..556

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

                                                                                                    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

                                                                                                            add: function( elem, classNames ) {
                                                                                                                jQuery.each((classNames || "").split(/\s+/), function(i, className){
                                                                                                                    if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
                                                                                                                        elem.className += (elem.className ? " " : "") + className;
                                                                                                                });
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 711..716

                                                                                                    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

                                                                                                            function complete(){
                                                                                                                // Process result
                                                                                                                if ( s.complete )
                                                                                                                    s.complete(xml, status);
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3652..3664

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

                                                                                                    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

                                                                                                            remove: function( elem, classNames ) {
                                                                                                                if (elem.nodeType == 1)
                                                                                                                    elem.className = classNames != undefined ?
                                                                                                                        jQuery.grep(elem.className.split(/\s+/), function(className){
                                                                                                                            return !jQuery.className.has( classNames, className );    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 719..726

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

                                                                                                    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

                                                                                                        hide: function(){
                                                                                                            // Remember where we started, so that we can go back to it later
                                                                                                            this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
                                                                                                            this.options.hide = true;
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 4084..4091

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

                                                                                                    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 ( status == "success" || status == "notmodified" )
                                                                                                                        // See if a selector was specified
                                                                                                                        self.html( selector ?
                                                                                                                            // Create a dummy div to hold the results
                                                                                                                            jQuery("<div/>")
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3265..3278

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

                                                                                                    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

                                                                                                    jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
                                                                                                        "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," + 
                                                                                                        "submit,keydown,keypress,keyup,error").split(","), function(i, name){
                                                                                                        
                                                                                                        // Handle event binding
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3093..3101

                                                                                                    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

                                                                                                        easing: {
                                                                                                            linear: function( p, n, firstNum, diff ) {
                                                                                                                return firstNum + diff * p;
                                                                                                            },
                                                                                                            swing: function( p, n, firstNum, diff ) {
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3991..3998

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 82.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                        get: function( url, data, callback, type ) {
                                                                                                            // shift arguments if data argument was ommited
                                                                                                            if ( jQuery.isFunction( data ) ) {
                                                                                                                callback = data;
                                                                                                                data = null;
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3322..3336

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 82.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                        post: function( url, data, callback, type ) {
                                                                                                            if ( jQuery.isFunction( data ) ) {
                                                                                                                callback = data;
                                                                                                                data = {};
                                                                                                            }
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3346..3359

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

                                                                                                    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 ( jQuery.browser.msie && window == top ) (function(){
                                                                                                            if (jQuery.isReady) return;
                                                                                                            try {
                                                                                                                // If IE is used, use the trick by Diego Perini
                                                                                                                // http://javascript.nwbox.com/IEContentLoaded/
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3072..3086

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 80.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                                        test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
                                                                                                                            m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
                                                                                                                            !/\D/.test(m[3]) && "0n+" + m[3] || m[3]),
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 1803..1805

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

                                                                                                    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

                                                                                                        bind: function( type, data, fn ) {
                                                                                                            return type == "unload" ? this.one(type, data, fn) : this.each(function(){
                                                                                                                jQuery.event.add( this, type, fn || data, fn && data );
                                                                                                            });
                                                                                                        },
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2895..2899

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

                                                                                                            if ( !event.which && event.button )
                                                                                                                event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2755..2756

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 74.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                                if ( s.type.toLowerCase() == "get" ) {
                                                                                                                    if ( !s.url.match(jsre) )
                                                                                                                        s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
                                                                                                                } else if ( !s.data || !s.data.match(jsre) )
                                                                                                                    s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3411..3415

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 74.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                            opt.complete = function(){
                                                                                                                if ( opt.queue !== false )
                                                                                                                    jQuery(this).dequeue();
                                                                                                                if ( jQuery.isFunction( opt.old ) )
                                                                                                                    opt.old.apply( this );
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3981..3986

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

                                                                                                    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 ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
                                                                                                                event.which = event.charCode || event.keyCode;
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2746..2747

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

                                                                                                    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

                                                                                                                    jQuery( "option", this ).each(function(){
                                                                                                                        this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
                                                                                                                            jQuery.inArray( this.text, values ) >= 0);
                                                                                                                    });
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 470..473

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 70.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                        handleError: function( s, xml, status, e ) {
                                                                                                            // If a local callback was specified, fire it
                                                                                                            if ( s.error ) s.error( xml, status, e );
                                                                                                    
                                                                                                            // Fire the global callback
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3670..3677

                                                                                                    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

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

                                                                                                                                if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
                                                                                                                                    if (elem.removeEventListener)
                                                                                                                                        elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
                                                                                                                                    else if (elem.detachEvent)
                                                                                                                                        elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2566..2571

                                                                                                    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

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

                                                                                                        fx: function( elem, options, prop ){
                                                                                                            this.options = options;
                                                                                                            this.elem = elem;
                                                                                                            this.prop = prop;
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 4002..4009

                                                                                                    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

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

                                                                                                        nth: function(cur,result,dir,elem){
                                                                                                            result = result || 1;
                                                                                                            var num = 0;
                                                                                                    
                                                                                                            for ( ; cur; cur = cur[dir] )
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2401..2410

                                                                                                    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

                                                                                                                return !r.status && location.protocol == "file:" ||
                                                                                                                    ( r.status >= 200 && r.status < 300 ) || r.status == 304 || r.status == 1223 ||
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3686..3687

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 67.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                            return this.each(function(i){
                                                                                                                // Set all the styles
                                                                                                                for ( name in options )
                                                                                                                    jQuery.attr(
                                                                                                                        type ?
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 182..191

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

                                                                                                    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 ( !ret ) {
                                                                                                                    var handle = jQuery.data( elem, "handle" );
                                                                                                                    if ( handle ) handle.elem = null;
                                                                                                                    jQuery.removeData( elem, "events" );
                                                                                                                    jQuery.removeData( elem, "handle" );
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2581..2586

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

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                            return this.map(function(){
                                                                                                                return jQuery.nodeName(this, "form") ?
                                                                                                                    jQuery.makeArray(this.elements) : this;
                                                                                                            })
                                                                                                            .filter(function(){
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3291..3298

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

                                                                                                    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

                                                                                                    jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
                                                                                                        jQuery.fn[o] = function(f){
                                                                                                            return this.bind(o, f);
                                                                                                        };
                                                                                                    });
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3312..3316

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 62.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                        css: function( key, value ) {
                                                                                                            // ignore negative width and height values
                                                                                                            if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
                                                                                                                value = undefined;
                                                                                                            return this.attr( key, value, "curCSS" );
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 194..199

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 62.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                            function success(){
                                                                                                                // If a local callback was specified, fire it and pass it the data
                                                                                                                if ( s.success )
                                                                                                                    s.success( data, status );
                                                                                                    
                                                                                                    
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3642..3650

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

                                                                                                    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

                                                                                                                        for ( var j = tbody.length - 1; j >= 0 ; --j )
                                                                                                                            if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
                                                                                                                                tbody[ j ].parentNode.removeChild( tbody[ j ] );
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 930..932

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

                                                                                                    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 ( !event.relatedTarget && event.fromElement )
                                                                                                                event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2735..2736

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

                                                                                                    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

                                                                                                                    elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
                                                                                                                        return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
                                                                                                                            all :
                                                                                                                            front + "></" + tag + ">";
                                                                                                                    });
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 874..878

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

                                                                                                    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

                                                                                                                s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3453..3453

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

                                                                                                    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 ( s.data && s.processData && typeof s.data != "string" )
                                                                                                                s.data = jQuery.param(s.data);
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3406..3407

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

                                                                                                    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 ( s.data && s.type.toLowerCase() == "get" ) {
                                                                                                                s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
                                                                                                    
                                                                                                                // IE likes to send both get and post data, prevent this
                                                                                                                s.data = null;
                                                                                                    Severity: Major
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 1 hr to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3457..3462

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

                                                                                                    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

                                                                                                        setArray: function( elems ) {
                                                                                                            // Resetting the length to 0, then using the native Array push
                                                                                                            // is a super-fast way to populate an object with array-like properties
                                                                                                            this.length = 0;
                                                                                                            Array.prototype.push.apply( this, elems );
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 50 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 142..149

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 52.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                                    if ( this.options.hide || this.options.show )
                                                                                                                        for ( var p in this.options.curAnim )
                                                                                                                            jQuery.attr(this.elem.style, p, this.options.orig[p]);
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 50 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 4125..4127

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 52.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                                        if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem) === false ) {
                                                                                                                            // Bind the global event handler to the element
                                                                                                                            if (elem.addEventListener)
                                                                                                                                elem.addEventListener(type, handle, false);
                                                                                                                            else if (elem.attachEvent)
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 50 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2497..2503

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 52.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                                    for ( var i = 0; i < timers.length; i++ )
                                                                                                                        if ( !timers[i]() )
                                                                                                                            timers.splice(i--, 1);
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 50 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 4056..4058

                                                                                                    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

                                                                                                        map: function( callback ) {
                                                                                                            return this.pushStack( jQuery.map(this, function(elem, i){
                                                                                                                return callback.call( elem, i, elem );
                                                                                                            }));
                                                                                                        },
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 50 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 504..508

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 51.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                            event.preventDefault = function() {
                                                                                                                // if preventDefault exists run it on the original event
                                                                                                                if (originalEvent.preventDefault)
                                                                                                                    originalEvent.preventDefault();
                                                                                                                // otherwise set the returnValue property of the original event to false (IE)
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 45 mins to fix
                                                                                                    app/assets/javascripts/jquery-tooltip/lib/jquery.js on lines 2083..2089

                                                                                                    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

                                                                                                                if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
                                                                                                                    this.checked = (jQuery.inArray(this.value, value) >= 0 ||
                                                                                                                        jQuery.inArray(this.name, value) >= 0);
                                                                                                    
                                                                                                                else if ( jQuery.nodeName( this, "select" ) ) {
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 45 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 463..479

                                                                                                    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

                                                                                                            event.stopPropagation = function() {
                                                                                                                // if stopPropagation exists run it on the original event
                                                                                                                if (originalEvent.stopPropagation)
                                                                                                                    originalEvent.stopPropagation();
                                                                                                                // otherwise set the cancelBubble property of the original event to true (IE)
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 45 mins to fix
                                                                                                    app/assets/javascripts/jquery-tooltip/lib/jquery.js on lines 2076..2082

                                                                                                    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

                                                                                                        wrapInner: function( html ) {
                                                                                                            return this.each(function(){
                                                                                                                jQuery( this ).contents().wrapAll( html );
                                                                                                            });
                                                                                                        },
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 40 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 240..244

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

                                                                                                    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

                                                                                                            while ( cur && cur != document ) {
                                                                                                                if ( cur.nodeType == 1 )
                                                                                                                    matched.push( cur );
                                                                                                                cur = cur[dir];
                                                                                                            }
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 40 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2393..2397

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

                                                                                                    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 ( p == "height" || p == "width" ) {
                                                                                                                        // Store display property
                                                                                                                        opt.display = jQuery.css(this, "display");
                                                                                                    
                                                                                                                        // Make sure that nothing sneaks out
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 40 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3878..3884

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

                                                                                                    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

                                                                                                        removeAttr: function( name ) {
                                                                                                            jQuery.attr( this, name, "" );
                                                                                                            if (this.nodeType == 1) 
                                                                                                                this.removeAttribute( name );
                                                                                                        },
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 35 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 1219..1223

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 47.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                                var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 35 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 752..752

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 47.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                            try {
                                                                                                                xml.send(s.data);
                                                                                                            } catch(e) {
                                                                                                                jQuery.handleError(s, xml, null, e);
                                                                                                            }
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 35 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 3632..3636

                                                                                                    Duplicated Code

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

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

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

                                                                                                    Tuning

                                                                                                    This issue has a mass of 47.

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

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

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

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

                                                                                                    Refactorings

                                                                                                    Further Reading

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

                                                                                                                for ( var i in this.options.curAnim )
                                                                                                                    if ( this.options.curAnim[i] !== true )
                                                                                                                        done = false;
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 30 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 4105..4107

                                                                                                    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

                                                                                                        nodeName: function( elem, name ) {
                                                                                                            return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
                                                                                                        },
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 30 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 666..668

                                                                                                    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

                                                                                                        unbind: function( type, fn ) {
                                                                                                            return this.each(function(){
                                                                                                                jQuery.event.remove( this, type, fn );
                                                                                                            });
                                                                                                        },
                                                                                                    Severity: Minor
                                                                                                    Found in app/assets/javascripts/jquery-tooltip/lib/jquery.js and 1 other location - About 30 mins to fix
                                                                                                    app/assets/javascripts/jquery.js on lines 2911..2915

                                                                                                    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