Sign upLogin

tyrbo/lolsummoners

View on GitHub
Star
app/assets/javascripts/jquery.tipsy.js

Summary

Maintainability
C
1 day
Test Coverage

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

        show: function() {
            var title = this.getTitle();
            if (title && this.enabled) {
                var $tip = this.tip();
Severity: Minor
Found in app/assets/javascripts/jquery.tipsy.js - About 1 hr to fix

    Function tipsy has 43 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        $.fn.tipsy = function(options) {
        
        if (options === true) {
            return this.data('tipsy');
        } else if (typeof options == 'string') {
    Severity: Minor
    Found in app/assets/javascripts/jquery.tipsy.js - About 1 hr to fix

      'title' is already defined.
      Open

                  var title, o = this.options;
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow variable redeclaration (no-redeclare)

      In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

      Rule Details

      This rule is aimed at eliminating variables that have multiple declarations in the same scope.

      Examples of incorrect code for this rule:

      /*eslint no-redeclare: "error"*/

var a = 3;
var a = 10;

      Examples of correct code for this rule:

      /*eslint no-redeclare: "error"*/

var a = 3;
// ...
a = 10;

      Options

      This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

      builtinGlobals

      Examples of incorrect code for the { "builtinGlobals": true } option:

      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/

var Object = 0;

      Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
/*eslint-env browser*/

var top = 0;

      The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. Source: http://eslint.org/docs/rules/

      'document' is not defined.
      Open

                      boundLeft = $(document).scrollLeft() + margin,
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'window' is not defined.
      Open

                  if ($(window).width() + $(document).scrollLeft() - $this.offset().left < margin) dir.ew = 'e';
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      Unnecessary semicolon.
      Open

              };
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow unnecessary semicolons (no-extra-semi)

      Typing mistakes and misunderstandings about where semicolons are required can lead to semicolons that are unnecessary. While not technically an error, extra semicolons can cause confusion when reading code.

      Rule Details

      This rule disallows unnecessary semicolons.

      Examples of incorrect code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;;

function foo() {
    // code
};

      Examples of correct code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;

var foo = function() {
    // code
};

      When Not To Use It

      If you intentionally use extra semicolons then you can disable this rule.

      Related Rules

      Unnecessary semicolon.
      Open

          };
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow unnecessary semicolons (no-extra-semi)

      Typing mistakes and misunderstandings about where semicolons are required can lead to semicolons that are unnecessary. While not technically an error, extra semicolons can cause confusion when reading code.

      Rule Details

      This rule disallows unnecessary semicolons.

      Examples of incorrect code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;;

function foo() {
    // code
};

      Examples of correct code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;

var foo = function() {
    // code
};

      When Not To Use It

      If you intentionally use extra semicolons then you can disable this rule.

      Related Rules

      Unnecessary semicolon.
      Open

          };
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow unnecessary semicolons (no-extra-semi)

      Typing mistakes and misunderstandings about where semicolons are required can lead to semicolons that are unnecessary. While not technically an error, extra semicolons can cause confusion when reading code.

      Rule Details

      This rule disallows unnecessary semicolons.

      Examples of incorrect code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;;

function foo() {
    // code
};

      Examples of correct code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;

var foo = function() {
    // code
};

      When Not To Use It

      If you intentionally use extra semicolons then you can disable this rule.

      Related Rules

      'document' is not defined.
      Open

                      $tip.remove().css({top: 0, left: 0, visibility: 'hidden', display: 'block'}).prependTo(document.body);
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'document' is not defined.
      Open

                  if ($(window).width() + $(document).scrollLeft() - $this.offset().left < margin) dir.ew = 'e';
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'setTimeout' is not defined.
      Open

                      setTimeout(function() { if (tipsy.hoverState == 'in') tipsy.show(); }, options.delayIn);
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'document' is not defined.
      Open

                      boundTop = $(document).scrollTop() + margin,
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      Unnecessary semicolon.
      Open

          };
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow unnecessary semicolons (no-extra-semi)

      Typing mistakes and misunderstandings about where semicolons are required can lead to semicolons that are unnecessary. While not technically an error, extra semicolons can cause confusion when reading code.

      Rule Details

      This rule disallows unnecessary semicolons.

      Examples of incorrect code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;;

function foo() {
    // code
};

      Examples of correct code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;

var foo = function() {
    // code
};

      When Not To Use It

      If you intentionally use extra semicolons then you can disable this rule.

      Related Rules

      'document' is not defined.
      Open

              return $(this).offset().top > ($(document).scrollTop() + $(window).height() / 2) ? 's' : 'n';
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'document' is not defined.
      Open

                  if ($(window).height() + $(document).scrollTop() - $this.offset().top < margin) dir.ns = 's';
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      Expected a conditional expression and instead saw an assignment.
      Open

            while (ele = ele.parentNode) {
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow assignment operators in conditional statements (no-cond-assign)

      In conditional statements, it is very easy to mistype a comparison operator (such as ==) as an assignment operator (such as =). For example:

      // Check the user's job title
if (user.jobTitle = "manager") {
    // user.jobTitle is now incorrect
}

      There are valid reasons to use assignment operators in conditional statements. However, it can be difficult to tell whether a specific assignment was intentional.

      Rule Details

      This rule disallows ambiguous assignment operators in test conditions of if, for, while, and do...while statements.

      Options

      This rule has a string option:

      • "except-parens" (default) allows assignments in test conditions only if they are enclosed in parentheses (for example, to allow reassigning a variable in the test of a while or do...while loop)
      • "always" disallows all assignments in test conditions

      except-parens

      Examples of incorrect code for this rule with the default "except-parens" option:

      /*eslint no-cond-assign: "error"*/

// Unintentional assignment
var x;
if (x = 0) {
    var b = 1;
}

// Practical example that is similar to an error
function setHeight(someNode) {
    "use strict";
    do {
        someNode.height = "100px";
    } while (someNode = someNode.parentNode);
}

      Examples of correct code for this rule with the default "except-parens" option:

      /*eslint no-cond-assign: "error"*/

// Assignment replaced by comparison
var x;
if (x === 0) {
    var b = 1;
}

// Practical example that wraps the assignment in parentheses
function setHeight(someNode) {
    "use strict";
    do {
        someNode.height = "100px";
    } while ((someNode = someNode.parentNode));
}

// Practical example that wraps the assignment and tests for 'null'
function setHeight(someNode) {
    "use strict";
    do {
        someNode.height = "100px";
    } while ((someNode = someNode.parentNode) !== null);
}

      always

      Examples of incorrect code for this rule with the "always" option:

      /*eslint no-cond-assign: ["error", "always"]*/

// Unintentional assignment
var x;
if (x = 0) {
    var b = 1;
}

// Practical example that is similar to an error
function setHeight(someNode) {
    "use strict";
    do {
        someNode.height = "100px";
    } while (someNode = someNode.parentNode);
}

// Practical example that wraps the assignment in parentheses
function setHeight(someNode) {
    "use strict";
    do {
        someNode.height = "100px";
    } while ((someNode = someNode.parentNode));
}

// Practical example that wraps the assignment and tests for 'null'
function setHeight(someNode) {
    "use strict";
    do {
        someNode.height = "100px";
    } while ((someNode = someNode.parentNode) !== null);
}

      Examples of correct code for this rule with the "always" option:

      /*eslint no-cond-assign: ["error", "always"]*/

// Assignment replaced by comparison
var x;
if (x === 0) {
    var b = 1;
}

      Related Rules

      'window' is not defined.
      Open

              return $(this).offset().top > ($(document).scrollTop() + $(window).height() / 2) ? 's' : 'n';
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'o' is already defined.
      Open

                  var title, o = this.options;
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow variable redeclaration (no-redeclare)

      In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

      Rule Details

      This rule is aimed at eliminating variables that have multiple declarations in the same scope.

      Examples of incorrect code for this rule:

      /*eslint no-redeclare: "error"*/

var a = 3;
var a = 10;

      Examples of correct code for this rule:

      /*eslint no-redeclare: "error"*/

var a = 3;
// ...
a = 10;

      Options

      This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

      builtinGlobals

      Examples of incorrect code for the { "builtinGlobals": true } option:

      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/

var Object = 0;

      Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
/*eslint-env browser*/

var top = 0;

      The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. Source: http://eslint.org/docs/rules/

      'window' is not defined.
      Open

                  if ($(window).height() + $(document).scrollTop() - $this.offset().top < margin) dir.ns = 's';
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'jQuery' is not defined.
      Open

      })(jQuery);
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      Unnecessary semicolon.
      Open

              };
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow unnecessary semicolons (no-extra-semi)

      Typing mistakes and misunderstandings about where semicolons are required can lead to semicolons that are unnecessary. While not technically an error, extra semicolons can cause confusion when reading code.

      Rule Details

      This rule disallows unnecessary semicolons.

      Examples of incorrect code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;;

function foo() {
    // code
};

      Examples of correct code for this rule:

      /*eslint no-extra-semi: "error"*/

var x = 5;

var foo = function() {
    // code
};

      When Not To Use It

      If you intentionally use extra semicolons then you can disable this rule.

      Related Rules

      'setTimeout' is not defined.
      Open

                      setTimeout(function() { if (tipsy.hoverState == 'out') tipsy.hide(); }, options.delayOut);
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'document' is not defined.
      Open

              if (ele == document) return true;
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'document' is not defined.
      Open

              return $(this).offset().left > ($(document).scrollLeft() + $(window).width() / 2) ? 'e' : 'w';
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      'window' is not defined.
      Open

              return $(this).offset().left > ($(document).scrollLeft() + $(window).width() / 2) ? 'e' : 'w';
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      Disallow Undeclared Variables (no-undef)

      This rule can help you locate potential ReferenceErrors resulting from misspellings of variable and parameter names, or accidental implicit globals (for example, from forgetting the var keyword in a for loop initializer).

      Rule Details

      Any reference to an undeclared variable causes a warning, unless the variable is explicitly mentioned in a /*global ...*/ comment.

      Examples of incorrect code for this rule:

      /*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      Examples of correct code for this rule with global declaration:

      /*global someFunction b:true*/
/*eslint no-undef: "error"*/

var a = someFunction();
b = 10;

      The b:true syntax in /*global */ indicates that assignment to b is correct.

      Examples of incorrect code for this rule with global declaration:

      /*global b*/
/*eslint no-undef: "error"*/

b = 10;

      By default, variables declared in /*global */ are read-only, therefore assignment is incorrect.

      Options

      • typeof set to true will warn for variables used inside typeof check (Default false).

      typeof

      Examples of correct code for the default { "typeof": false } option:

      /*eslint no-undef: "error"*/

if (typeof UndefinedIdentifier === "undefined") {
    // do something ...
}

      You can use this option if you want to prevent typeof check on a variable which has not been declared.

      Examples of incorrect code for the { "typeof": true } option:

      /*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Examples of correct code for the { "typeof": true } option with global declaration:

      /*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */

if(typeof a === "string"){}

      Environments

      For convenience, ESLint provides shortcuts that pre-define global variables exposed by popular libraries and runtime environments. This rule supports these environments, as listed in Specifying Environments. A few examples are given below.

      browser

      Examples of correct code for this rule with browser environment:

      /*eslint no-undef: "error"*/
/*eslint-env browser*/

setTimeout(function() {
    alert("Hello");
});

      node

      Examples of correct code for this rule with node environment:

      /*eslint no-undef: "error"*/
/*eslint-env node*/

var fs = require("fs");
module.exports = function() {
    console.log(fs);
};

      When Not To Use It

      If explicit declaration of global variables is not to your taste.

      Compatibility

      This rule provides compatibility with treatment of global variables in JSHint and JSLint. Source: http://eslint.org/docs/rules/

      Mixed spaces and tabs.
      Open

                      boundLeft = $(document).scrollLeft() + margin,
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow mixed spaces and tabs for indentation (no-mixed-spaces-and-tabs)

      Most code conventions require either tabs or spaces be used for indentation. As such, it's usually an error if a single line of code is indented with both tabs and spaces.

      Rule Details

      This rule disallows mixed spaces and tabs for indentation.

      Examples of incorrect code for this rule:

      /*eslint no-mixed-spaces-and-tabs: "error"*/

function add(x, y) {
// --->..return x + y;

      return x + y;
}

function main() {
// --->var x = 5,
// --->....y = 7;

    var x = 5,
        y = 7;
}

      Examples of correct code for this rule:

      /*eslint no-mixed-spaces-and-tabs: "error"*/

function add(x, y) {
// --->return x + y;
    return x + y;
}

      Options

      This rule has a string option.

      • "smart-tabs" allows mixed spaces and tabs when the latter are used for alignment.

      smart-tabs

      Examples of correct code for this rule with the "smart-tabs" option:

      /*eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/

function main() {
// --->var x = 5,
// --->....y = 7;

    var x = 5,
        y = 7;
}

      Further Reading

      Mixed spaces and tabs.
      Open

                      $this = $(this);
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow mixed spaces and tabs for indentation (no-mixed-spaces-and-tabs)

      Most code conventions require either tabs or spaces be used for indentation. As such, it's usually an error if a single line of code is indented with both tabs and spaces.

      Rule Details

      This rule disallows mixed spaces and tabs for indentation.

      Examples of incorrect code for this rule:

      /*eslint no-mixed-spaces-and-tabs: "error"*/

function add(x, y) {
// --->..return x + y;

      return x + y;
}

function main() {
// --->var x = 5,
// --->....y = 7;

    var x = 5,
        y = 7;
}

      Examples of correct code for this rule:

      /*eslint no-mixed-spaces-and-tabs: "error"*/

function add(x, y) {
// --->return x + y;
    return x + y;
}

      Options

      This rule has a string option.

      • "smart-tabs" allows mixed spaces and tabs when the latter are used for alignment.

      smart-tabs

      Examples of correct code for this rule with the "smart-tabs" option:

      /*eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/

function main() {
// --->var x = 5,
// --->....y = 7;

    var x = 5,
        y = 7;
}

      Further Reading

      Mixed spaces and tabs.
      Open

                      boundTop = $(document).scrollTop() + margin,
      Severity: Minor
      Found in app/assets/javascripts/jquery.tipsy.js by eslint

      disallow mixed spaces and tabs for indentation (no-mixed-spaces-and-tabs)

      Most code conventions require either tabs or spaces be used for indentation. As such, it's usually an error if a single line of code is indented with both tabs and spaces.

      Rule Details

      This rule disallows mixed spaces and tabs for indentation.

      Examples of incorrect code for this rule:

      /*eslint no-mixed-spaces-and-tabs: "error"*/

function add(x, y) {
// --->..return x + y;

      return x + y;
}

function main() {
// --->var x = 5,
// --->....y = 7;

    var x = 5,
        y = 7;
}

      Examples of correct code for this rule:

      /*eslint no-mixed-spaces-and-tabs: "error"*/

function add(x, y) {
// --->return x + y;
    return x + y;
}

      Options

      This rule has a string option.

      • "smart-tabs" allows mixed spaces and tabs when the latter are used for alignment.

      smart-tabs

      Examples of correct code for this rule with the "smart-tabs" option:

      /*eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/

function main() {
// --->var x = 5,
// --->....y = 7;

    var x = 5,
        y = 7;
}

      Further Reading

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

          $.fn.tipsy.autoWE = function() {
        return $(this).offset().left > ($(document).scrollLeft() + $(window).width() / 2) ? 'e' : 'w';
    };
      Severity: Major
      Found in app/assets/javascripts/jquery.tipsy.js and 1 other location - About 2 hrs to fix
      app/assets/javascripts/jquery.tipsy.js on lines 219..221

      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

          $.fn.tipsy.autoNS = function() {
        return $(this).offset().top > ($(document).scrollTop() + $(window).height() / 2) ? 's' : 'n';
    };
      Severity: Major
      Found in app/assets/javascripts/jquery.tipsy.js and 1 other location - About 2 hrs to fix
      app/assets/javascripts/jquery.tipsy.js on lines 223..225

      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 ($(window).height() + $(document).scrollTop() - $this.offset().top < margin) dir.ns = 's';
      Severity: Major
      Found in app/assets/javascripts/jquery.tipsy.js and 1 other location - About 1 hr to fix
      app/assets/javascripts/jquery.tipsy.js on lines 251..251

      Duplicated Code

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

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

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

      Tuning

      This issue has a mass of 60.

      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 ($(window).width() + $(document).scrollLeft() - $this.offset().left < margin) dir.ew = 'e';
      Severity: Major
      Found in app/assets/javascripts/jquery.tipsy.js and 1 other location - About 1 hr to fix
      app/assets/javascripts/jquery.tipsy.js on lines 252..252

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

      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