eslint 1.9.0 → 1.10.3

package/lib/config/config-initializer.js

@@ -0,0 +1,241 @@
+/**
+ * @fileoverview Config initialization wizard.
+ * @author Ilya Volodin
+ * @copyright 2015 Ilya Volodin. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var exec = require("child_process").exec,
+    inquirer = require("inquirer"),
+    ConfigFile = require("./config-file");
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+/* istanbul ignore next: hard to test fs function */
+/**
+ * Create .eslintrc file in the current working directory
+ * @param {object} config object that contains user's answers
+ * @param {string} format The file format to write to.
+ * @param {function} callback function to call once the file is written.
+ * @returns {void}
+ */
+function writeFile(config, format, callback) {
+
+    // default is .js
+    var extname = ".js";
+    if (format === "YAML") {
+        extname = ".yml";
+    } else if (format === "JSON") {
+        extname = ".json";
+    }
+
+
+    try {
+        ConfigFile.write(config, "./.eslintrc" + extname);
+        console.log("Successfully created .eslintrc" + extname + " file in " + process.cwd());
+    } catch (e) {
+        callback(e);
+        return;
+    }
+
+    // install any external configs as well as any included plugins
+    if (config.extends && config.extends.indexOf("eslint") === -1) {
+        console.log("Installing additional dependencies");
+        exec("npm i eslint-config-" + config.extends + " --save-dev", function(err) {
+
+            if (err) {
+                return callback(err);
+            }
+
+            // TODO: consider supporting more than 1 plugin though it's required yet.
+            exec("npm i eslint-plugin-" + config.plugins[0] + " --save-dev", callback);
+        });
+        return;
+    }
+
+    // install the react plugin if it was explictly chosen
+    if (config.plugins && config.plugins.indexOf("react") >= 0) {
+        console.log("Installing React plugin");
+        exec("npm i eslint-plugin-react --save-dev", callback);
+        return;
+    }
+    callback();
+}
+
+/**
+ * process user's answers and create config object
+ * @param {object} answers answers received from inquirer
+ * @returns {object} config object
+ */
+function processAnswers(answers) {
+    var config = {rules: {}, env: {}, extends: "eslint:recommended"};
+    config.rules.indent = [2, answers.indent];
+    config.rules.quotes = [2, answers.quotes];
+    config.rules["linebreak-style"] = [2, answers.linebreak];
+    config.rules.semi = [2, answers.semi ? "always" : "never"];
+    if (answers.es6) {
+        config.env.es6 = true;
+    }
+    answers.env.forEach(function(env) {
+        config.env[env] = true;
+    });
+    if (answers.jsx) {
+        config.ecmaFeatures = {jsx: true};
+        if (answers.react) {
+            config.plugins = ["react"];
+            config.ecmaFeatures.experimentalObjectRestSpread = true;
+        }
+    }
+    return config;
+}
+
+/**
+ * process user's style guide of choice and return an appropriate config object.
+ * @param {string} guide name of the chosen style guide
+ * @returns {object} config object
+ */
+function getConfigForStyleGuide(guide) {
+    var guides = {
+        google: {extends: "google"},
+        airbnb: {extends: "airbnb", plugins: ["react"]},
+        standard: {extends: "standard", plugins: ["standard"]}
+    };
+    if (!guides[guide]) {
+        throw new Error("You referenced an unsupported guide.");
+    }
+    return guides[guide];
+}
+
+/* istanbul ignore next: no need to test inquirer*/
+/**
+ * Ask use a few questions on command prompt
+ * @param {function} callback callback function when file has been written
+ * @returns {void}
+ */
+function promptUser(callback) {
+    inquirer.prompt([
+        {
+            type: "list",
+            name: "source",
+            message: "How would you like to configure ESLint?",
+            default: "prompt",
+            choices: [{name: "Answer questions about your style", value: "prompt"}, {name: "Use a popular style guide", value: "guide"}]
+        },
+        {
+            type: "list",
+            name: "styleguide",
+            message: "Which style guide do you want to follow?",
+            choices: [{name: "Google", value: "google"}, {name: "AirBnB", value: "airbnb"}, {name: "Standard", value: "standard"}],
+            when: function(answers) {
+                return answers.source === "guide";
+            }
+        },
+        {
+            type: "list",
+            name: "format",
+            message: "What format do you want your config file to be in?",
+            default: "JavaScript",
+            choices: ["JavaScript", "YAML", "JSON"],
+            when: function(answers) {
+                return answers.source === "guide";
+            }
+        }
+    ], function(earlyAnswers) {
+
+        // early exit if you are using a style guide
+        if (earlyAnswers.source === "guide") {
+            writeFile(getConfigForStyleGuide(earlyAnswers.styleguide), earlyAnswers.format, callback);
+            return;
+        }
+
+        // continue with the style questions otherwise...
+        inquirer.prompt([
+            {
+                type: "list",
+                name: "indent",
+                message: "What style of indentation do you use?",
+                default: "tabs",
+                choices: [{name: "Tabs", value: "tab"}, {name: "Spaces", value: 4}]
+            },
+            {
+                type: "list",
+                name: "quotes",
+                message: "What quotes do you use for strings?",
+                default: "double",
+                choices: [{name: "Double", value: "double"}, {name: "Single", value: "single"}]
+            },
+            {
+                type: "list",
+                name: "linebreak",
+                message: "What line endings do you use?",
+                default: "unix",
+                choices: [{name: "Unix", value: "unix"}, {name: "Windows", value: "windows"}]
+            },
+            {
+                type: "confirm",
+                name: "semi",
+                message: "Do you require semicolons?",
+                default: true
+            },
+            {
+                type: "confirm",
+                name: "es6",
+                message: "Are you using ECMAScript 6 features?",
+                default: false
+            },
+            {
+                type: "checkbox",
+                name: "env",
+                message: "Where will your code run?",
+                default: ["browser"],
+                choices: [{name: "Node", value: "node"}, {name: "Browser", value: "browser"}]
+            },
+            {
+                type: "confirm",
+                name: "jsx",
+                message: "Do you use JSX?",
+                default: false
+            },
+            {
+                type: "confirm",
+                name: "react",
+                message: "Do you use React",
+                default: false,
+                when: function(answers) {
+                    return answers.jsx;
+                }
+            },
+            {
+                type: "list",
+                name: "format",
+                message: "What format do you want your config file to be in?",
+                default: "JavaScript",
+                choices: ["JavaScript", "YAML", "JSON"]
+            }
+        ], function(answers) {
+            var config = processAnswers(answers);
+            writeFile(config, answers.format, callback);
+        });
+    });
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+var init = {
+    getConfigForStyleGuide: getConfigForStyleGuide,
+    processAnswers: processAnswers,
+    initializeConfig: /* istanbul ignore next */ function(callback) {
+        promptUser(callback);
+    }
+};
+
+module.exports = init;

package/lib/config/config-ops.js

@@ -0,0 +1,186 @@
+/**
+ * @fileoverview Config file operations. This file must be usable in the browser,
+ * so no Node-specific code can be here.
+ * @author Nicholas C. Zakas
+ * @copyright 2015 Nicholas C. Zakas. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var debug = require("debug"),
+    environments = require("../../conf/environments"),
+    assign = require("object-assign");
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+debug = debug("eslint:config-ops");
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+
+    /**
+     * Creates an empty configuration object suitable for merging as a base.
+     * @returns {Object} A configuration object.
+     */
+    createEmptyConfig: function() {
+        return {
+            globals: {},
+            env: {},
+            rules: {},
+            ecmaFeatures: {}
+        };
+    },
+
+    /**
+     * Creates an environment config based on the specified environments.
+     * @param {Object<string,boolean>} env The environment settings.
+     * @returns {Object} A configuration object with the appropriate rules and globals
+     *      set.
+     */
+    createEnvironmentConfig: function(env) {
+
+        var envConfig = this.createEmptyConfig();
+
+        if (env) {
+
+            envConfig.env = env;
+
+            Object.keys(env).filter(function(name) {
+                return env[name];
+            }).forEach(function(name) {
+                var environment = environments[name];
+
+                if (environment) {
+                    debug("Creating config for environment " + name);
+                    if (environment.globals) {
+                        assign(envConfig.globals, environment.globals);
+                    }
+
+                    if (environment.ecmaFeatures) {
+                        assign(envConfig.ecmaFeatures, environment.ecmaFeatures);
+                    }
+                }
+            });
+        }
+
+        return envConfig;
+    },
+
+    /**
+     * Given a config with environment settings, applies the globals and
+     * ecmaFeatures to the configuration and returns the result.
+     * @param {Object} config The configuration information.
+     * @returns {Object} The updated configuration information.
+     */
+    applyEnvironments: function(config) {
+        if (config.env && typeof config.env === "object") {
+            debug("Apply environment settings to config");
+            return this.merge(this.createEnvironmentConfig(config.env), config);
+        }
+
+        return config;
+    },
+
+    /**
+     * Merges two config objects. This will not only add missing keys, but will also modify values to match.
+     * @param {Object} target config object
+     * @param {Object} src config object. Overrides in this config object will take priority over base.
+     * @param {boolean} [combine] Whether to combine arrays or not
+     * @param {boolean} [isRule] Whether its a rule
+     * @returns {Object} merged config object.
+     */
+    merge: function deepmerge(target, src, combine, isRule) {
+        /*
+         The MIT License (MIT)
+
+         Copyright (c) 2012 Nicholas Fisher
+
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+
+         The above copyright notice and this permission notice shall be included in
+         all copies or substantial portions of the Software.
+
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+         THE SOFTWARE.
+         */
+        // This code is taken from deepmerge repo (https://github.com/KyleAMathews/deepmerge) and modified to meet our needs.
+        var array = Array.isArray(src) || Array.isArray(target);
+        var dst = array && [] || {};
+
+        combine = !!combine;
+        isRule = !!isRule;
+        if (array) {
+            target = target || [];
+            if (isRule && src.length > 1) {
+                dst = dst.concat(src);
+            } else {
+                dst = dst.concat(target);
+            }
+            if (typeof src !== "object" && !Array.isArray(src)) {
+                src = [src];
+            }
+            Object.keys(src).forEach(function(e, i) {
+                e = src[i];
+                if (typeof dst[i] === "undefined") {
+                    dst[i] = e;
+                } else if (typeof e === "object") {
+                    if (isRule) {
+                        dst[i] = e;
+                    } else {
+                        dst[i] = deepmerge(target[i], e, combine, isRule);
+                    }
+                } else {
+                    if (!combine) {
+                        dst[i] = e;
+                    } else {
+                        if (dst.indexOf(e) === -1) {
+                            dst.push(e);
+                        }
+                    }
+                }
+            });
+        } else {
+            if (target && typeof target === "object") {
+                Object.keys(target).forEach(function(key) {
+                    dst[key] = target[key];
+                });
+            }
+            Object.keys(src).forEach(function(key) {
+                if (Array.isArray(src[key]) || Array.isArray(target[key])) {
+                    dst[key] = deepmerge(target[key], src[key], key === "plugins", isRule);
+                } else if (typeof src[key] !== "object" || !src[key]) {
+                    dst[key] = src[key];
+                } else {
+                    if (!target[key]) {
+                        dst[key] = src[key];
+                    } else {
+                        dst[key] = deepmerge(target[key], src[key], combine, key === "rules");
+                    }
+                }
+            });
+        }
+
+        return dst;
+    }
+
+
+};

package/lib/{config-validator.js → config/config-validator.js}

@@ -10,14 +10,18 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-var rules = require("./rules"),
-    environments = require("../conf/environments"),
+var rules = require("../rules"),
+    environments = require("../../conf/environments"),
     schemaValidator = require("is-my-json-valid");
 
 var validators = {
     rules: Object.create(null)
 };
 
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
 /**
  * Gets a complete options schema for a rule.
  * @param {string} id The rule's unique name.
@@ -148,6 +152,10 @@ function validate(config, source) {
     validateEnvironment(config.env, source);
 }
 
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
 module.exports = {
     getRuleOptionsSchema: getRuleOptionsSchema,
     validate: validate,