eslint-plugin-jest-formatting 1.0.0 → 2.0.0

package/lib/rules/padding.js

@@ -1,190 +1,163 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const STATEMENT_LIST_PARENTS = new Set([
-    'Program',
-    'BlockStatement',
-    'SwitchCase',
-    'SwitchStatement',
-]);
-const isTokenOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
-const isSemicolonToken = (token) => token.value === ';' && token.type === 'Punctuator';
-const isTestFile = (filename) => filename.includes('test') || filename.includes('spec');
-function newJestTokenTester(name) {
-    return {
-        test: (node, sourceCode) => {
-            const token = sourceCode.getFirstToken(node);
-            return (node.type === 'ExpressionStatement' &&
-                token.type === 'Identifier' &&
-                token.value === name);
-        },
+exports.createRule = exports.PaddingType = exports.StatementType = void 0;
+const astUtils = require("../ast-utils");
+var StatementType;
+(function (StatementType) {
+    StatementType[StatementType["Any"] = 0] = "Any";
+    StatementType[StatementType["AfterAllToken"] = 1] = "AfterAllToken";
+    StatementType[StatementType["AfterEachToken"] = 2] = "AfterEachToken";
+    StatementType[StatementType["BeforeAllToken"] = 3] = "BeforeAllToken";
+    StatementType[StatementType["BeforeEachToken"] = 4] = "BeforeEachToken";
+    StatementType[StatementType["DescribeToken"] = 5] = "DescribeToken";
+    StatementType[StatementType["ExpectToken"] = 6] = "ExpectToken";
+    StatementType[StatementType["FdescribeToken"] = 7] = "FdescribeToken";
+    StatementType[StatementType["FitToken"] = 8] = "FitToken";
+    StatementType[StatementType["ItToken"] = 9] = "ItToken";
+    StatementType[StatementType["TestToken"] = 10] = "TestToken";
+    StatementType[StatementType["XdescribeToken"] = 11] = "XdescribeToken";
+    StatementType[StatementType["XitToken"] = 12] = "XitToken";
+    StatementType[StatementType["XtestToken"] = 13] = "XtestToken";
+})(StatementType = exports.StatementType || (exports.StatementType = {}));
+var PaddingType;
+(function (PaddingType) {
+    PaddingType[PaddingType["Any"] = 0] = "Any";
+    PaddingType[PaddingType["Always"] = 1] = "Always";
+})(PaddingType = exports.PaddingType || (exports.PaddingType = {}));
+const createTokenTester = (tokenName) => {
+    return (node, sourceCode) => {
+        const token = sourceCode.getFirstToken(node);
+        return (node.type === 'ExpressionStatement' &&
+            token.type === 'Identifier' &&
+            token.value === tokenName);
     };
-}
-function getActualLastToken(sourceCode, node) {
-    const semiToken = sourceCode.getLastToken(node);
-    const prevToken = sourceCode.getTokenBefore(semiToken);
-    const nextToken = sourceCode.getTokenAfter(semiToken);
-    const isSemicolonLessStyle = Boolean(prevToken &&
-        nextToken &&
-        prevToken.range[0] >= node.range[0] &&
-        isSemicolonToken(semiToken) &&
-        semiToken.loc.start.line !== prevToken.loc.end.line &&
-        semiToken.loc.end.line === nextToken.loc.start.line);
-    return isSemicolonLessStyle ? prevToken : semiToken;
-}
-function verifyForAlways(context, prevNode, nextNode, paddingLines) {
+};
+const statementTesters = {
+    [0]: () => true,
+    [1]: createTokenTester('afterAll'),
+    [2]: createTokenTester('afterEach'),
+    [3]: createTokenTester('beforeAll'),
+    [4]: createTokenTester('beforeEach'),
+    [5]: createTokenTester('describe'),
+    [6]: createTokenTester('expect'),
+    [7]: createTokenTester('fdescribe'),
+    [8]: createTokenTester('fit'),
+    [9]: createTokenTester('it'),
+    [10]: createTokenTester('test'),
+    [11]: createTokenTester('xdescribe'),
+    [12]: createTokenTester('xit'),
+    [13]: createTokenTester('xtest'),
+};
+const paddingAlwaysTester = (prevNode, nextNode, paddingContext) => {
+    const { sourceCode, ruleContext } = paddingContext;
+    const paddingLines = astUtils.getPaddingLineSequences(prevNode, nextNode, sourceCode);
     if (paddingLines.length > 0) {
         return;
     }
-    context.report({
+    ruleContext.report({
         node: nextNode,
         message: 'Expected blank line before this statement.',
         fix(fixer) {
-            const sourceCode = context.getSourceCode();
-            let prevToken = getActualLastToken(sourceCode, prevNode);
+            let prevToken = astUtils.getActualLastToken(sourceCode, prevNode);
             const nextToken = sourceCode.getFirstTokenBetween(prevToken, nextNode, {
                 includeComments: true,
                 filter(token) {
-                    if (isTokenOnSameLine(prevToken, token)) {
+                    if (astUtils.areTokensOnSameLine(prevToken, token)) {
                         prevToken = token;
                         return false;
                     }
                     return true;
                 },
             }) || nextNode;
-            const insertText = isTokenOnSameLine(prevToken, nextToken)
+            const insertText = astUtils.areTokensOnSameLine(prevToken, nextToken)
                 ? '\n\n'
                 : '\n';
             return fixer.insertTextAfter(prevToken, insertText);
         },
     });
-}
-const PaddingTypes = {
-    any: { verify: () => { } },
-    always: { verify: verifyForAlways },
 };
-const StatementTypes = {
-    '*': { test: () => true },
-    afterAll: newJestTokenTester('afterAll'),
-    afterEach: newJestTokenTester('afterEach'),
-    beforeAll: newJestTokenTester('beforeAll'),
-    beforeEach: newJestTokenTester('beforeEach'),
-    describe: newJestTokenTester('describe'),
-    expect: newJestTokenTester('expect'),
-    it: newJestTokenTester('it'),
-    test: newJestTokenTester('test'),
+const paddingTesters = {
+    [0]: () => true,
+    [1]: paddingAlwaysTester,
 };
-exports.default = {
-    meta: {
-        fixable: 'whitespace',
-        schema: {
-            definitions: {
-                paddingType: {
-                    enum: Object.keys(PaddingTypes),
-                },
-                statementType: {
-                    anyOf: [
-                        { enum: Object.keys(StatementTypes) },
-                        {
-                            type: 'array',
-                            items: { enum: Object.keys(StatementTypes) },
-                            minItems: 1,
-                            uniqueItems: true,
-                            additionalItems: false,
-                        },
-                    ],
-                },
+const createScopeInfo = () => {
+    return (() => {
+        let scope = null;
+        return {
+            get prevNode() {
+                return scope.prevNode;
             },
-            type: 'array',
-            items: {
-                type: 'object',
-                properties: {
-                    blankLine: { $ref: '#/definitions/paddingType' },
-                    prev: { $ref: '#/definitions/statementType' },
-                    next: { $ref: '#/definitions/statementType' },
-                },
-                additionalProperties: false,
-                required: ['blankLine', 'prev', 'next'],
+            set prevNode(node) {
+                scope.prevNode = node;
             },
-            additionalItems: false,
-        },
+            enter() {
+                scope = { upper: scope, prevNode: null };
+            },
+            exit() {
+                scope = scope.upper;
+            },
+        };
+    })();
+};
+const nodeMatchesType = (node, statementType, paddingContext) => {
+    let innerStatementNode = node;
+    const { sourceCode } = paddingContext;
+    while (innerStatementNode.type === 'LabeledStatement') {
+        innerStatementNode = innerStatementNode.body;
+    }
+    if (Array.isArray(statementType)) {
+        return statementType.some((type) => nodeMatchesType(innerStatementNode, type, paddingContext));
+    }
+    return statementTesters[statementType](innerStatementNode, sourceCode);
+};
+const testPadding = (prevNode, nextNode, paddingContext) => {
+    const { configs } = paddingContext;
+    const testType = (type) => paddingTesters[type](prevNode, nextNode, paddingContext);
+    for (let i = configs.length - 1; i >= 0; --i) {
+        const { prevStatementType: prevType, nextStatementType: nextType, paddingType, } = configs[i];
+        if (nodeMatchesType(prevNode, prevType, paddingContext) &&
+            nodeMatchesType(nextNode, nextType, paddingContext)) {
+            return testType(paddingType);
+        }
+    }
+    return testType(0);
+};
+const verifyNode = (node, paddingContext) => {
+    const { scopeInfo } = paddingContext;
+    if (!astUtils.isValidParent(node.parent.type)) {
+        return;
+    }
+    if (scopeInfo.prevNode) {
+        testPadding(scopeInfo.prevNode, node, paddingContext);
+    }
+    scopeInfo.prevNode = node;
+};
+exports.createRule = (configs, deprecated = false) => ({
+    meta: {
+        fixable: 'whitespace',
+        deprecated,
     },
     create(context) {
-        const filename = context.getFilename();
-        if (!isTestFile(filename)) {
-            return {};
-        }
-        const sourceCode = context.getSourceCode();
-        const configureList = context.options || [];
-        let scopeInfo = null;
-        function enterScope() {
-            scopeInfo = { upper: scopeInfo, prevNode: null };
-        }
-        function exitScope() {
-            scopeInfo = scopeInfo.upper;
-        }
-        function match(node, type) {
-            let innerStatementNode = node;
-            while (innerStatementNode.type === 'LabeledStatement') {
-                innerStatementNode = innerStatementNode.body;
-            }
-            if (Array.isArray(type)) {
-                return type.some(match.bind(null, innerStatementNode));
-            }
-            return StatementTypes[type].test(innerStatementNode, sourceCode);
-        }
-        function getPaddingType(prevNode, nextNode) {
-            for (let i = configureList.length - 1; i >= 0; --i) {
-                const { prev, next, blankLine } = configureList[i];
-                if (match(prevNode, prev) && match(nextNode, next)) {
-                    return PaddingTypes[blankLine];
-                }
-            }
-            return PaddingTypes.any;
-        }
-        function getPaddingLineSequences(prevNode, nextNode) {
-            const pairs = [];
-            let prevToken = getActualLastToken(sourceCode, prevNode);
-            if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
-                do {
-                    const token = sourceCode.getTokenAfter(prevToken, {
-                        includeComments: true,
-                    });
-                    if (token.loc.start.line - prevToken.loc.end.line >= 2) {
-                        pairs.push([prevToken, token]);
-                    }
-                    prevToken = token;
-                } while (prevToken.range[0] < nextNode.range[0]);
-            }
-            return pairs;
-        }
-        function verify(node) {
-            const parentType = node.parent.type;
-            const validParent = STATEMENT_LIST_PARENTS.has(parentType);
-            if (!validParent) {
-                return;
-            }
-            const { prevNode } = scopeInfo;
-            if (prevNode) {
-                const type = getPaddingType(prevNode, node);
-                const paddingLines = getPaddingLineSequences(prevNode, node);
-                type.verify(context, prevNode, node, paddingLines);
-            }
-            scopeInfo.prevNode = node;
-        }
-        function verifyThenEnterScope(node) {
-            verify(node);
-            enterScope();
-        }
+        const paddingContext = {
+            ruleContext: context,
+            sourceCode: context.getSourceCode(),
+            scopeInfo: createScopeInfo(),
+            configs,
+        };
+        const { scopeInfo } = paddingContext;
         return {
-            Program: enterScope,
-            BlockStatement: enterScope,
-            SwitchStatement: enterScope,
-            'Program:exit': exitScope,
-            'BlockStatement:exit': exitScope,
-            'SwitchStatement:exit': exitScope,
-            ':statement': verify,
-            SwitchCase: verifyThenEnterScope,
-            'SwitchCase:exit': exitScope,
+            Program: scopeInfo.enter,
+            'Program:exit': scopeInfo.enter,
+            BlockStatement: scopeInfo.enter,
+            'BlockStatement:exit': scopeInfo.exit,
+            SwitchStatement: scopeInfo.enter,
+            'SwitchStatement:exit': scopeInfo.exit,
+            ':statement': (node) => verifyNode(node, paddingContext),
+            SwitchCase: (node) => {
+                verifyNode(node, paddingContext);
+                scopeInfo.enter();
+            },
+            'SwitchCase:exit': scopeInfo.exit,
         };
     },
-};
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest-formatting",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Formatting rules for jest tests",
   "keywords": [
     "eslint",
@@ -20,8 +20,8 @@
   "module": "src/index.ts",
   "scripts": {
     "pretty": "yarn prettier '**/*.*'",
-    "lint": "yarn build && yarn link-plugin && yarn pretty --check && yarn eslint .",
-    "format": "yarn build && yarn link-plugin && yarn pretty --write && yarn eslint --fix .",
+    "lint": "yarn build && yarn link-plugin && yarn pretty --check && yarn eslint --ext .ts,.js .",
+    "format": "yarn build && yarn link-plugin && yarn pretty --write && yarn eslint --fix --ext .ts,.js .",
     "build": "tsc",
     "test": "yarn build && jest",
     "link-plugin": "yarn link && yarn link eslint-plugin-jest-formatting"
@@ -30,25 +30,26 @@
     "eslint": ">=0.8.0"
   },
   "devDependencies": {
-    "@types/eslint": "4.16.6",
-    "@types/estree": "0.0.39",
-    "@types/jest": "24.0.11",
-    "@types/node": "8.10.0",
-    "@typescript-eslint/parser": "1.10.2",
-    "eslint": "5.16.0",
-    "eslint-config-airbnb-base": "13.1.0",
-    "eslint-config-prettier": "5.0.0",
-    "eslint-plugin-import": "2.14.0",
-    "eslint-plugin-jest": "22.7.0",
+    "@types/eslint": "^7.2.0",
+    "@types/jest": "^26.0.0",
+    "@types/node": "^14.0.13",
+    "@typescript-eslint/eslint-plugin": "^3.4.0",
+    "@typescript-eslint/parser": "^3.4.0",
+    "eslint": "^7.3.1",
+    "eslint-config-airbnb-base": "^14.2.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-import-resolver-typescript": "^2.0.0",
+    "eslint-plugin-import": "^2.21.2",
+    "eslint-plugin-jest": "^23.17.1",
     "eslint-plugin-jest-formatting": "file:.",
-    "eslint-plugin-prettier": "3.1.0",
-    "jest": "24.8.0",
-    "prettier": "1.18.2",
-    "typescript": "3.4.1",
-    "ts-jest": "24.0.2"
+    "eslint-plugin-prettier": "^3.1.4",
+    "jest": "^26.1.0",
+    "prettier": "2.0.5",
+    "typescript": "^3.9.5",
+    "ts-jest": "^26.1.1"
   },
   "engines": {
-    "node": ">=8.10.0"
+    "node": "^10.12.0 || >=12.0.0"
   },
   "license": "MIT"
 }

package/src/ast-utils.ts

@@ -0,0 +1,80 @@
+import { AST, SourceCode } from 'eslint';
+// This is because we are using @types/estree that are brought in with eslint
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Node } from 'estree';
+
+export const isTokenASemicolon = (token: AST.Token): boolean =>
+  token.value === ';' && token.type === 'Punctuator';
+
+export const areTokensOnSameLine = (
+  left: Node | AST.Token,
+  right: Node | AST.Token,
+): boolean => left.loc.end.line === right.loc.start.line;
+
+// We'll only verify nodes with these parent types
+const STATEMENT_LIST_PARENTS = new Set([
+  'Program',
+  'BlockStatement',
+  'SwitchCase',
+  'SwitchStatement',
+]);
+
+export const isValidParent = (parentType: string): boolean => {
+  return STATEMENT_LIST_PARENTS.has(parentType);
+};
+
+/**
+ * Gets the actual last token.
+ *
+ * If a semicolon is semicolon-less style's semicolon, this ignores it.
+ * For example:
+ *
+ *     foo()
+ *     ;[1, 2, 3].forEach(bar)
+ */
+export const getActualLastToken = (
+  sourceCode: SourceCode,
+  node: Node,
+): AST.Token => {
+  const semiToken = sourceCode.getLastToken(node);
+  const prevToken = sourceCode.getTokenBefore(semiToken);
+  const nextToken = sourceCode.getTokenAfter(semiToken);
+  const isSemicolonLessStyle = Boolean(
+    prevToken &&
+      nextToken &&
+      prevToken.range[0] >= node.range[0] &&
+      isTokenASemicolon(semiToken) &&
+      semiToken.loc.start.line !== prevToken.loc.end.line &&
+      semiToken.loc.end.line === nextToken.loc.start.line,
+  );
+
+  return isSemicolonLessStyle ? prevToken : semiToken;
+};
+
+/**
+ * Gets padding line sequences between the given 2 statements.
+ * Comments are separators of the padding line sequences.
+ */
+export const getPaddingLineSequences = (
+  prevNode: Node,
+  nextNode: Node,
+  sourceCode: SourceCode,
+): AST.Token[][] => {
+  const pairs: AST.Token[][] = [];
+  const includeComments = true;
+  let prevToken = getActualLastToken(sourceCode, prevNode);
+
+  if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
+    do {
+      const token = sourceCode.getTokenAfter(prevToken, { includeComments });
+
+      if (token.loc.start.line - prevToken.loc.end.line >= 2) {
+        pairs.push([prevToken, token]);
+      }
+
+      prevToken = token;
+    } while (prevToken.range[0] < nextNode.range[0]);
+  }
+
+  return pairs;
+};