Fix: Incorrectly warning about ignored files

lib/cli-engine.js

@@ -274,17 +274,37 @@ function isErrorMessage(message) {
  *
  * Also makes sure all path separators are POSIX style for `glob` compatibility.
  *
- * @param {string} pathname The directory path to be modified
- * @returns {string} The glob path or the file path itself
+ * @param {string[]} [extensions] An array of accepted extensions
+ * @returns {Function} A function that takes a pathname and returns a glob that
+ *                     matches all files with the provided extensions if
+ *                     pathname is a directory.
  */
-function processPath(pathname) {
-    var newPath = pathname;
+function processPath(extensions) {
+    var suffix = "/**";
 
-    if (shell.test("-d", pathname)) {
-        newPath = path.join(pathname, "**");
+    if (extensions) {
+        if (extensions.length === 1) {
+            suffix += "/*." + extensions[0];
+        } else {
+            suffix += "/*.{" + extensions.join(",") + "}";
+        }
     }
 
-    return newPath.replace(/\\/g, "/");
+    /**
+     * A function that converts a directory name to a glob pattern
+     *
+     * @param {string} pathname The directory path to be modified
+     * @returns {string} The glob path or the file path itself
+     */
+    return function(pathname) {
+        var newPath = pathname;
+
+        if (shell.test("-d", pathname)) {
+            newPath = pathname + suffix;
+        }
+
+        return newPath.replace(/\\/g, "/");
+    };
 }
 
 
@@ -409,32 +429,33 @@ CLIEngine.prototype = {
 
     /**
      * Executes the current configuration on an array of file and directory names.
-     * @param {string[]} files An array of file and directory names.
+     * @param {string[]} patterns An array of file and directory names.
      * @returns {Object} The results for all files that were linted.
      */
-    executeOnFiles: function(files) {
+    executeOnFiles: function(patterns) {
         var results = [],
             processed = {},
             options = this.options,
             fileCache = this._fileCache, // eslint-disable-line no-underscore-dangle
             configHelper = new Config(options),
-            ignoredPaths = options.ignore ? IgnoredPaths.load(options).patterns : [],
+            ignoredPaths = IgnoredPaths.load(options),
+            ignoredPathsList = ignoredPaths.patterns || [],
             extensions = options.extensions.map(function(ext) {
-                return ext.charAt(0) === "." ? ext : "." + ext;
+                return ext.charAt(0) === "." ? ext.substr(1) : ext;
             }),
             globOptions,
             stats,
             startTime;
 
         startTime = Date.now();
 
-        files = files.map(processPath);
-        ignoredPaths = ignoredPaths.map(processPath);
+        patterns = patterns.map(processPath(extensions));
+        ignoredPathsList = ignoredPathsList.map(processPath());
 
         globOptions = {
             nodir: true,
             realpath: true,
-            ignore: ignoredPaths
+            ignore: ignoredPathsList
         };
 
         /**
@@ -444,7 +465,7 @@ CLIEngine.prototype = {
          * @returns {void}
          */
         function executeOnFile(filename) {
-            if (extensions.indexOf(path.extname(filename)) === -1 || processed[filename]) {
+            if (processed[filename]) {
                 return;
             }
 
@@ -496,15 +517,19 @@ CLIEngine.prototype = {
             results.push(res);
         }
 
-        files.forEach(function(pattern) {
-            glob.sync(pattern, globOptions).forEach(executeOnFile);
+        patterns.forEach(function(pattern) {
+            if (shell.test("-f", pattern) && !ignoredPaths.contains(pattern)) {
+                executeOnFile(fs.realpathSync(pattern));
+            } else {
+                glob.sync(pattern, globOptions).forEach(executeOnFile);
+            }
         });
 
         // only warn for files explicitly passed on the command line
         if (options.ignore) {
-            files.forEach(function(file) {
+            patterns.forEach(function(file) {
                 var fullPath = path.resolve(file);
-                if (shell.test("-e", fullPath) && !processed[fullPath]) {
+                if (shell.test("-f", fullPath) && !processed[fullPath]) {
                     results.push(createIgnoreResult(file));
                 }
             });

tests/lib/cli-engine.js

@@ -304,6 +304,15 @@ describe("CLIEngine", function() {
             assert.equal(report.results[1].warningCount, 0);
         });
 
+        it("should process when file is given by not specifying extensions", function() {
+
+            engine = new CLIEngine();
+
+            var report = engine.executeOnFiles(["tests/fixtures/files/foo.js2"]);
+            assert.equal(report.results.length, 1);
+            assert.equal(report.results[0].messages.length, 0);
+        });
+
         it("should return zero messages when given a config with environment set to browser", function() {
 
             engine = new CLIEngine({