eslint-plugin-jest-formatting 0.1.0 → 1.2.0

package/lib/index.js

@@ -1,44 +1,244 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("./utils");
+const padding_1 = require("./rules/padding");
+const paddingConfigs = {
+    afterAll: [
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 1,
+        },
+        {
+            paddingType: 1,
+            prevStatementType: 1,
+            nextStatementType: 0,
+        },
+    ],
+    afterEach: [
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 2,
+        },
+        {
+            paddingType: 1,
+            prevStatementType: 2,
+            nextStatementType: 0,
+        },
+    ],
+    beforeAll: [
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 3,
+        },
+        {
+            paddingType: 1,
+            prevStatementType: 3,
+            nextStatementType: 0,
+        },
+    ],
+    beforeEach: [
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 4,
+        },
+        {
+            paddingType: 1,
+            prevStatementType: 4,
+            nextStatementType: 0,
+        },
+    ],
+    describe: [
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: [
+                5,
+                7,
+                11,
+            ],
+        },
+        {
+            paddingType: 1,
+            prevStatementType: [
+                5,
+                7,
+                11,
+            ],
+            nextStatementType: 0,
+        },
+    ],
+    expect: [
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 6,
+        },
+        {
+            paddingType: 1,
+            prevStatementType: 6,
+            nextStatementType: 0,
+        },
+        {
+            paddingType: 0,
+            prevStatementType: 6,
+            nextStatementType: 6,
+        },
+    ],
+    test: [
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: [
+                10,
+                9,
+                8,
+                12,
+                13,
+            ],
+        },
+        {
+            paddingType: 1,
+            prevStatementType: [
+                10,
+                9,
+                8,
+                12,
+                13,
+            ],
+            nextStatementType: 0,
+        },
+    ],
+};
 exports.rules = {
-    'padding-before-after-all-blocks': utils_1.makeRule([
-        { blankLine: 'always', prev: '*', next: 'afterAll' },
-    ]),
-    'padding-before-after-each-blocks': utils_1.makeRule([
-        { blankLine: 'always', prev: '*', next: 'afterEach' },
-    ]),
-    'padding-before-before-all-blocks': utils_1.makeRule([
-        { blankLine: 'always', prev: '*', next: 'beforeAll' },
-    ]),
-    'padding-before-before-each-blocks': utils_1.makeRule([
-        { blankLine: 'always', prev: '*', next: 'beforeEach' },
-    ]),
-    'padding-before-describe-blocks': utils_1.makeRule([
-        { blankLine: 'always', prev: '*', next: 'describe' },
-    ]),
-    'padding-before-expect-statements': utils_1.makeRule([
-        { blankLine: 'always', prev: '*', next: 'expect' },
-        { blankLine: 'any', prev: 'expect', next: 'expect' },
-    ]),
-    'padding-before-test-blocks': utils_1.makeRule([
-        { blankLine: 'always', prev: '*', next: ['test', 'it'] },
-    ]),
-    'padding-before-all': utils_1.makeRule([
-        {
-            blankLine: 'always',
-            prev: '*',
-            next: [
-                'afterAll',
-                'afterEach',
-                'beforeAll',
-                'beforeEach',
-                'describe',
-                'expect',
-                'it',
-                'test',
+    'padding-around-after-all-blocks': padding_1.createRule(paddingConfigs.afterAll),
+    'padding-around-after-each-blocks': padding_1.createRule(paddingConfigs.afterEach),
+    'padding-around-before-all-blocks': padding_1.createRule(paddingConfigs.beforeAll),
+    'padding-around-before-each-blocks': padding_1.createRule(paddingConfigs.beforeEach),
+    'padding-around-describe-blocks': padding_1.createRule(paddingConfigs.describe),
+    'padding-around-expect-groups': padding_1.createRule(paddingConfigs.expect),
+    'padding-around-test-blocks': padding_1.createRule(paddingConfigs.test),
+    'padding-around-all': padding_1.createRule([].concat(...Object.keys(paddingConfigs).map(k => paddingConfigs[k]))),
+    'padding-before-after-all-blocks': padding_1.createRule([
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 1,
+        },
+    ], true),
+    'padding-before-after-each-blocks': padding_1.createRule([
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 2,
+        },
+    ], true),
+    'padding-before-before-all-blocks': padding_1.createRule([
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 3,
+        },
+    ], true),
+    'padding-before-before-each-blocks': padding_1.createRule([
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 4,
+        },
+    ], true),
+    'padding-before-describe-blocks': padding_1.createRule([
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 5,
+        },
+    ], true),
+    'padding-before-expect-statements': padding_1.createRule([
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: 6,
+        },
+        {
+            paddingType: 0,
+            prevStatementType: 6,
+            nextStatementType: 6,
+        },
+    ], true),
+    'padding-before-test-blocks': padding_1.createRule([
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: [10, 9],
+        },
+    ], true),
+    'padding-before-all': padding_1.createRule([
+        {
+            paddingType: 1,
+            prevStatementType: 0,
+            nextStatementType: [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                9,
+                10,
             ],
         },
-        { blankLine: 'any', prev: 'expect', next: 'expect' },
-    ]),
+        {
+            paddingType: 0,
+            prevStatementType: 6,
+            nextStatementType: 6,
+        },
+    ], true),
+};
+exports.configs = {
+    recommended: {
+        plugins: ['jest-formatting'],
+        overrides: [
+            {
+                files: [
+                    '**/*.test.*',
+                    '**/*_test.*',
+                    '**/*Test.*',
+                    '**/*.spec.*',
+                    '**/*_spec.*',
+                    '**/*Spec.*',
+                    '**/__tests__/*',
+                ],
+                rules: {
+                    'jest-formatting/padding-around-after-all-blocks': 2,
+                    'jest-formatting/padding-around-after-each-blocks': 2,
+                    'jest-formatting/padding-around-before-all-blocks': 2,
+                    'jest-formatting/padding-around-before-each-blocks': 2,
+                    'jest-formatting/padding-around-describe-blocks': 2,
+                    'jest-formatting/padding-around-test-blocks': 2,
+                },
+            },
+        ],
+    },
+    strict: {
+        plugins: ['jest-formatting'],
+        overrides: [
+            {
+                files: [
+                    '**/*.test.*',
+                    '**/*_test.*',
+                    '**/*Test.*',
+                    '**/*.spec.*',
+                    '**/*_spec.*',
+                    '**/*Spec.*',
+                    '**/__tests__/*',
+                ],
+                rules: {
+                    'jest-formatting/padding-around-all': 2,
+                },
+            },
+        ],
+    },
 };

package/lib/rules/padding.js

@@ -1,190 +1,162 @@
 "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);
-        },
+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,13 +1,15 @@
 {
   "name": "eslint-plugin-jest-formatting",
-  "version": "0.1.0",
+  "version": "1.2.0",
   "description": "Formatting rules for jest tests",
   "keywords": [
     "eslint",
     "eslintplugin",
     "eslint-plugin",
     "jest",
-    "format"
+    "format",
+    "formatting",
+    "padding"
   ],
   "author": "Dan Green-Leipciger",
   "repository": {