Skip to content

Instantly share code, notes, and snippets.

@adityasaxena

adityasaxena/annotated-jshintrc.txt

Forked from JamieMason/annotated-jshintrc.txt
Created June 29, 2014 12:26
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save adityasaxena/0bf260c0529310ab60cd to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save adityasaxena/0bf260c0529310ab60cd to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. @JamieMason JamieMason created this gist Jun 13, 2014.
    814 changes: 814 additions & 0 deletions annotated-jshintrc.txt
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,814 @@
    {

    /**
    * Tell JSHint about global variables.
    */
    "predef": [

    // https://github.com/pivotal/jasmine
    "after",
    "afterEach",
    "before",
    "beforeEach",
    "console",
    "define",
    "describe",
    "expect",
    "exports",
    "it",
    "jasmine",
    "runs",
    "spyOn",
    "waitsFor",
    "xdescribe",
    "xit",

    // https://github.com/angular/angular.js
    "angular",
    "inject",
    "module",

    // https://github.com/angular/protractor
    "browser",
    "protractor"
    ],




    // Enforcing options
    // ---------------------------------------------------------------------------
    // When set to true, these options will make JSHint produce more warnings
    // about your code.
    // ---------------------------------------------------------------------------




    /**
    * This option prohibits the use of bitwise operators such as ^ (XOR), |
    * (OR) and others. Bitwise operators are very rare in JavaScript programs
    * and quite often & is simply a mistyped &&.
    */
    "bitwise": true,

    /**
    * This option allows you to force all variable names to use either camelCase
    * style or UPPER_CASE with underscores.
    */
    "camelcase": true,

    /**
    * This option requires you to always put curly braces around blocks in loops
    * and conditionals. JavaScript allows you to omit curly braces when the block
    * consists of only one statement, for example:
    *
    * while (day)
    * shuffle();
    *
    * However, in some circumstances, it can lead to bugs (you'd think that
    * sleep() is a part of the loop while in reality it is not):
    *
    * while (day)
    * shuffle();
    * sleep();
    */
    "curly": true,

    /**
    * This options prohibits the use of == and != in favor of === and !==. The
    * former try to coerce values before comparing them which can lead to some
    * unexpected results. The latter don't do any coercion so they are
    * generally safer. If you would like to learn more about type coercion in
    * JavaScript, we recommend Truth, Equality and JavaScript by Angus Croll.
    */
    "eqeqeq": true,

    /**
    * This option tells JSHint that your code needs to adhere to ECMAScript 3
    * specification. Use this option if you need your program to be executable
    * in older browsers—such as Internet Explorer 6/7/8/9—and other legacy
    * JavaScript environments.
    */
    "es3": true,

    /**
    * This option requires all for in loops to filter object's items. The for
    * in statement allows for looping through the names of all of the
    * properties of an object including those inherited throught the prototype
    * chain. This behavior can lead to unexpected items in your object so it is
    * generally safer to always filter inherited properties out as shown in the
    * example:
    *
    * for (key in obj) {
    * if (obj.hasOwnProperty(key)) {
    * // We are sure that obj[key] belongs to the object and was not
    * // inherited.
    * }
    * }
    *
    * For more in-depth understanding of for in loops in JavaScript, read
    * Exploring JavaScript for-in loops by Angus Croll.
    */
    "forin": true,

    /**
    * This options prohibits overwriting prototypes of native objects such as
    * Array, Date and so on.
    *
    * /* jshint freeze:true *\/
    * Array.prototype.count = function (value) { return 4; };
    * // -> Warning: Extending prototype of native object: 'Array'.
    */
    "freeze": true,

    /**
    * This option prohibits the use of immediate function invocations without
    * wrapping them in parentheses. Wrapping parentheses assists readers of
    * your code in understanding that the expression is the result of a
    * function, and not the function itself.
    */
    "immed": true,

    /**
    * This option enforces specific tab width for your code. For example, the
    * following code will trigger a warning on line 4:
    *
    * /*jshint indent:4 *\/
    *
    * if (cond) {
    * doSomething(); // We used only two spaces for indentation here
    * }
    */
    "indent": 2,

    /**
    * This option prohibits the use of a variable before it was defined.
    * JavaScript has function scope only and, in addition to that, all
    * variables are always moved—or hoisted— to the top of the function. This
    * behavior can lead to some very nasty bugs and that's why it is safer to
    * always use variable only after they have been explicitly defined.
    *
    * Setting this option to "nofunc" will allow function declarations to be
    * ignored.
    *
    * For more in-depth understanding of scoping and hoisting in JavaScript,
    * read JavaScript Scoping and Hoisting by Ben Cherry.
    */
    "latedef": false,

    /**
    * This option requires you to capitalize names of constructor functions.
    * Capitalizing functions that are intended to be used with new operator is
    * just a convention that helps programmers to visually distinguish
    * constructor functions from other types of functions to help spot mistakes
    * when using this.
    *
    * Not doing so won't break your code in any browsers or environments but it
    * will be a bit harder to figure out—by reading the code—if the function
    * was supposed to be used with or without new. And this is important
    * because when the function that was intended to be used with new is used
    * without it, this will point to the global object instead of a new object.
    */
    "newcap": true,

    /**
    * This option prohibits the use of arguments.caller and arguments.callee.
    * Both .caller and .callee make quite a few optimizations impossible so
    * they were deprecated in future versions of JavaScript. In fact,
    * ECMAScript 5 forbids the use of arguments.callee in strict mode.
    */
    "noarg": true,

    /**
    * This option warns when you have an empty block in your code. JSLint was
    * originally warning for all empty blocks and we simply made it optional.
    * There were no studies reporting that empty blocks in JavaScript break
    * your code in any way.
    */
    "noempty": true,

    /**
    * This option warns about "non-breaking whitespace" characters. These
    * characters can be entered with option-space on Mac computers and have a
    * potential of breaking non-UTF8 web pages.
    */
    "nonbsp": true,

    /**
    * This option prohibits the use of constructor functions for side-effects.
    * Some people like to call constructor functions without assigning its result
    * to any variable:
    *
    * new MyConstructor();
    *
    * There is no advantage in this approach over simply calling MyConstructor
    * since the object that the operator new creates isn't used anywhere so you
    * should generally avoid constructors like this one.
    */
    "nonew": true,

    /**
    * This option prohibits the use of unary increment and decrement operators.
    * Some people think that ++ and -- reduces the quality of their coding
    * styles and there are programming languages—such as Python—that go
    * completely without these operators.
    */
    "plusplus": false,

    /**
    * This option enforces the consistency of quotation marks used throughout
    * your code. It accepts three values: true if you don't want to enforce one
    * particular style but want some consistency, "single" if you want to allow
    * only single quotes and "double" if you want to allow only double quotes.
    */
    "quotmark": "single",

    /**
    * This option prohibits the use of explicitly undeclared variables. This
    * option is very useful for spotting leaking and mistyped variables.
    *
    * /*jshint undef:true*\/
    *
    * function test() {
    * var myVar = 'Hello, World';
    * console.log(myvar); // Oops, JSHint with undef will complain
    * }
    *
    * If your variable is defined in another file, you can use /*global ... *\/
    * directive to tell JSHint about it.
    */
    "undef": true,

    /**
    * This option warns when you define and never use your variables. It is very
    * useful for general code cleanup, especially when used in addition to undef.
    *
    * /*jshint unused:true*\/
    *
    * function test(a, b) {
    * var c, d = 2;
    *
    * return a + d;
    * }
    *
    * test(1, 2);
    *
    * // Line 3: 'b' was defined but never used.
    * // Line 4: 'c' was defined but never used.
    *
    * In addition to that, this option will warn you about unused global
    * variables declared via /*global ... *\/ directive.
    *
    * This can be set to vars to only check for variables, not function
    * parameters, or strict to check all variables and parameters. The default
    * (true) behavior is to allow unused parameters that are followed by a used
    * parameter.
    */
    "unused": true,

    /**
    * This option requires all functions to run in ECMAScript 5's strict mode.
    * Strict mode is a way to opt in to a restricted variant of JavaScript.
    * Strict mode eliminates some JavaScript pitfalls that didn't cause errors
    * by changing them to produce errors. It also fixes mistakes that made it
    * difficult for the JavaScript engines to perform certain optimizations.
    *
    * Note: This option enables strict mode for function scope only. It
    * prohibits the global scoped strict mode because it might break
    * third-party widgets on your page. If you really want to use global strict
    * mode, see the globalstrict option.
    */
    "strict": true,

    /**
    * This option makes it an error to leave a trailing whitespace in your code.
    * Trailing whitespaces can be source of nasty bugs with multi-line strings in
    * JavaScript:
    *
    * // This otherwise perfectly valid string will error if
    * // there is a whitespace after \
    * var str = "Hello \
    * World";
    */
    "trailing": true,

    /**
    * This option lets you set the max number of formal parameters allowed per
    * function:
    *
    * /*jshint maxparams:3*\/
    *
    * function login(request, onSuccess) {
    * // ...
    * }
    *
    * // JSHint: Too many parameters per function (4).
    * function logout(request, isManual, whereAmI, onSuccess) {
    * // ...
    * }
    */
    "maxparams": false,

    /**
    * This option lets you control how nested do you want your blocks to be:
    *
    * /*jshint maxdepth:2*\/
    *
    * function main(meaning) {
    * var day = true;
    *
    * if (meaning === 42) {
    * while (day) {
    * shuffle();
    *
    * if (tired) { // JSHint: Blocks are nested too deeply (3).
    * sleep();
    * }
    * }
    * }
    * }
    */
    "maxdepth": false,

    /**
    * This option lets you set the max number of statements allowed per function:
    *
    * /*jshint maxstatements:4*\/
    *
    * function main() {
    * var i = 0;
    * var j = 0;
    *
    * // Function declarations count as one statement. Their bodies
    * // don't get taken into account for the outer function.
    * function inner() {
    * var i2 = 1;
    * var j2 = 1;
    *
    * return i2 + j2;
    * }
    *
    * j = i + j;
    * return j; // JSHint: Too many statements per function. (5)
    * }
    */
    "maxstatements": false,

    /**
    * This option lets you control cyclomatic complexity throughout your code.
    * Cyclomatic complexity measures the number of linearly independent paths
    * through a program's source code. Read more about cyclomatic complexity on
    * Wikipedia.
    */
    "maxcomplexity": false,

    /**
    * This option lets you set the maximum length of a line.
    */
    "maxlen": false,




    // Relaxing options
    // ---------------------------------------------------------------------------
    // When set to true, these options will make JSHint produce less warnings
    // about your code.
    // ---------------------------------------------------------------------------




    /**
    * This option suppresses warnings about missing semicolons. There is a lot
    * of FUD about semicolon spread by quite a few people in the community. The
    * common myths are that semicolons are required all the time (they are not)
    * and that they are unreliable. JavaScript has rules about semicolons which
    * are followed by all browsers so it is up to you to decide whether you
    * should or should not use semicolons in your code.
    *
    * For more information about semicolons in JavaScript read An Open Letter
    * to JavaScript Leaders Regarding Semicolons by Isaac Schlueter and
    * JavaScript Semicolon Insertion.
    */
    "asi": false,

    /**
    * This option suppresses warnings about the use of assignments in cases
    * where comparisons are expected. More often than not, code like if (a =
    * 10) {} is a typo. However, it can be useful in cases like this one:
    *
    * for (var i = 0, person; person = people[i]; i++) {}
    *
    * You can silence this error on a per-use basis by surrounding the assignment
    * with parenthesis, such
    * as:
    *
    * for (var i = 0, person; (person = people[i]); i++) {}
    *
    */
    "boss": false,

    /**
    * This option suppresses warnings about the debugger statements in your code.
    */
    "debug": false,

    /**
    * This option suppresses warnings about == null comparisons. Such
    * comparisons are often useful when you want to check if a variable is null
    * or undefined.
    */
    "eqnull": false,

    /**
    * This option tells JSHint that your code uses ECMAScript 6 specific
    * syntax. Note that these features are not finalized yet and not all
    * browsers implement them.
    */
    "esnext": false,

    /**
    * This option suppresses warnings about the use of eval. The use of eval is
    * discouraged because it can make your code vulnerable to various injection
    * attacks and it makes it hard for JavaScript interpreter to do certain
    * optimizations.
    */
    "evil": true,

    /**
    * This option suppresses warnings about the use of expressions where
    * normally you would expect to see assignments or function calls. Most of
    * the time, such code is a typo. However, it is not forbidden by the spec
    * and that's why this warning is optional.
    */
    "expr": true,

    /**
    * This option suppresses warnings about declaring variables inside of
    * control structures while accessing them later from the outside. Even
    * though JavaScript has only two real scopes—global and function—such
    * practice leads to confusion among people new to the language and
    * hard-to-debug bugs. This is why, by default, JSHint warns about variables
    * that are used outside of their intended scope.
    *
    * function test() {
    * if (true) {
    * var x = 0;
    * }
    *
    * x += 1; // Default: 'x' used out of scope.
    * // No warning when funcscope:true
    * }
    */
    "funcscope": false,

    /**
    * This option makes JSHint compatible with Google Closure Compiler.
    */
    "gcl": false,

    /**
    * This option suppresses warnings about the use of global strict mode.
    * Global strict mode can break third-party widgets so it is not
    * recommended.
    *
    * For more info about strict mode see the strict option.
    */
    "globalstrict": false,

    /**
    * This option suppresses warnings about the __iterator__ property. This
    * property is not supported by all browsers so use it carefully.
    */
    "iterator": false,

    /**
    * This option suppresses warnings about missing semicolons, but only when the
    * semicolon is omitted for the last statement in a one-line block:
    *
    * var name = (function() { return 'Anton' }());
    *
    * This is a very niche use case that is useful only when you use automatic
    * JavaScript code generators.
    */
    "lastsemic": false,

    /**
    * This option suppresses most of the warnings about possibly unsafe line
    * breakings in your code. It doesn't suppress warnings about comma-first
    * coding style. To suppress those you have to use laxcomma (see below).
    */
    "laxbreak": false,

    /**
    * This option suppresses warnings about comma-first coding style:
    *
    * var obj = {
    * name: 'Anton'
    * , handle: 'valueof'
    * , role: 'SW Engineer'
    * };
    */
    "laxcomma": false,

    /**
    * This option suppresses warnings about functions inside of loops. Defining
    * functions inside of loops can lead to bugs such as this one:
    *
    * var nums = [];
    *
    * for (var i = 0; i < 10; i++) {
    * nums[i] = function (j) {
    * return i + j;
    * };
    * }
    *
    * nums[0](2); // Prints 12 instead of 2
    *
    * To fix the code above you need to copy the value of i:
    *
    * var nums = [];
    *
    * for (var i = 0; i < 10; i++) {
    * (function (i) {
    * nums[i] = function (j) {
    * return i + j;
    * };
    * }(i));
    * }
    */
    "loopfunc": false,

    /**
    * This options allows you to set the maximum amount of warnings JSHint will
    * produce before giving up. Default is 50.
    */
    "maxerr": false,

    /**
    * This options tells JSHint that your code uses Mozilla JavaScript
    * extensions. Unless you develop specifically for the Firefox web browser
    * you don't need this option.
    */
    "moz": false,

    /**
    * This option suppresses warnings about multi-line strings. Multi-line
    * strings can be dangerous in JavaScript because all hell breaks loose if
    * you accidentally put a whitespace in between the escape character (\) and
    * a new line.
    *
    * Note that even though this option allows correct multi-line strings, it
    * still warns about multi-line strings without escape characters or with
    * anything in between the escape character and a whitespace.
    *
    * /*jshint multistr:true*\/
    *
    * var text = "Hello\
    * World"; // All good.
    *
    * text = "Hello
    * World"; // Warning, no escape character.
    *
    * text = "Hello\
    * World"; // Warning, there is a space after \
    */
    "multistr": false,

    /**
    * This option suppresses warnings about invalid typeof operator values. This
    * operator has only a limited set of possible return values. By default,
    * JSHint warns when you compare its result with an invalid value which often
    * can be a typo.
    *
    * // 'fuction' instead of 'function'
    * if (typeof a == "fuction") { // Invalid typeof value 'fuction'
    * // ...
    * }
    *
    * Do not use this option unless you're absolutely sure you don't want these
    * checks.
    */
    "notypeof": false,

    /**
    * This option suppresses warnings about the __proto__ property.
    */
    "proto": false,

    /**
    * This option suppresses warnings about the use of script-targeted
    * URLs—such as javascript:....
    */
    "scripturl": false,

    /**
    * This option suppresses warnings about mixed tabs and spaces when the
    * latter are used for alignmnent only. The technique is called SmartTabs.
    */
    "smarttabs": false,

    /**
    * This option suppresses warnings about variable shadowing i.e. declaring a
    * variable that had been already declared somewhere in the outer scope.
    */
    "shadow": false,

    /**
    * This option suppresses warnings about using [] notation when it can be
    * expressed in dot notation:
    *
    * person['name'] vs. person.name.
    */
    "sub": true,

    /**
    * This option suppresses warnings about "weird" constructions like
    * `new function () { ... }` and `new Object;`. Such constructions are
    * sometimes used to produce singletons in JavaScript:
    *
    * var singleton = new function() {
    * var privateVar;
    *
    * this.publicMethod = function () {}
    * this.publicMethod2 = function () {}
    * };
    */
    "supernew": false,

    /**
    * This option suppresses warnings about possible strict violations when the
    * code is running in strict mode and you use this in a non-constructor
    * function. You should use this option—in a function scope only—when you
    * are positive that your use of this is valid in the strict mode (for
    * example, if you call your function using Function.call).
    *
    * Note: This option can be used only inside of a function scope. JSHint
    * will fail with an error if you will try to set this option globally.
    */
    "validthis": true,

    /**
    * This option suppresses warnings about generator functions with no yield
    * statement in them.
    */
    "noyield": false,




    // Environments
    // ---------------------------------------------------------------------------
    // These options let JSHint know about some pre-defined global variables.
    // ---------------------------------------------------------------------------




    /**
    * This option defines globals exposed by modern browsers: all the way from
    * good old document and navigator to the HTML5 FileReader and other new
    * developments in the browser world.
    *
    * Note: This option doesn't expose variables like alert or console. See
    * option devel for more information.
    */
    "browser": true,

    /**
    * This option defines globals exposed by CouchDB. CouchDB is a
    * document-oriented database that can be queried and indexed in a MapReduce
    * fashion using JavaScript.
    */
    "couch": false,

    /**
    * This option defines globals that are usually used for logging poor-man's
    * debugging: console, alert, etc. It is usually a good idea to not ship
    * them in production because, for example, console.log breaks in legacy
    * versions of Internet Explorer.
    */
    "devel": false,

    /**
    * This option defines globals exposed by the Dojo Toolkit.
    */
    "dojo": false,

    /**
    * This option defines globals exposed by the jQuery JavaScript library.
    */
    "jquery": false,

    /**
    * This option defines globals exposed by the MooTools JavaScript framework.
    */
    "mootools": false,

    /**
    * This option defines globals available when your code is running inside of
    * the Node runtime environment. Node.js is a server-side JavaScript
    * environment that uses an asynchronous event-driven model. This option
    * also skips some warnings that make sense in the browser environments but
    * don't make sense in Node such as file-level use strict pragmas and
    * console.log statements.
    */
    "node": true,

    /**
    * This option defines non-standard but widely adopted globals such as
    * escape and unescape.
    */
    "nonstandard": false,

    /**
    * This option defines globals available when your core is running inside of
    * the PhantomJS runtime environment. PhantomJS is a headless WebKit
    * scriptable with a JavaScript API. It has fast and native support for
    * various web standards: DOM handling, CSS selector, JSON, Canvas, and SVG.
    */
    "phantom": false,

    /**
    * This option defines globals exposed by the Prototype JavaScript framework.
    */
    "prototypejs": false,

    /**
    * This option defines globals available when your code is running inside of
    * the Rhino runtime environment. Rhino is an open-source implementation of
    * JavaScript written entirely in Java.
    */
    "rhino": false,

    /**
    * This option defines globals available when your code is running inside of
    * a Web Worker. Web Workers provide a simple means for web content to run
    * scripts in background threads.
    */
    "worker": false,

    /**
    * This option defines globals available when your code is running as a
    * script for the Windows Script Host.
    */
    "wsh": false,

    /**
    * This option defines globals exposed by the YUI JavaScript framework.
    */
    "yui": false,




    // Legacy
    // ---------------------------------------------------------------------------
    // These options are deprecated and will be removed soon. DO NOT use them.
    // ---------------------------------------------------------------------------




    /**
    * This option disallows the use of dangling _ in variables. We don't know why
    * would you need it.
    */
    "nomen": false,

    /**
    * This option allows only one var statement per function. Some people think
    * that having a single var in a function, at the top of the function, helps
    * readability. Example (taken from JSLint/JSHint source code):
    *
    * x.nud = function () {
    * var b, f, i, j, p, seen = {}, t;
    *
    * b = token.line !== nexttoken.line;
    * if (b) {
    * indent += option.indent;
    * if (nexttoken.from === indent + option.indent) {
    * indent += option.indent;
    * }
    * }
    *
    * // [...]
    * };
    */
    "onevar": false,

    /**
    * This option makes JSHint stop on the first error or warning.
    */
    "passfail": false,

    /**
    * This option make JSHint check your source code against Douglas
    * Crockford's JavaScript coding style. Unfortunately, his “The Good Parts”
    * book aside, the actual rules are not very well documented.
    */
    "white": false

    }