eslint-plugin-jest-formatting 0.1.0 → 1.2.0

package/src/ast-utils.ts

@@ -0,0 +1,78 @@
+import { AST, SourceCode } from 'eslint';
+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;
+};

package/src/index.ts

@@ -3,50 +3,289 @@
  * @author Dan
  */
 
-import { makeRule } from './utils';
+import {
+  Config,
+  createRule,
+  PaddingType,
+  StatementType,
+} from './rules/padding';
 
-//------------------------------------------------------------------------------
-// Plugin Definition
-//------------------------------------------------------------------------------
-
-export const rules = {
-  'padding-before-after-all-blocks': makeRule([
-    { blankLine: 'always', prev: '*', next: 'afterAll' },
-  ]),
-  'padding-before-after-each-blocks': makeRule([
-    { blankLine: 'always', prev: '*', next: 'afterEach' },
-  ]),
-  'padding-before-before-all-blocks': makeRule([
-    { blankLine: 'always', prev: '*', next: 'beforeAll' },
-  ]),
-  'padding-before-before-each-blocks': makeRule([
-    { blankLine: 'always', prev: '*', next: 'beforeEach' },
-  ]),
-  'padding-before-describe-blocks': makeRule([
-    { blankLine: 'always', prev: '*', next: 'describe' },
-  ]),
-  'padding-before-expect-statements': makeRule([
-    { blankLine: 'always', prev: '*', next: 'expect' },
-    { blankLine: 'any', prev: 'expect', next: 'expect' },
-  ]),
-  'padding-before-test-blocks': makeRule([
-    { blankLine: 'always', prev: '*', next: ['test', 'it'] },
-  ]),
-  'padding-before-all': makeRule([
-    {
-      blankLine: 'always',
-      prev: '*',
-      next: [
-        'afterAll',
-        'afterEach',
-        'beforeAll',
-        'beforeEach',
-        'describe',
-        'expect',
-        'it',
-        'test',
+const paddingConfigs: { [name: string]: Config[] } = {
+  afterAll: [
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.Any,
+      nextStatementType: StatementType.AfterAllToken,
+    },
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.AfterAllToken,
+      nextStatementType: StatementType.Any,
+    },
+  ],
+  afterEach: [
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.Any,
+      nextStatementType: StatementType.AfterEachToken,
+    },
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.AfterEachToken,
+      nextStatementType: StatementType.Any,
+    },
+  ],
+  beforeAll: [
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.Any,
+      nextStatementType: StatementType.BeforeAllToken,
+    },
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.BeforeAllToken,
+      nextStatementType: StatementType.Any,
+    },
+  ],
+  beforeEach: [
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.Any,
+      nextStatementType: StatementType.BeforeEachToken,
+    },
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.BeforeEachToken,
+      nextStatementType: StatementType.Any,
+    },
+  ],
+  describe: [
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.Any,
+      nextStatementType: [
+        StatementType.DescribeToken,
+        StatementType.FdescribeToken,
+        StatementType.XdescribeToken,
+      ],
+    },
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: [
+        StatementType.DescribeToken,
+        StatementType.FdescribeToken,
+        StatementType.XdescribeToken,
+      ],
+      nextStatementType: StatementType.Any,
+    },
+  ],
+  expect: [
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.Any,
+      nextStatementType: StatementType.ExpectToken,
+    },
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.ExpectToken,
+      nextStatementType: StatementType.Any,
+    },
+    {
+      paddingType: PaddingType.Any,
+      prevStatementType: StatementType.ExpectToken,
+      nextStatementType: StatementType.ExpectToken,
+    },
+  ],
+  test: [
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: StatementType.Any,
+      nextStatementType: [
+        StatementType.TestToken,
+        StatementType.ItToken,
+        StatementType.FitToken,
+        StatementType.XitToken,
+        StatementType.XtestToken,
       ],
     },
-    { blankLine: 'any', prev: 'expect', next: 'expect' },
-  ]),
+    {
+      paddingType: PaddingType.Always,
+      prevStatementType: [
+        StatementType.TestToken,
+        StatementType.ItToken,
+        StatementType.FitToken,
+        StatementType.XitToken,
+        StatementType.XtestToken,
+      ],
+      nextStatementType: StatementType.Any,
+    },
+  ],
+};
+
+export const rules = {
+  'padding-around-after-all-blocks': createRule(paddingConfigs.afterAll),
+  'padding-around-after-each-blocks': createRule(paddingConfigs.afterEach),
+  'padding-around-before-all-blocks': createRule(paddingConfigs.beforeAll),
+  'padding-around-before-each-blocks': createRule(paddingConfigs.beforeEach),
+  'padding-around-describe-blocks': createRule(paddingConfigs.describe),
+  'padding-around-expect-groups': createRule(paddingConfigs.expect),
+  'padding-around-test-blocks': createRule(paddingConfigs.test),
+  'padding-around-all': createRule(
+    [].concat(...Object.keys(paddingConfigs).map(k => paddingConfigs[k])),
+  ),
+
+  // ===========================================================================
+  // DEPRECATED
+  'padding-before-after-all-blocks': createRule(
+    [
+      {
+        paddingType: PaddingType.Always,
+        prevStatementType: StatementType.Any,
+        nextStatementType: StatementType.AfterAllToken,
+      },
+    ],
+    true,
+  ),
+  // DEPRECATED
+  'padding-before-after-each-blocks': createRule(
+    [
+      {
+        paddingType: PaddingType.Always,
+        prevStatementType: StatementType.Any,
+        nextStatementType: StatementType.AfterEachToken,
+      },
+    ],
+    true,
+  ),
+  // DEPRECATED
+  'padding-before-before-all-blocks': createRule(
+    [
+      {
+        paddingType: PaddingType.Always,
+        prevStatementType: StatementType.Any,
+        nextStatementType: StatementType.BeforeAllToken,
+      },
+    ],
+    true,
+  ),
+  // DEPRECATED
+  'padding-before-before-each-blocks': createRule(
+    [
+      {
+        paddingType: PaddingType.Always,
+        prevStatementType: StatementType.Any,
+        nextStatementType: StatementType.BeforeEachToken,
+      },
+    ],
+    true,
+  ),
+  // DEPRECATED
+  'padding-before-describe-blocks': createRule(
+    [
+      {
+        paddingType: PaddingType.Always,
+        prevStatementType: StatementType.Any,
+        nextStatementType: StatementType.DescribeToken,
+      },
+    ],
+    true,
+  ),
+  // DEPRECATED
+  'padding-before-expect-statements': createRule(
+    [
+      {
+        paddingType: PaddingType.Always,
+        prevStatementType: StatementType.Any,
+        nextStatementType: StatementType.ExpectToken,
+      },
+      {
+        paddingType: PaddingType.Any,
+        prevStatementType: StatementType.ExpectToken,
+        nextStatementType: StatementType.ExpectToken,
+      },
+    ],
+    true,
+  ),
+  // DEPRECATED
+  'padding-before-test-blocks': createRule(
+    [
+      {
+        paddingType: PaddingType.Always,
+        prevStatementType: StatementType.Any,
+        nextStatementType: [StatementType.TestToken, StatementType.ItToken],
+      },
+    ],
+    true,
+  ),
+  // DEPRECATED
+  'padding-before-all': createRule(
+    [
+      {
+        paddingType: PaddingType.Always,
+        prevStatementType: StatementType.Any,
+        nextStatementType: [
+          StatementType.AfterAllToken,
+          StatementType.AfterEachToken,
+          StatementType.BeforeAllToken,
+          StatementType.BeforeEachToken,
+          StatementType.DescribeToken,
+          StatementType.ExpectToken,
+          StatementType.ItToken,
+          StatementType.TestToken,
+        ],
+      },
+      {
+        paddingType: PaddingType.Any,
+        prevStatementType: StatementType.ExpectToken,
+        nextStatementType: StatementType.ExpectToken,
+      },
+    ],
+    true,
+  ),
+};
+
+export const 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,
+        },
+      },
+    ],
+  },
 };