format with prettier

Author: MoOx

index.js

@@ -1,13 +1,13 @@
-"use strict"
+"use strict";
 
-var assign = require("object-assign")
-var loaderUtils = require("loader-utils")
-var objectHash = require("object-hash")
-var pkg = require("./package.json")
-var createCache = require("loader-fs-cache")
-var cache = createCache("eslint-loader")
+var assign = require("object-assign");
+var loaderUtils = require("loader-utils");
+var objectHash = require("object-hash");
+var pkg = require("./package.json");
+var createCache = require("loader-fs-cache");
+var cache = createCache("eslint-loader");
 
-var engines = {}
+var engines = {};
 
 /**
  * Class representing an ESLintError.
@@ -19,10 +19,10 @@ class ESLintError extends Error {
    * @param {string} messages - Formatted eslint errors.
    */
   constructor(messages) {
-    super()
-    this.name = "ESLintError"
-    this.message = messages
-    this.stack = ""
+    super();
+    this.name = "ESLintError";
+    this.message = messages;
+    this.stack = "";
   }
 
   /**
@@ -32,7 +32,7 @@ class ESLintError extends Error {
    * @return {string} error - A stringified representation of the error.
    */
   inspect() {
-    return this.message
+    return this.message;
   }
 }
 
@@ -47,87 +47,89 @@ class ESLintError extends Error {
 function printLinterOutput(res, config, webpack) {
   // skip ignored file warning
   if (
-    !(res.warningCount === 1 &&
+    !(
+      res.warningCount === 1 &&
       res.results[0].messages[0] &&
       res.results[0].messages[0].message &&
-      res.results[0].messages[0].message.indexOf("ignore") > 1)
+      res.results[0].messages[0].message.indexOf("ignore") > 1
+    )
   ) {
     // quiet filter done now
     // eslint allow rules to be specified in the input between comments
     // so we can found warnings defined in the input itself
     if (res.warningCount && config.quiet) {
-      res.warningCount = 0
-      res.results[0].warningCount = 0
+      res.warningCount = 0;
+      res.results[0].warningCount = 0;
       res.results[0].messages = res.results[0].messages.filter(function(
         message
       ) {
-        return message.severity !== 1
-      })
+        return message.severity !== 1;
+      });
     }
 
     // if enabled, use eslint auto-fixing where possible
     if (config.fix && res.results[0].output) {
-      var eslint = require(config.eslintPath)
-      eslint.CLIEngine.outputFixes(res)
+      var eslint = require(config.eslintPath);
+      eslint.CLIEngine.outputFixes(res);
     }
 
     if (res.errorCount || res.warningCount) {
       // add filename for each results so formatter can have relevant filename
       res.results.forEach(function(r) {
-        r.filePath = webpack.resourcePath
-      })
-      var messages = config.formatter(res.results)
+        r.filePath = webpack.resourcePath;
+      });
+      var messages = config.formatter(res.results);
 
       if (config.outputReport && config.outputReport.filePath) {
-        var reportOutput
+        var reportOutput;
         // if a different formatter is passed in as an option use that
         if (config.outputReport.formatter) {
-          reportOutput = config.outputReport.formatter(res.results)
-        }
-        else {
-          reportOutput = messages
+          reportOutput = config.outputReport.formatter(res.results);
+        } else {
+          reportOutput = messages;
         }
-        var filePath = loaderUtils.interpolateName(webpack,
-          config.outputReport.filePath, {
-            content: res.results.map(function(r) {
-              return r.source
-            }).join("\n"),
+        var filePath = loaderUtils.interpolateName(
+          webpack,
+          config.outputReport.filePath,
+          {
+            content: res.results
+              .map(function(r) {
+                return r.source;
+              })
+              .join("\n")
           }
-        )
-        webpack.emitFile(filePath, reportOutput)
+        );
+        webpack.emitFile(filePath, reportOutput);
       }
 
       // default behavior: emit error only if we have errors
-      var emitter = res.errorCount ? webpack.emitError : webpack.emitWarning
+      var emitter = res.errorCount ? webpack.emitError : webpack.emitWarning;
 
       // force emitError or emitWarning if user want this
       if (config.emitError) {
-        emitter = webpack.emitError
-      }
-      else if (config.emitWarning) {
-        emitter = webpack.emitWarning
+        emitter = webpack.emitError;
+      } else if (config.emitWarning) {
+        emitter = webpack.emitWarning;
       }
 
       if (emitter) {
         if (config.failOnError && res.errorCount) {
           throw new ESLintError(
             "Module failed because of a eslint error.\n" + messages
-          )
-        }
-        else if (config.failOnWarning && res.warningCount) {
+          );
+        } else if (config.failOnWarning && res.warningCount) {
           throw new ESLintError(
             "Module failed because of a eslint warning.\n" + messages
-          )
+          );
         }
 
-        emitter(new ESLintError(messages))
-      }
-      else {
+        emitter(new ESLintError(messages));
+      } else {
         throw new Error(
           "Your module system doesn't support emitWarning. " +
             "Update available? \n" +
             messages
-        )
+        );
       }
     }
   }
@@ -141,24 +143,23 @@ function printLinterOutput(res, config, webpack) {
  * @return {void}
  */
 module.exports = function(input, map) {
-  var webpack = this
+  var webpack = this;
 
   var userOptions = assign(
     // user defaults
     (webpack.options && webpack.options.eslint) || webpack.query || {},
     // loader query string
     loaderUtils.getOptions(webpack)
-  )
+  );
 
-  var userEslintPath = userOptions.eslintPath
-  var formatter = require("eslint/lib/formatters/stylish")
+  var userEslintPath = userOptions.eslintPath;
+  var formatter = require("eslint/lib/formatters/stylish");
 
   if (userEslintPath) {
     try {
-      formatter = require(userEslintPath + "/lib/formatters/stylish")
-    }
-    catch (e) {
-      formatter = require("eslint/lib/formatters/stylish")
+      formatter = require(userEslintPath + "/lib/formatters/stylish");
+    } catch (e) {
+      formatter = require("eslint/lib/formatters/stylish");
     }
   }
 
@@ -168,69 +169,68 @@ module.exports = function(input, map) {
       formatter: formatter,
       cacheIdentifier: JSON.stringify({
         "eslint-loader": pkg.version,
-        eslint: require(userEslintPath || "eslint").version,
+        eslint: require(userEslintPath || "eslint").version
       }),
-      eslintPath: "eslint",
+      eslintPath: "eslint"
     },
     userOptions
-  )
+  );
 
-  var cacheDirectory = config.cache
-  var cacheIdentifier = config.cacheIdentifier
+  var cacheDirectory = config.cache;
+  var cacheIdentifier = config.cacheIdentifier;
 
-  delete config.cacheIdentifier
+  delete config.cacheIdentifier;
 
   // Create the engine only once per config
-  var configHash = objectHash(config)
+  var configHash = objectHash(config);
   if (!engines[configHash]) {
-    var eslint = require(config.eslintPath)
-    engines[configHash] = new eslint.CLIEngine(config)
+    var eslint = require(config.eslintPath);
+    engines[configHash] = new eslint.CLIEngine(config);
   }
 
-  webpack.cacheable()
+  webpack.cacheable();
 
-  var resourcePath = webpack.resourcePath
-  var cwd = process.cwd()
+  var resourcePath = webpack.resourcePath;
+  var cwd = process.cwd();
 
   // remove cwd from resource path in case webpack has been started from project
   // root, to allow having relative paths in .eslintignore
   if (resourcePath.indexOf(cwd) === 0) {
-    resourcePath = resourcePath.substr(cwd.length + 1)
+    resourcePath = resourcePath.substr(cwd.length + 1);
   }
 
-  var engine = engines[configHash]
+  var engine = engines[configHash];
   // return early if cached
   if (config.cache) {
-    var callback = webpack.async()
+    var callback = webpack.async();
     return cache(
       {
         directory: cacheDirectory,
         identifier: cacheIdentifier,
         options: config,
         source: input,
         transform: function() {
-          return lint(engine, input, resourcePath)
-        },
+          return lint(engine, input, resourcePath);
+        }
       },
       function(err, res) {
         if (err) {
-          return callback(err)
+          return callback(err);
         }
 
         try {
-          printLinterOutput(res || {}, config, webpack)
-        }
-        catch (e) {
-          err = e
+          printLinterOutput(res || {}, config, webpack);
+        } catch (e) {
+          err = e;
         }
-        return callback(err, input, map)
+        return callback(err, input, map);
       }
-    )
+    );
   }
-  printLinterOutput(lint(engine, input, resourcePath), config, webpack)
-  webpack.callback(null, input, map)
-}
+  printLinterOutput(lint(engine, input, resourcePath), config, webpack);
+  webpack.callback(null, input, map);
+};
 
 function lint(engine, input, resourcePath) {
-  return engine.executeOnText(input, resourcePath, true)
+  return engine.executeOnText(input, resourcePath, true);
 }

test/autofix.js

@@ -1,46 +1,45 @@
-var test = require("ava")
-var webpack = require("webpack")
-var conf = require("./utils/conf")
-var fs = require("fs")
+var test = require("ava");
+var webpack = require("webpack");
+var conf = require("./utils/conf");
+var fs = require("fs");
 
 // clone the "fixable" file, so that we do not lose the original contents
 // when the fixes are applied to disk
 test.before(function() {
-  fs
-    .createReadStream("./test/fixtures/fixable.js")
-    .pipe(fs.createWriteStream("./test/fixtures/fixable-clone.js"))
-})
+  fs.createReadStream("./test/fixtures/fixable.js").pipe(
+    fs.createWriteStream("./test/fixtures/fixable-clone.js")
+  );
+});
 
-test.cb("loader doesn't throw error if file ok after auto-fixing",
-  function(t) {
-    t.plan(2)
-    webpack(conf(
-      {
-        entry: "./test/fixtures/fixable-clone.js",
-        module: {
-          rules: [
-            {
-              test: /\.js$/,
-              use: "./index?fix=true",
-              exclude: /node_modules/,
-            },
-          ],
-        },
+test.cb("loader doesn't throw error if file ok after auto-fixing", function(t) {
+  t.plan(2);
+  webpack(
+    conf({
+      entry: "./test/fixtures/fixable-clone.js",
+      module: {
+        rules: [
+          {
+            test: /\.js$/,
+            use: "./index?fix=true",
+            exclude: /node_modules/
+          }
+        ]
       }
-    ),
+    }),
     function(err, stats) {
       if (err) {
-        throw err
+        throw err;
       }
       // console.log(stats.compilation.errors)
-      t.false(stats.hasErrors(), "a good file doesn't give any error")
+      t.false(stats.hasErrors(), "a good file doesn't give any error");
       // console.log(stats.compilation.warnings)
-      t.false(stats.hasWarnings(), "a good file doesn't give any warning")
-      t.end()
-    })
-  })
+      t.false(stats.hasWarnings(), "a good file doesn't give any warning");
+      t.end();
+    }
+  );
+});
 
 // remove the clone
 test.after.always(function() {
-  fs.unlinkSync("./test/fixtures/fixable-clone.js")
-})
+  fs.unlinkSync("./test/fixtures/fixable-clone.js");
+});