Update eslint-config-stylelint (#3733)

* Update eslint and eslint-config-stylelint

* Format files with new ESLint rules

jest-setup.js

@@ -32,6 +32,7 @@ global.testRule = (rule, schema) => {
     };
 
     let passingTestCases = schema.accept || [];
+
     if (!schema.skipBasicChecks) {
       passingTestCases = passingTestCases.concat(basicChecks);
     }
@@ -40,6 +41,7 @@ global.testRule = (rule, schema) => {
       describe("accept", () => {
         passingTestCases.forEach(testCase => {
           const spec = testCase.only ? it.only : it;
+
           describe(JSON.stringify(schema.config, replacer), () => {
             describe(JSON.stringify(testCase.code), () => {
               spec(testCase.description || "no description", () => {
@@ -48,15 +50,18 @@ global.testRule = (rule, schema) => {
                   config: stylelintConfig,
                   syntax: schema.syntax
                 };
+
                 return stylelint(options).then(output => {
                   expect(output.results[0].warnings).toEqual([]);
                   expect(output.results[0].parseErrors).toEqual([]);
+
                   if (!schema.fix) return;
 
                   // Check the fix
                   return stylelint(Object.assign({ fix: true }, options)).then(
                     output => {
                       const fixedCode = getOutputCss(output);
+
                       expect(fixedCode).toBe(testCase.code);
                     }
                   );
@@ -72,6 +77,7 @@ global.testRule = (rule, schema) => {
       describe("reject", () => {
         schema.reject.forEach(testCase => {
           const spec = testCase.only ? it.only : it;
+
           describe(JSON.stringify(schema.config, replacer), () => {
             describe(JSON.stringify(testCase.code), () => {
               spec(testCase.description || "no description", () => {
@@ -80,6 +86,7 @@ global.testRule = (rule, schema) => {
                   config: stylelintConfig,
                   syntax: schema.syntax
                 };
+
                 return stylelint(options).then(output => {
                   const warning = output.results[0].warnings[0];
 
@@ -89,16 +96,22 @@ global.testRule = (rule, schema) => {
                   if (testCase.message !== undefined) {
                     expect(_.get(warning, "text")).toBe(testCase.message);
                   }
+
                   if (testCase.line !== undefined) {
                     expect(_.get(warning, "line")).toBe(testCase.line);
                   }
+
                   if (testCase.column !== undefined) {
                     expect(_.get(warning, "column")).toBe(testCase.column);
                   }
 
                   if (!schema.fix) return;
 
-                  if (!testCase.fixed && testCase.fixed !== "" && !testCase.unfixable) {
+                  if (
+                    !testCase.fixed &&
+                    testCase.fixed !== "" &&
+                    !testCase.unfixable
+                  ) {
                     throw new Error(
                       "If using { fix: true } in test schema, all reject cases must have { fixed: .. }"
                     );
@@ -108,6 +121,7 @@ global.testRule = (rule, schema) => {
                   return stylelint(Object.assign({ fix: true }, options))
                     .then(output => {
                       const fixedCode = getOutputCss(output);
+
                       if (!testCase.unfixable) {
                         expect(fixedCode).toBe(testCase.fixed);
                         expect(fixedCode).not.toBe(testCase.code);
@@ -116,8 +130,10 @@ global.testRule = (rule, schema) => {
                         if (testCase.fixed) {
                           expect(fixedCode).toBe(testCase.fixed);
                         }
+
                         expect(fixedCode).toBe(testCase.code);
                       }
+
                       return {
                         fixedCode,
                         warnings: output.results[0].warnings
@@ -151,10 +167,12 @@ global.testRule = (rule, schema) => {
 function getOutputCss(output) {
   const result = output.results[0]._postcssResult;
   const css = result.root.toString(result.opts.syntax);
+
   if (result.opts.syntax === less) {
     // Less needs us to manually strip whitespace at the end of single-line comments ¯\_(ツ)_/¯
     return css.replace(/(\n?\s*\/\/.*?)[ \t]*(\r?\n)/g, "$1$2");
   }
+
   return css;
 }
 

lib/__tests__/createLinter.test.js

@@ -10,6 +10,7 @@ it("createLinter().getConfigForFile augmented config loads", () => {
     __dirname,
     "fixtures/getConfigForFile/a/b/foo.css"
   );
+
   return linter.getConfigForFile(filepath).then(result => {
     expect(result).toEqual({
       config: {

lib/__tests__/defaultSeverity.test.js

@@ -9,10 +9,12 @@ it("`defaultSeverity` option set to warning", () => {
       "block-no-empty": true
     }
   };
+
   return postcssPlugin
     .process("a {}", { from: undefined }, config)
     .then(result => {
       const warnings = result.warnings();
+
       expect(warnings).toHaveLength(1);
       expect(warnings[0].text.indexOf("block-no-empty")).not.toBe(-1);
       expect(warnings[0].severity).toBe("warning");

lib/__tests__/disableRanges.test.js

@@ -233,6 +233,7 @@ it("SCSS // line-disabling comment", () => {
   const scssSource = `a {
     color: pink !important; // stylelint-disable-line declaration-no-important
   }`;
+
   return postcss()
     .use(assignDisabledRanges)
     .process(scssSource, { syntax: scss, from: undefined })
@@ -253,6 +254,7 @@ it("Less // line-disabling comment", () => {
   const lessSource = `a {
     color: pink !important; // stylelint-disable-line declaration-no-important
   }`;
+
   return postcss()
     .use(assignDisabledRanges)
     .process(lessSource, { syntax: less, from: undefined })

lib/__tests__/fixtures/plugin-conditionally-check-color-hex-case.js

@@ -14,8 +14,10 @@ module.exports = stylelint.createPlugin(ruleName, function(
     options,
     context
   );
+
   return (root, result) => {
     if (root.toString().indexOf("@@check-color-hex-case") === -1) return;
+
     colorHexCaseRule(root, result);
   };
 });

lib/__tests__/fixtures/processor-fenced-blocks.js

@@ -7,10 +7,12 @@ module.exports = function() {
     arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
   const specialMessage = options.specialMessage || "was processed";
+
   return {
     code(input) {
       const blocks = execall(/```start([\s\S]+?)```end/g, input);
       const toLint = blocks.map(match => match.sub[0]).join("\n\n");
+
       return toLint;
     },
     result(stylelintResult) {

lib/__tests__/fixtures/processor-triple-question-marks.js

@@ -4,13 +4,16 @@ const execall = require("execall");
 
 module.exports = function() {
   let found = false;
+
   return {
     code(input) {
       const blocks = execall(/\?\?\?start([\s\S]+?)\?\?\?end/g, input);
       const toLint = blocks.map(match => match.sub[0]).join("\n\n");
+
       if (toLint.length > 0) {
         found = true;
       }
+
       return toLint;
     },
     result(stylelintResult) {

lib/__tests__/needlessDisables.test.js

@@ -35,6 +35,7 @@ it("needlessDisables simple case", () => {
     ignoreDisables: true
   }).then(linted => {
     const report = needlessDisables(linted.results);
+
     expect(report).toHaveLength(1);
     expect(report[0].ranges).toEqual([
       { start: 7, end: 9 },

lib/__tests__/normalizeRuleSettings.test.js

@@ -4,22 +4,24 @@ const normalizeRuleSettings = require("../normalizeRuleSettings");
 
 describe("rules whose primary option IS NOT an array", () => {
   it("solo null returns null", () => {
-    expect(normalizeRuleSettings(null, "foo")).toBe(null);
+    expect(normalizeRuleSettings(null, "foo")).toBeNull();
   });
 
   it("arrayed null returns null", () => {
-    expect(normalizeRuleSettings([null], "foo")).toBe(null);
+    expect(normalizeRuleSettings([null], "foo")).toBeNull();
   });
 
   it("solo number returns arrayed number", () => {
     const actual = normalizeRuleSettings(2, "foo");
     const expected = [2];
+
     expect(actual).toEqual(expected);
   });
 
   it("arrayed number returns arrayed number if rule is not special", () => {
     const actual = normalizeRuleSettings([2], "foo");
     const expected = [2];
+
     expect(actual).toEqual(expected);
   });
 
@@ -29,18 +31,21 @@ describe("rules whose primary option IS NOT an array", () => {
       "block-no-empty"
     );
     const expected = [2, { severity: "warning" }];
+
     expect(actual).toEqual(expected);
   });
 
   it("solo string returns arrayed string", () => {
     const actual = normalizeRuleSettings("always", "foo");
     const expected = ["always"];
+
     expect(actual).toEqual(expected);
   });
 
   it("arrayed string returns arrayed string", () => {
     const actual = normalizeRuleSettings(["always"], "foo");
     const expected = ["always"];
+
     expect(actual).toEqual(expected);
   });
 
@@ -50,18 +55,21 @@ describe("rules whose primary option IS NOT an array", () => {
       "foo"
     );
     const expected = ["always", { severity: "warning" }];
+
     expect(actual).toEqual(expected);
   });
 
   it("solo boolean returns arrayed boolean", () => {
     const actual = normalizeRuleSettings(true, "foo");
     const expected = [true];
+
     expect(actual).toEqual(expected);
   });
 
   it("arrayed boolean returns arrayed boolean if rule is not special", () => {
     const actual = normalizeRuleSettings([false], "foo");
     const expected = [false];
+
     expect(actual).toEqual(expected);
   });
 
@@ -71,17 +79,18 @@ describe("rules whose primary option IS NOT an array", () => {
       "block-no-empty"
     );
     const expected = [true, { severity: "warning" }];
+
     expect(actual).toEqual(expected);
   });
 });
 
 describe("rules whose primary option CAN BE an array", () => {
   it("solo null returns null", () => {
-    expect(normalizeRuleSettings(null, "foo")).toBe(null);
+    expect(normalizeRuleSettings(null, "foo")).toBeNull();
   });
 
   it("arrayed null returns null", () => {
-    expect(normalizeRuleSettings([null], "foo")).toBe(null);
+    expect(normalizeRuleSettings([null], "foo")).toBeNull();
   });
 
   it("solo primary option array is nested within an array", () => {
@@ -91,6 +100,7 @@ describe("rules whose primary option CAN BE an array", () => {
       true
     );
     const expected = [["calc", "rgba"]];
+
     expect(actual).toEqual(expected);
   });
 
@@ -101,6 +111,7 @@ describe("rules whose primary option CAN BE an array", () => {
       true
     );
     const expected = [["calc", "rgba"]];
+
     expect(actual).toEqual(expected);
   });
 
@@ -111,6 +122,7 @@ describe("rules whose primary option CAN BE an array", () => {
       true
     );
     const expected = [["calc", "rgba"], { severity: "warning" }];
+
     expect(actual).toEqual(expected);
   });
 
@@ -120,6 +132,7 @@ describe("rules whose primary option CAN BE an array", () => {
       "rulename-bar"
     );
     const expected = ["alphabetical", { severity: "warning" }];
+
     expect(actual).toEqual(expected);
   });
 
@@ -130,6 +143,7 @@ describe("rules whose primary option CAN BE an array", () => {
       true
     );
     const expected = [[{ foo: 1 }, { foo: 2 }]];
+
     expect(actual).toEqual(expected);
   });
 
@@ -140,6 +154,7 @@ describe("rules whose primary option CAN BE an array", () => {
       true
     );
     const expected = [[{ foo: 1 }, { foo: 2 }], { severity: "warning" }];
+
     expect(actual).toEqual(expected);
   });
 });

lib/__tests__/plugins.test.js

@@ -260,6 +260,7 @@ it("plugin with primary option array", () => {
       "plugin/primary-array": ["foo", "bar"]
     }
   };
+
   return postcss()
     .use(stylelint(config))
     .process("a {}", { from: undefined })
@@ -275,6 +276,7 @@ it("plugin with primary option array within options array", () => {
       "plugin/primary-array": [["foo", "bar"], { something: true }]
     }
   };
+
   return postcss()
     .use(stylelint(config))
     .process("a {}", { from: undefined })
@@ -290,6 +292,7 @@ it("plugin with async rule", () => {
       "plugin/async": true
     }
   };
+
   return postcss()
     .use(stylelint(config))
     .process("a {}", { from: undefined })