eslint 1.9.0 → 1.10.3

package/lib/config.js

@@ -2,8 +2,9 @@
  * @fileoverview Responsible for loading config files
  * @author Seth McLaughlin
  * @copyright 2014 Nicholas C. Zakas. All rights reserved.
- * @copyright 2013 Seth McLaughlin. All rights reserved.
  * @copyright 2014 Michael McLaughlin. All rights reserved.
+ * @copyright 2013 Seth McLaughlin. All rights reserved.
+ * See LICENSE in root directory for full license.
  */
 "use strict";
 
@@ -11,29 +12,22 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-var fs = require("fs"),
-    path = require("path"),
-    environments = require("../conf/environments"),
+var path = require("path"),
+    ConfigOps = require("./config/config-ops"),
+    ConfigFile = require("./config/config-file"),
     util = require("./util"),
     FileFinder = require("./file-finder"),
-    stripComments = require("strip-json-comments"),
-    assign = require("object-assign"),
     debug = require("debug"),
-    yaml = require("js-yaml"),
     userHome = require("user-home"),
-    isAbsolutePath = require("path-is-absolute"),
     isResolvable = require("is-resolvable"),
-    validator = require("./config-validator"),
     pathIsInside = require("path-is-inside");
 
 //------------------------------------------------------------------------------
 // Constants
 //------------------------------------------------------------------------------
 
-var LOCAL_CONFIG_FILENAME = ".eslintrc",
-    PACKAGE_CONFIG_FILENAME = "package.json",
-    PACKAGE_CONFIG_FIELD_NAME = "eslintConfig",
-    PERSONAL_CONFIG_PATH = userHome ? path.join(userHome, LOCAL_CONFIG_FILENAME) : null;
+var PACKAGE_CONFIG_FILENAME = "package.json",
+    PERSONAL_CONFIG_DIR = userHome || null;
 
 //------------------------------------------------------------------------------
 // Private
@@ -47,18 +41,6 @@ var loadedPlugins = Object.create(null);
 
 debug = debug("eslint:config");
 
-/**
- * Determines if a given string represents a filepath or not using the same
- * conventions as require(), meaning that the first character must be nonalphanumeric
- * and not the @ sign which is used for scoped packages to be considered a file path.
- * @param {string} filePath The string to check.
- * @returns {boolean} True if it's a filepath, false if not.
- * @private
- */
-function isFilePath(filePath) {
-    return isAbsolutePath(filePath) || !/\w|@/.test(filePath.charAt(0));
-}
-
 /**
  * Check if item is an javascript object
  * @param {*} item object to check for
@@ -69,94 +51,6 @@ function isObject(item) {
     return typeof item === "object" && !Array.isArray(item) && item !== null;
 }
 
-/**
- * Creates an environment config based on the specified environments.
- * @param {Object<string,boolean>} envs The environment settings.
- * @returns {Object} A configuration object with the appropriate rules and globals
- *      set.
- * @private
- */
-function createEnvironmentConfig(envs) {
-
-    var envConfig = {
-        globals: {},
-        env: envs || {},
-        rules: {},
-        ecmaFeatures: {}
-    };
-
-    if (envs) {
-        Object.keys(envs).filter(function(name) {
-            return envs[name];
-        }).forEach(function(name) {
-            var environment = environments[name];
-
-            if (environment) {
-
-                if (environment.globals) {
-                    assign(envConfig.globals, environment.globals);
-                }
-
-                if (environment.ecmaFeatures) {
-                    assign(envConfig.ecmaFeatures, environment.ecmaFeatures);
-                }
-            }
-        });
-    }
-
-    return envConfig;
-}
-
-/**
- * Read the config from the config JSON file
- * @param {string} filePath the path to the JSON config file
- * @returns {Object} config object
- * @private
- */
-function readConfigFromFile(filePath) {
-    var config = {};
-
-    if (isFilePath(filePath)) {
-        if (path.extname(filePath) === ".js") { // using js files for config
-            config = require(filePath);
-        } else {
-            try {
-                config = yaml.safeLoad(stripComments(fs.readFileSync(filePath, "utf8"))) || {};
-            } catch (e) {
-                debug("Error reading YAML file: " + filePath);
-                e.message = "Cannot read config file: " + filePath + "\nError: " + e.message;
-                throw e;
-            }
-        }
-
-        if (path.basename(filePath) === PACKAGE_CONFIG_FILENAME) {
-            config = config[PACKAGE_CONFIG_FIELD_NAME] || {};
-        }
-
-    } else {
-
-        // it's a package
-
-        if (filePath.charAt(0) === "@") {
-            // it's a scoped package
-
-            // package name is "eslint-config", or just a username
-            var scopedPackageShortcutRegex = /^(@[^\/]+)(?:\/(?:eslint-config)?)?$/;
-            if (scopedPackageShortcutRegex.test(filePath)) {
-                filePath = filePath.replace(scopedPackageShortcutRegex, "$1/eslint-config");
-            } else if (filePath.split("/")[1].indexOf("eslint-config-") !== 0) {
-                // for scoped packages, insert the eslint-config after the first /
-                filePath = filePath.replace(/^@([^\/]+)\/(.*)$/, "@$1/eslint-config-$2");
-            }
-        } else if (filePath.indexOf("eslint-config-") !== 0) {
-            filePath = "eslint-config-" + filePath;
-        }
-
-        config = util.mergeConfigs(config, require(filePath));
-    }
-    return config;
-}
-
 /**
  * Load and parse a JSON config object from a file.
  * @param {string|Object} configToLoad the path to the JSON config file or the config object itself.
@@ -164,67 +58,24 @@ function readConfigFromFile(filePath) {
  * @private
  */
 function loadConfig(configToLoad) {
-    var config = {};
-    var filePath = "";
+    var config = {},
+        filePath = "";
 
     if (configToLoad) {
 
         if (isObject(configToLoad)) {
             config = configToLoad;
-        } else {
-            filePath = configToLoad;
-            config = readConfigFromFile(filePath);
-        }
-
-        validator.validate(config, filePath);
-
-        // If an `extends` property is defined, it represents a configuration file to use as
-        // a "parent". Load the referenced file and merge the configuration recursively.
-        if (config.extends) {
-            var configExtends = config.extends;
 
-            if (!Array.isArray(config.extends)) {
-                configExtends = [config.extends];
+            if (config.extends) {
+                config = ConfigFile.applyExtends(config, filePath);
             }
-
-            // Make the last element in an array take the highest precedence
-            config = configExtends.reduceRight(function(previousValue, parentPath) {
-
-                if (parentPath === "eslint:recommended") {
-                    // Add an explicit substitution for eslint:recommended to conf/eslint.json
-                    // this lets us use the eslint.json file as the recommended rules
-                    parentPath = path.resolve(__dirname, "../conf/eslint.json");
-                } else if (isFilePath(parentPath)) {
-                    // If the `extends` path is relative, use the directory of the current configuration
-                    // file as the reference point. Otherwise, use as-is.
-                    parentPath = (!isAbsolutePath(parentPath) ?
-                        path.join(path.dirname(filePath), parentPath) :
-                        parentPath
-                    );
-                }
-
-                try {
-                    return util.mergeConfigs(loadConfig(parentPath), previousValue);
-                } catch (e) {
-                    // If the file referenced by `extends` failed to load, add the path to the
-                    // configuration file that referenced it to the error message so the user is
-                    // able to see where it was referenced from, then re-throw
-                    e.message += "\nReferenced from: " + filePath;
-                    throw e;
-                }
-
-            }, config);
-
-        }
-
-        if (config.env) {
-            // Merge in environment-specific globals and ecmaFeatures.
-            config = util.mergeConfigs(createEnvironmentConfig(config.env), config);
+        } else {
+            filePath = configToLoad;
+            config = ConfigFile.load(filePath);
         }
 
     }
 
-
     return config;
 }
 
@@ -263,7 +114,7 @@ function getPluginsConfig(pluginNames) {
             rules[pluginNameWithoutPrefix + "/" + item] = plugin.rulesConfig[item];
         });
 
-        pluginConfig = util.mergeConfigs(pluginConfig, rules);
+        pluginConfig = ConfigOps.merge(pluginConfig, rules);
     });
 
     return {rules: pluginConfig};
@@ -275,11 +126,16 @@ function getPluginsConfig(pluginNames) {
  * @private
  */
 function getPersonalConfig() {
-    var config = {};
+    var config = {},
+        filename;
+
+    if (PERSONAL_CONFIG_DIR) {
+        filename = ConfigFile.getFilenameForDirectory(PERSONAL_CONFIG_DIR);
 
-    if (PERSONAL_CONFIG_PATH && fs.existsSync(PERSONAL_CONFIG_PATH)) {
-        debug("Using personal config");
-        config = loadConfig(PERSONAL_CONFIG_PATH);
+        if (filename) {
+            debug("Using personal config");
+            config = loadConfig(filename);
+        }
     }
 
     return config;
@@ -300,7 +156,7 @@ function getLocalConfig(thisConfig, directory) {
         localConfigFiles = thisConfig.findLocalConfigFiles(directory),
         numFiles = localConfigFiles.length,
         rootPath,
-        projectConfigPath = path.join(process.cwd(), LOCAL_CONFIG_FILENAME);
+        projectConfigPath = ConfigFile.getFilenameForDirectory(process.cwd());
 
     for (i = 0; i < numFiles; i++) {
 
@@ -308,7 +164,7 @@ function getLocalConfig(thisConfig, directory) {
 
         // Don't consider the personal config file in the home directory,
         // except if the home directory is the same as the current working directory
-        if (localConfigFile === PERSONAL_CONFIG_PATH && localConfigFile !== projectConfigPath) {
+        if (path.dirname(localConfigFile) === PERSONAL_CONFIG_DIR && localConfigFile !== projectConfigPath) {
             continue;
         }
 
@@ -320,8 +176,8 @@ function getLocalConfig(thisConfig, directory) {
         debug("Loading " + localConfigFile);
         localConfig = loadConfig(localConfigFile);
 
-        // Don't consider a local config file found if the config is empty.
-        if (!Object.keys(localConfig).length) {
+        // Don't consider a local config file found if the config is null
+        if (!localConfig) {
             continue;
         }
 
@@ -332,11 +188,11 @@ function getLocalConfig(thisConfig, directory) {
 
         found = true;
         debug("Using " + localConfigFile);
-        config = util.mergeConfigs(localConfig, config);
+        config = ConfigOps.merge(localConfig, config);
     }
 
     // Use the personal config file if there are no other local config files found.
-    return found ? config : util.mergeConfigs(config, getPersonalConfig());
+    return found ? config : ConfigOps.merge(config, getPersonalConfig());
 }
 
 //------------------------------------------------------------------------------
@@ -420,42 +276,42 @@ Config.prototype.getConfig = function(filePath) {
     }
 
     // Step 2: Create a copy of the baseConfig
-    config = util.mergeConfigs({parser: this.parser}, this.baseConfig);
+    config = ConfigOps.merge({parser: this.parser}, this.baseConfig);
 
     // Step 3: Merge in the user-specified configuration from .eslintrc and package.json
-    config = util.mergeConfigs(config, userConfig);
+    config = ConfigOps.merge(config, userConfig);
 
     // Step 4: Merge in command line config file
     if (this.useSpecificConfig) {
         debug("Merging command line config file");
 
-        config = util.mergeConfigs(config, this.useSpecificConfig);
+        config = ConfigOps.merge(config, this.useSpecificConfig);
     }
 
     // Step 5: Merge in command line environments
     debug("Merging command line environment settings");
-    config = util.mergeConfigs(config, createEnvironmentConfig(this.env));
+    config = ConfigOps.merge(config, ConfigOps.createEnvironmentConfig(this.env));
 
     // Step 6: Merge in command line rules
     if (this.options.rules) {
         debug("Merging command line rules");
-        config = util.mergeConfigs(config, { rules: this.options.rules });
+        config = ConfigOps.merge(config, { rules: this.options.rules });
     }
 
     // Step 7: Merge in command line globals
-    config = util.mergeConfigs(config, { globals: this.globals });
+    config = ConfigOps.merge(config, { globals: this.globals });
 
     // Step 8: Merge in command line plugins
     if (this.options.plugins) {
         debug("Merging command line plugins");
         pluginConfig = getPluginsConfig(this.options.plugins);
-        config = util.mergeConfigs(config, { plugins: this.options.plugins });
+        config = ConfigOps.merge(config, { plugins: this.options.plugins });
     }
 
     // Step 9: Merge in plugin specific rules in reverse
     if (config.plugins) {
         pluginConfig = getPluginsConfig(config.plugins);
-        config = util.mergeConfigs(pluginConfig, config);
+        config = ConfigOps.merge(pluginConfig, config);
     }
 
     this.cache[directory] = config;
@@ -471,7 +327,7 @@ Config.prototype.getConfig = function(filePath) {
 Config.prototype.findLocalConfigFiles = function(directory) {
 
     if (!this.localConfigFinder) {
-        this.localConfigFinder = new FileFinder(LOCAL_CONFIG_FILENAME, PACKAGE_CONFIG_FILENAME);
+        this.localConfigFinder = new FileFinder(ConfigFile.CONFIG_FILES, PACKAGE_CONFIG_FILENAME);
     }
 
     return this.localConfigFinder.findAllInDirectoryAndParents(directory);

package/lib/eslint.js

@@ -16,15 +16,16 @@ var estraverse = require("./util/estraverse"),
     blankScriptAST = require("../conf/blank-script.json"),
     assign = require("object-assign"),
     rules = require("./rules"),
-    util = require("./util"),
     RuleContext = require("./rule-context"),
     timing = require("./timing"),
     SourceCode = require("./util/source-code"),
     NodeEventGenerator = require("./util/node-event-generator"),
     CommentEventGenerator = require("./util/comment-event-generator"),
     EventEmitter = require("events").EventEmitter,
-    validator = require("./config-validator"),
-    replacements = require("../conf/replacements.json");
+    ConfigOps = require("./config/config-ops"),
+    validator = require("./config/config-validator"),
+    replacements = require("../conf/replacements.json"),
+    assert = require("assert");
 
 var DEFAULT_PARSER = require("../conf/eslint.json").parser;
 
@@ -111,25 +112,6 @@ function parseListConfig(string) {
     return items;
 }
 
-/**
- * @param {Scope} scope The scope object to check.
- * @param {string} name The name of the variable to look up.
- * @returns {Variable} The variable object if found or null if not.
- */
-function getVariable(scope, name) {
-    var variable = null;
-    scope.variables.some(function(v) {
-        if (v.name === name) {
-            variable = v;
-            return true;
-        } else {
-            return false;
-        }
-
-    });
-    return variable;
-}
-
 /**
  * Ensures that variables representing built-in properties of the Global Object,
  * and any globals declared by special block comments, are present in the global
@@ -161,29 +143,31 @@ function addDeclaredGlobals(program, globalScope, config) {
     assign(explicitGlobals, config.astGlobals);
 
     Object.keys(declaredGlobals).forEach(function(name) {
-        var variable = getVariable(globalScope, name);
+        var variable = globalScope.set.get(name);
         if (!variable) {
             variable = new escope.Variable(name, globalScope);
             variable.eslintExplicitGlobal = false;
             globalScope.variables.push(variable);
+            globalScope.set.set(name, variable);
         }
         variable.writeable = declaredGlobals[name];
     });
 
     Object.keys(explicitGlobals).forEach(function(name) {
-        var variable = getVariable(globalScope, name);
+        var variable = globalScope.set.get(name);
         if (!variable) {
             variable = new escope.Variable(name, globalScope);
             variable.eslintExplicitGlobal = true;
             variable.eslintExplicitGlobalComment = explicitGlobals[name].comment;
             globalScope.variables.push(variable);
+            globalScope.set.set(name, variable);
         }
         variable.writeable = explicitGlobals[name].value;
     });
 
     // mark all exported variables as such
     Object.keys(exportedGlobals).forEach(function(name) {
-        var variable = getVariable(globalScope, name);
+        var variable = globalScope.set.get(name);
         if (variable) {
             variable.eslintUsed = true;
         }
@@ -329,12 +313,12 @@ function modifyConfigsFromComments(filename, ast, config, reportingConfig, messa
     // apply environment configs
     Object.keys(commentConfig.env).forEach(function(name) {
         if (environments[name]) {
-            commentConfig = util.mergeConfigs(commentConfig, environments[name]);
+            commentConfig = ConfigOps.merge(commentConfig, environments[name]);
         }
     });
     assign(commentConfig.rules, commentRules);
 
-    return util.mergeConfigs(config, commentConfig);
+    return ConfigOps.merge(config, commentConfig);
 }
 
 /**
@@ -399,10 +383,10 @@ function prepareConfig(config) {
     preparedConfig = {
         rules: copiedRules,
         parser: config.parser || DEFAULT_PARSER,
-        globals: util.mergeConfigs({}, config.globals),
-        env: util.mergeConfigs({}, config.env || {}),
-        settings: util.mergeConfigs({}, config.settings || {}),
-        ecmaFeatures: util.mergeConfigs(ecmaFeatures, config.ecmaFeatures || {})
+        globals: ConfigOps.merge({}, config.globals),
+        env: ConfigOps.merge({}, config.env || {}),
+        settings: ConfigOps.merge({}, config.settings || {}),
+        ecmaFeatures: ConfigOps.merge(ecmaFeatures, config.ecmaFeatures || {})
     };
 
     // can't have global return inside of modules
@@ -605,22 +589,32 @@ module.exports = (function() {
      * Verifies the text against the rules specified by the second argument.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
      * @param {Object} config An object whose keys specify the rules to use.
-     * @param {string=} filename The optional filename of the file being checked.
-     *      If this is not set, the filename will default to '<input>' in the rule context.
-     * @param {boolean=} saveState Indicates if the state from the last run should be saved.
+     * @param {(string|Object)} [filenameOrOptions] The optional filename of the file being checked.
+     *      If this is not set, the filename will default to '<input>' in the rule context. If
+     *      an object, then it has "filename", "saveState", and "allowInlineConfig" properties.
+     * @param {boolean} [saveState] Indicates if the state from the last run should be saved.
      *      Mostly useful for testing purposes.
+     * @param {boolean} [filenameOrOptions.allowInlineConfig] Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied.
+     *      Useful if you want to validate JS without comments overriding rules.
      * @returns {Object[]} The results as an array of messages or null if no messages.
      */
-    api.verify = function(textOrSourceCode, config, filename, saveState) {
+    api.verify = function(textOrSourceCode, config, filenameOrOptions, saveState) {
 
         var ast,
             shebang,
             ecmaFeatures,
             ecmaVersion,
+            allowInlineConfig,
             text = (typeof textOrSourceCode === "string") ? textOrSourceCode : null;
 
-        // set the current parsed filename
-        currentFilename = filename;
+        // evaluate arguments
+        if (typeof filenameOrOptions === "object") {
+            currentFilename = filenameOrOptions.filename;
+            allowInlineConfig = filenameOrOptions.allowInlineConfig;
+            saveState = filenameOrOptions.saveState;
+        } else {
+            currentFilename = filenameOrOptions;
+        }
 
         if (!saveState) {
             this.reset();
@@ -667,7 +661,9 @@ module.exports = (function() {
         if (ast) {
 
             // parse global comments and modify config
-            config = modifyConfigsFromComments(filename, ast, config, reportingConfig, messages);
+            if (allowInlineConfig !== false) {
+                config = modifyConfigsFromComments(currentFilename, ast, config, reportingConfig, messages);
+            }
 
             // enable appropriate rules
             Object.keys(config.rules).filter(function(key) {
@@ -806,13 +802,19 @@ module.exports = (function() {
      * @returns {void}
      */
     api.report = function(ruleId, severity, node, location, message, opts, fix) {
+        if (node) {
+            assert.strictEqual(typeof node, "object", "Node must be an object");
+        }
 
         if (typeof location === "string") {
+            assert.ok(node, "Node must be provided when reporting error if location is not provided");
+
             fix = opts;
             opts = message;
             message = location;
             location = node.loc.start;
         }
+        // else, assume location was provided, so node may be omitted
 
         if (isDisabledByReportingConfig(reportingConfig, ruleId, location)) {
             return;
@@ -835,7 +837,7 @@ module.exports = (function() {
             message: message,
             line: location.line,
             column: location.column + 1,   // switch to 1-base instead of 0-base
-            nodeType: node.type,
+            nodeType: node && node.type,
             source: sourceCode.lines[location.line - 1] || ""
         };
 
@@ -878,8 +880,14 @@ module.exports = (function() {
 
     // copy over methods
     Object.keys(externalMethods).forEach(function(methodName) {
-        api[methodName] = function() {
-            return sourceCode ? sourceCode[externalMethods[methodName]].apply(sourceCode, arguments) : null;
+        var exMethodName = externalMethods[methodName];
+
+        // All functions expected to have less arguments than 5.
+        api[methodName] = function(a, b, c, d, e) {
+            if (sourceCode) {
+                return sourceCode[exMethodName](a, b, c, d, e);
+            }
+            return null;
         };
     });
 

package/lib/file-finder.js

@@ -2,6 +2,8 @@
  * @fileoverview Util class to find config files.
  * @author Aliaksei Shytkin
  * @copyright 2014 Michael McLaughlin. All rights reserved.
+ * @copyright 2014 Aliaksei Shytkin. All rights reserved.
+ * See LICENSE in root directory for full license.
  */
 "use strict";
 
@@ -61,6 +63,7 @@ FileFinder.prototype.findInDirectoryOrParents = function(directory) {
         filePath,
         i,
         name,
+        names,
         searched;
 
     if (!directory) {
@@ -74,20 +77,26 @@ FileFinder.prototype.findInDirectoryOrParents = function(directory) {
     dirs = [];
     searched = 0;
     name = this.fileNames[0];
+    names = Array.isArray(name) ? name : [name];
 
-    while (directory !== child) {
-        dirs[searched++] = directory;
+    (function() {
+        while (directory !== child) {
+            dirs[searched++] = directory;
 
-        if (getDirectoryEntries(directory).indexOf(name) !== -1 && fs.statSync(path.resolve(directory, name)).isFile()) {
-            filePath = path.resolve(directory, name);
-            break;
-        }
+            for (var k = 0, found = false; k < names.length && !found; k++) {
 
-        child = directory;
+                if (getDirectoryEntries(directory).indexOf(names[k]) !== -1 && fs.statSync(path.resolve(directory, names[k])).isFile()) {
+                    filePath = path.resolve(directory, names[k]);
+                    return;
+                }
+            }
 
-        // Assign parent directory to directory.
-        directory = path.dirname(directory);
-    }
+            child = directory;
+
+            // Assign parent directory to directory.
+            directory = path.dirname(directory);
+        }
+    }());
 
     for (i = 0; i < searched; i++) {
         cache[dirs[i]] = filePath;
@@ -137,14 +146,24 @@ FileFinder.prototype.findAllInDirectoryAndParents = function(directory) {
         for (i = 0; i < fileNamesCount; i++) {
             name = fileNames[i];
 
-            if (getDirectoryEntries(directory).indexOf(name) !== -1 && fs.statSync(path.resolve(directory, name)).isFile()) {
-                filePath = path.resolve(directory, name);
+            // convert to an array for easier handling
+            if (!Array.isArray(name)) {
+                name = [name];
+            }
 
-                // Add the file path to the cache of each directory searched.
-                for (j = 0; j < searched; j++) {
-                    cache[dirs[j]].push(filePath);
+            for (var k = 0, found = false; k < name.length && !found; k++) {
+
+                if (getDirectoryEntries(directory).indexOf(name[k]) !== -1 && fs.statSync(path.resolve(directory, name[k])).isFile()) {
+                    filePath = path.resolve(directory, name[k]);
+                    found = true;
+
+                    // Add the file path to the cache of each directory searched.
+                    for (j = 0; j < searched; j++) {
+                        cache[dirs[j]].push(filePath);
+                    }
                 }
             }
+
         }
         child = directory;
 

package/lib/ignored-paths.js

@@ -103,7 +103,7 @@ IgnoredPaths.load = function(options) {
     }
 
     if (options.ignorePattern) {
-        patterns.push(options.ignorePattern);
+        patterns = patterns.concat(options.ignorePattern);
     }
 
     return new IgnoredPaths(patterns);