Merge pull request #31 from buildo/create-rule

Use createRule utility for all rules

Author: gabro

src/index.ts

@@ -2,15 +2,15 @@ import { array, record, semigroup } from "fp-ts";
 import { pipe } from "fp-ts/function";
 
 const potentialErrors = {
-  "no-lib-imports": require("./rules/no-lib-imports"),
-  "no-pipeable": require("./rules/no-pipeable"),
+  "no-lib-imports": require("./rules/no-lib-imports").default,
+  "no-pipeable": require("./rules/no-pipeable").default,
   "no-module-imports": require("./rules/no-module-imports").default,
 };
 
 const suggestions = {
-  "prefer-traverse": require("./rules/prefer-traverse"),
-  "no-redundant-flow": require("./rules/no-redundant-flow"),
-  "prefer-chain": require("./rules/prefer-chain"),
+  "prefer-traverse": require("./rules/prefer-traverse").default,
+  "no-redundant-flow": require("./rules/no-redundant-flow").default,
+  "prefer-chain": require("./rules/prefer-chain").default,
 };
 
 export const rules = {

src/rules/no-lib-imports.ts

@@ -1,46 +1,49 @@
-import { TSESLint } from "@typescript-eslint/experimental-utils";
+import { createRule } from "../utils";
 
-const messages = {
-  importNotAllowed:
-    "Importing from {{ detected }} is not allowed, import from {{ fixed }} instead",
-} as const;
-type MessageIds = keyof typeof messages;
-
-export const meta: TSESLint.RuleMetaData<MessageIds> = {
-  type: "problem",
-  fixable: "code",
-  schema: [],
-  messages,
-};
-
-export function create(
-  context: TSESLint.RuleContext<MessageIds, []>
-): TSESLint.RuleListener {
-  return {
-    ImportDeclaration(node) {
-      const sourceValue = node.source.value?.toString();
-      if (sourceValue) {
-        const forbiddenImportPattern = /^fp-ts\/lib\//;
+export default createRule({
+  name: "no-lib-imports",
+  meta: {
+    type: "problem",
+    fixable: "code",
+    docs: {
+      category: "Possible Errors",
+      description: "Disallow imports from 'fp-ts/lib'",
+      recommended: "error",
+    },
+    schema: [],
+    messages: {
+      importNotAllowed:
+        "Importing from {{ detected }} is not allowed, import from {{ fixed }} instead",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const sourceValue = node.source.value?.toString();
+        if (sourceValue) {
+          const forbiddenImportPattern = /^fp-ts\/lib\//;
 
-        const fixedImportSource = sourceValue.replace(
-          forbiddenImportPattern,
-          "fp-ts/"
-        );
+          const fixedImportSource = sourceValue.replace(
+            forbiddenImportPattern,
+            "fp-ts/"
+          );
 
-        if (sourceValue.match(forbiddenImportPattern)) {
-          context.report({
-            node: node.source,
-            messageId: "importNotAllowed",
-            data: {
-              detected: node.source.value,
-              fixed: fixedImportSource,
-            },
-            fix(fixer) {
-              return fixer.replaceText(node.source, `"${fixedImportSource}"`);
-            },
-          });
+          if (sourceValue.match(forbiddenImportPattern)) {
+            context.report({
+              node: node.source,
+              messageId: "importNotAllowed",
+              data: {
+                detected: node.source.value,
+                fixed: fixedImportSource,
+              },
+              fix(fixer) {
+                return fixer.replaceText(node.source, `"${fixedImportSource}"`);
+              },
+            });
+          }
         }
-      }
-    },
-  };
-}
+      },
+    };
+  },
+});

src/rules/no-pipeable.ts

@@ -1,56 +1,56 @@
-import {
-  ASTUtils,
-  TSESLint,
-  TSESTree,
-} from "@typescript-eslint/experimental-utils";
+import { ASTUtils, TSESTree } from "@typescript-eslint/experimental-utils";
+import { createRule } from "../utils";
 
-const messages = {
-  importPipeFromFunction:
-    "The 'pipeable' module is deprecated. Import 'pipe' from the 'function' module instead",
-  pipeableIsDeprecated:
-    "The 'pipeable' module is deprecated and will be removed in future versions of fp-ts",
-} as const;
-type MessageIds = keyof typeof messages;
-
-export const meta: TSESLint.RuleMetaData<MessageIds> = {
-  type: "problem",
-  fixable: "code",
-  schema: [],
-  messages,
-};
-
-export function create(
-  context: TSESLint.RuleContext<MessageIds, []>
-): TSESLint.RuleListener {
-  return {
-    ImportDeclaration(node) {
-      const sourceValue = ASTUtils.getStringIfConstant(node.source);
-      if (sourceValue) {
-        const pipeableSourcePattern = /^fp-ts\/(lib\/)?pipeable/;
+export default createRule({
+  name: "no-pipeable",
+  meta: {
+    type: "problem",
+    fixable: "code",
+    schema: [],
+    docs: {
+      category: "Possible Errors",
+      description: "Disallow imports from the 'pipeable' module",
+      recommended: "error",
+    },
+    messages: {
+      importPipeFromFunction:
+        "The 'pipeable' module is deprecated. Import 'pipe' from the 'function' module instead",
+      pipeableIsDeprecated:
+        "The 'pipeable' module is deprecated and will be removed in future versions of fp-ts",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const sourceValue = ASTUtils.getStringIfConstant(node.source);
+        if (sourceValue) {
+          const pipeableSourcePattern = /^fp-ts\/(lib\/)?pipeable/;
 
-        if (sourceValue.match(pipeableSourcePattern)) {
-          if (
-            node.specifiers.find(
-              (importClause) =>
-                (importClause as TSESTree.ImportSpecifier).imported?.name ===
-                "pipe"
-            )
-          ) {
-            context.report({
-              node: node.source,
-              messageId: "importPipeFromFunction",
-              fix(fixer) {
-                return fixer.replaceText(node.source, `"fp-ts/function"`);
-              },
-            });
-          } else {
-            context.report({
-              node: node.source,
-              messageId: "pipeableIsDeprecated",
-            });
+          if (sourceValue.match(pipeableSourcePattern)) {
+            if (
+              node.specifiers.find(
+                (importClause) =>
+                  (importClause as TSESTree.ImportSpecifier).imported?.name ===
+                  "pipe"
+              )
+            ) {
+              context.report({
+                node: node.source,
+                messageId: "importPipeFromFunction",
+                fix(fixer) {
+                  return fixer.replaceText(node.source, `"fp-ts/function"`);
+                },
+              });
+            } else {
+              context.report({
+                node: node.source,
+                messageId: "pipeableIsDeprecated",
+              });
+            }
           }
         }
-      }
-    },
-  };
-}
+      },
+    };
+  },
+});

src/rules/no-redundant-flow.ts

@@ -1,46 +1,48 @@
-import { TSESLint } from "@typescript-eslint/experimental-utils";
-import { contextUtils } from "../utils";
+import { contextUtils, createRule } from "../utils";
 
-const messages = {
-  redundantFlow: "flow can be removed because it takes only one argument",
-  removeFlow: "remove flow",
-} as const;
-type MessageIds = keyof typeof messages;
-
-export const meta: TSESLint.RuleMetaData<MessageIds> = {
-  type: "suggestion",
-  fixable: "code",
-  schema: [],
-  messages,
-};
-
-export function create(
-  context: TSESLint.RuleContext<MessageIds, []>
-): TSESLint.RuleListener {
-  const { isFlowExpression } = contextUtils(context);
+export default createRule({
+  name: "no-redundant-flow",
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    schema: [],
+    docs: {
+      category: "Best Practices",
+      description: "Remove redundant uses of flow",
+      recommended: "warn",
+    },
+    messages: {
+      redundantFlow: "flow can be removed because it takes only one argument",
+      removeFlow: "remove flow",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const { isFlowExpression } = contextUtils(context);
 
-  return {
-    CallExpression(node) {
-      if (node.arguments.length === 1 && isFlowExpression(node)) {
-        context.report({
-          node,
-          messageId: "redundantFlow",
-          suggest: [
-            {
-              messageId: "removeFlow",
-              fix(fixer) {
-                return [
-                  fixer.removeRange([
-                    node.callee.range[0],
-                    node.callee.range[1] + 1,
-                  ]),
-                  fixer.removeRange([node.range[1] - 1, node.range[1]]),
-                ];
+    return {
+      CallExpression(node) {
+        if (node.arguments.length === 1 && isFlowExpression(node)) {
+          context.report({
+            node,
+            messageId: "redundantFlow",
+            suggest: [
+              {
+                messageId: "removeFlow",
+                fix(fixer) {
+                  return [
+                    fixer.removeRange([
+                      node.callee.range[0],
+                      node.callee.range[1] + 1,
+                    ]),
+                    fixer.removeRange([node.range[1] - 1, node.range[1]]),
+                  ];
+                },
               },
-            },
-          ],
-        });
-      }
-    },
-  };
-}
+            ],
+          });
+        }
+      },
+    };
+  },
+});