@monorepolint/rules 0.5.0-alpha.103 → 0.5.0-alpha.106

package/src/__tests__/alphabeticalScripts.spec.ts

@@ -49,7 +49,7 @@ describe.each(HOST_FACTORIES)("alphabeticalScripts ($name)", (hostFactory) => {
     it("fixes unsorted scripts", () => {
       workspace.writeFile("package.json", PACKAGE_SCRIPTS_UNSORTED);
 
-      alphabeticalScripts.check(context, undefined);
+      alphabeticalScripts({}).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -68,7 +68,7 @@ describe.each(HOST_FACTORIES)("alphabeticalScripts ($name)", (hostFactory) => {
     it("does nothing if already sorted", () => {
       workspace.writeFile("package.json", PACKAGE_SCRIPTS_SORTED);
 
-      alphabeticalScripts.check(context, undefined);
+      alphabeticalScripts({}).check(context);
 
       expect(spy).toHaveBeenCalledTimes(0);
     });

package/src/__tests__/bannedDependencies.spec.ts

@@ -51,9 +51,7 @@ describe("bannedDependencies", () => {
 
     function checkAndSpy(options: Options) {
       const addErrorSpy = jest.spyOn(workspaceContext, "addError");
-      bannedDependencies.check(workspaceContext, {
-        ...options,
-      });
+      bannedDependencies({ options }).check(workspaceContext);
       return { addErrorSpy };
     }
 

package/src/__tests__/consistentDependencies.spec.ts

@@ -77,7 +77,7 @@ describe("consistentDependencies", () => {
     function checkAndSpy(q: string, opts?: Options) {
       const context = workspaceContext.createChildContext(path.resolve(dir.name, q));
       const addErrorSpy = jest.spyOn(context, "addError");
-      consistentDependencies.check(context, opts);
+      consistentDependencies({ options: opts }).check(context);
       return { context, addErrorSpy };
     }
 
@@ -104,7 +104,7 @@ describe("consistentDependencies", () => {
     addFile("./packages/right/package.json", PACKAGE_CHILD_WITH_RIGHT_VERSION);
     addFile("./packages/wrong/package.json", PACKAGE_CHILD_WITH_WRONG_VERSION);
 
-    consistentDependencies.check(workspaceContext, undefined);
+    consistentDependencies({}).check(workspaceContext);
 
     const star = checkAndSpy("./packages/star");
     expect(star.addErrorSpy).toHaveBeenCalledTimes(0);

package/src/__tests__/consistentVersions.spec.ts

@@ -50,7 +50,7 @@ describe("consistentVersions", () => {
     const addErrorSpy = jest.spyOn(workspaceContext, "addError");
 
     function check(options: Options = { matchDependencyVersions: {} }) {
-      consistentVersions.check(workspaceContext, options);
+      consistentVersions({ options }).check(workspaceContext);
     }
 
     return { addErrorSpy, check, host };

package/src/__tests__/fileContents.spec.ts

@@ -29,12 +29,14 @@ describe.each(HOST_FACTORIES)("fileContents ($name)", (hostFactory) => {
     });
 
     it("fixes missing file", () => {
-      fileContents.check(workspace.context, {
-        file: "foo.txt",
-        templateFile: "shared/foo-template.txt",
-        generator: undefined,
-        template: undefined,
-      });
+      fileContents({
+        options: {
+          file: "foo.txt",
+          templateFile: "shared/foo-template.txt",
+          generator: undefined,
+          template: undefined,
+        },
+      }).check(workspace.context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -51,12 +53,14 @@ describe.each(HOST_FACTORIES)("fileContents ($name)", (hostFactory) => {
     });
 
     it("fixes missing nested file", () => {
-      fileContents.check(workspace.context, {
-        file: "nested/foo.txt",
-        templateFile: "shared/foo-template.txt",
-        generator: undefined,
-        template: undefined,
-      });
+      fileContents({
+        options: {
+          file: "nested/foo.txt",
+          templateFile: "shared/foo-template.txt",
+          generator: undefined,
+          template: undefined,
+        },
+      }).check(workspace.context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 

package/src/__tests__/mustSatisfyPeerDependencies.spec.ts

@@ -80,7 +80,7 @@ describe("mustSatisfyPeerDependencies", () => {
     const addErrorSpy = jest.spyOn(workspaceContext, "addError");
 
     async function check(options: Options) {
-      await mustSatisfyPeerDependencies.check(workspaceContext, options);
+      await mustSatisfyPeerDependencies({ options }).check(workspaceContext);
     }
 
     return { addErrorSpy, check, host };

package/src/__tests__/nestedWorkspaces.spec.ts

@@ -72,7 +72,7 @@ describe("nestedWorkspaces", () => {
     async function checkAndSpy() {
       const addErrorSpy = jest.spyOn(workspaceContext, "addError");
 
-      await nestedWorkspaces.check(workspaceContext, undefined);
+      await nestedWorkspaces({}).check(workspaceContext);
       return { addErrorSpy };
     }
 

package/src/__tests__/packageEntry.spec.ts

@@ -76,12 +76,14 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("fixes missing entries", () => {
       workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
 
-      packageEntry.check(context, {
-        entries: {
-          license: "UNLICENSED",
+      packageEntry({
+        options: {
+          entries: {
+            license: "UNLICENSED",
+          },
+          entriesExist: undefined,
         },
-        entriesExist: undefined,
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -100,15 +102,17 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("fixes missing nested entries", () => {
       workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
 
-      packageEntry.check(context, {
-        entries: {
-          repository: {
-            type: "git",
-            url: "https://github.com:foo/foo",
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
           },
+          entriesExist: undefined,
         },
-        entriesExist: undefined,
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -127,15 +131,17 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("doesn't error for nested entries that are defined", () => {
       workspace.writeFile("package.json", PACKAGE_REPOSITORY);
 
-      packageEntry.check(context, {
-        entries: {
-          repository: {
-            type: "git",
-            url: "https://github.com:foo/foo",
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
           },
+          entriesExist: undefined,
         },
-        entriesExist: undefined,
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(0);
       expect(workspace.readFile("package.json")).toEqual(PACKAGE_REPOSITORY);
@@ -144,10 +150,12 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("errors for keys that are missing", () => {
       workspace.writeFile("package.json", PACKAGE_REPOSITORY);
 
-      packageEntry.check(context, {
-        entries: undefined,
-        entriesExist: ["bugs"],
-      });
+      packageEntry({
+        options: {
+          entries: undefined,
+          entriesExist: ["bugs"],
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -165,15 +173,17 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("handles both entries and entriesExist", () => {
       workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
 
-      packageEntry.check(context, {
-        entries: {
-          repository: {
-            type: "git",
-            url: "https://github.com:foo/foo",
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
           },
+          entriesExist: ["bugs"],
         },
-        entriesExist: ["bugs"],
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(2);
 

package/src/__tests__/packageOrder.spec.ts

@@ -101,9 +101,11 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
     it("fixes order for expected keys", () => {
       workspace.writeFile("package.json", PACKAGE_UNORDERED);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -122,9 +124,11 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
     it("fixes order for unexpected keys", () => {
       workspace.writeFile("package.json", PACKAGE_UNORDERED_UNKOWN_KEYS);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -143,9 +147,11 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
     it("fixes order using function", () => {
       workspace.writeFile("package.json", PACKAGE_UNORDERED);
 
-      packageOrder.check(context, {
-        order: orderFunction,
-      });
+      packageOrder({
+        options: {
+          order: orderFunction,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -164,9 +170,11 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
     it("does nothing if already order", () => {
       workspace.writeFile("package.json", PACKAGE_ORDERED_UNKOWN_KEYS);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).not.toHaveBeenCalled();
 

package/src/__tests__/packageScript.spec.ts

@@ -47,11 +47,13 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("handles an empty script section", () => {
       workspace.writeFile("package.json", PACKAGE_WITHOUT_SCRIPTS);
 
-      packageScript.check(workspace.context, {
-        scripts: {
-          foo: "bar",
+      packageScript({
+        options: {
+          scripts: {
+            foo: "bar",
+          },
         },
-      });
+      }).check(workspace.context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -84,11 +86,13 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("fixes an empty script section", () => {
       workspace.writeFile("package.json", PACKAGE_WITHOUT_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          foo: "bar",
+      packageScript({
+        options: {
+          scripts: {
+            foo: "bar",
+          },
         },
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -107,11 +111,13 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("adds a script", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          [MISSING_SCRIPT_NAME]: MISSING_SCRIPT_VALUE,
+      packageScript({
+        options: {
+          scripts: {
+            [MISSING_SCRIPT_NAME]: MISSING_SCRIPT_VALUE,
+          },
         },
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -134,11 +140,13 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("does nothing if the value exists", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          [SCRIPT_NAME]: SCRIPT_VALUE,
+      packageScript({
+        options: {
+          scripts: {
+            [SCRIPT_NAME]: SCRIPT_VALUE,
+          },
         },
-      });
+      }).check(context);
 
       expect(spy).not.toHaveBeenCalled();
 
@@ -150,13 +158,15 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("errors if long form is used and no value matches and there is no fixValue", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          foo: {
-            options: ["a", "b"],
+      packageScript({
+        options: {
+          scripts: {
+            foo: {
+              options: ["a", "b"],
+            },
           },
         },
-      });
+      }).check(context);
 
       const errors = spy.mock.calls;
 
@@ -167,14 +177,16 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("uses the fixValue for fixing if provided", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          foo: {
-            options: ["a", "b"],
-            fixValue: "a",
+      packageScript({
+        options: {
+          scripts: {
+            foo: {
+              options: ["a", "b"],
+              fixValue: "a",
+            },
           },
         },
-      });
+      }).check(context);
 
       const errors = spy.mock.calls;
 
@@ -190,14 +202,16 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("can fix to empty", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          [SCRIPT_NAME]: {
-            options: ["a", undefined],
-            fixValue: undefined,
+      packageScript({
+        options: {
+          scripts: {
+            [SCRIPT_NAME]: {
+              options: ["a", undefined],
+              fixValue: undefined,
+            },
           },
         },
-      });
+      }).check(context);
 
       const errors = spy.mock.calls;
 
@@ -210,14 +224,16 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("can allow only empty", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          [SCRIPT_NAME]: {
-            options: [undefined],
-            fixValue: undefined,
+      packageScript({
+        options: {
+          scripts: {
+            [SCRIPT_NAME]: {
+              options: [undefined],
+              fixValue: undefined,
+            },
           },
         },
-      });
+      }).check(context);
 
       const errors = spy.mock.calls;
 

package/src/__tests__/requireDependency.spec.ts

@@ -89,7 +89,7 @@ describe("requireDependency", () => {
     function checkAndSpy(q: string) {
       const context = workspaceContext.createChildContext(path.resolve(dir.name, q));
       const addErrorSpy = jest.spyOn(context, "addError");
-      requireDependency.check(context, OPTIONS);
+      requireDependency({ options: OPTIONS }).check(context);
       return { context, addErrorSpy };
     }
 
@@ -116,7 +116,7 @@ describe("requireDependency", () => {
     addFile("./packages/wrong/package.json", PACKAGE_WITH_WRONG_ENTRIES);
     addFile("./packages/right/package.json", PACKAGE_WITH_RIGHT_ENTRIES);
 
-    requireDependency.check(workspaceContext, OPTIONS);
+    requireDependency({ options: OPTIONS }).check(workspaceContext);
 
     const none = checkAndSpy("./packages/none");
     expect(none.addErrorSpy).toHaveBeenCalledTimes(2);

package/src/alphabeticalDependencies.ts

@@ -5,19 +5,17 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
 import { checkAlpha } from "./util/checkAlpha.js";
-import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+import { makeRule } from "./util/makeRule.js";
 const Options = r.Undefined;
 
-export const alphabeticalDependencies: RuleModule<typeof Options> = {
-  check: function expectAlphabeticalDependencies(context: Context) {
+export const alphabeticalDependencies = makeRule({
+  name: "alphabeticalDependencies",
+  check: (context) => {
     checkAlpha(context, "dependencies");
     checkAlpha(context, "devDependencies");
     checkAlpha(context, "peerDependencies");
   },
   optionsRuntype: Options,
-};
-
-export const AlphabeticalDependencies = createNewRuleConversion("AlphabetialDependencies", alphabeticalDependencies);
+});

package/src/alphabeticalScripts.ts

@@ -5,17 +5,15 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
 import { checkAlpha } from "./util/checkAlpha.js";
-import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+import { makeRule } from "./util/makeRule.js";
 const Options = r.Undefined;
 
-export const alphabeticalScripts: RuleModule<typeof Options> = {
-  check: function expectAlphabeticalScripts(context: Context) {
+export const alphabeticalScripts = makeRule({
+  name: "alphabeticalScripts",
+  check: (context) => {
     checkAlpha(context, "scripts");
   },
   optionsRuntype: Options,
-};
-
-export const AlphabeticalScripts = createNewRuleConversion("AlphabeticalScripts", alphabeticalScripts);
+});

package/src/bannedDependencies.ts

@@ -5,12 +5,12 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
+import { Context } from "@monorepolint/config";
 import { matchesAnyGlob } from "@monorepolint/utils";
 import { AggregateTiming } from "@monorepolint/utils";
 import * as path from "node:path";
 import * as r from "runtypes";
-import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+import { makeRule } from "./util/makeRule.js";
 import { IPackageDependencyGraphNode, PackageDependencyGraphService } from "./util/packageDependencyGraphService.js";
 // FIXME: This rule is messed. bannedTransitiveDependencies doesnt glob
 
@@ -49,10 +49,9 @@ const setCache = new Map<ReadonlyArray<string>, Set<string>>();
 
 const aggregateTiming = new AggregateTiming(":bannedDependencies stats");
 
-export const bannedDependencies: RuleModule<typeof Options> & {
-  printStats: () => void;
-} = {
-  check: function expectAllowedDependencies(context, opts, extra) {
+export const bannedDependencies = makeRule({
+  name: "bannedDependencies",
+  check: (context, opts, extra) => {
     aggregateTiming.start(extra?.id ?? "unknown id");
 
     const packageJson = context.getPackageJson();
@@ -112,8 +111,7 @@ export const bannedDependencies: RuleModule<typeof Options> & {
   printStats: () => {
     aggregateTiming.printResults();
   },
-};
-export const BannedDependencies = createNewRuleConversion("BannedDependencies", bannedDependencies);
+});
 
 function populateProblemsExact(banned: Set<string>, dependencies: ReadonlyArray<string>, violations: Set<string>) {
   for (const dependency of dependencies) {

package/src/consistentDependencies.ts

@@ -5,10 +5,10 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
+import { Context } from "@monorepolint/config";
 import { diff } from "jest-diff";
 import * as r from "runtypes";
-import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+import { makeRule } from "./util/makeRule.js";
 const Options = r
   .Record({
     ignoredDependencies: r.Array(r.String).Or(r.Undefined),
@@ -18,16 +18,15 @@ export type Options = r.Static<typeof Options>;
 
 const skippedVersions = ["*", "latest"];
 
-export const consistentDependencies = {
-  check: function expectConsistentDependencies(context: Context, args: Options) {
+export const consistentDependencies = makeRule({
+  name: "consistentDependencies",
+  check: (context, args) => {
     checkDeps(context, args, "dependencies");
     checkDeps(context, args, "devDependencies");
     // we don't check peer deps since they can be more lenient
   },
   optionsRuntype: Options,
-} as RuleModule<typeof Options>;
-
-export const ConsistentDependencies = createNewRuleConversion("ConsistentDependencies", consistentDependencies);
+});
 
 function checkDeps(context: Context, args: Options, block: "dependencies" | "devDependencies" | "peerDependencies") {
   const packageJson = context.getPackageJson();

package/src/consistentVersions.ts

@@ -5,21 +5,22 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
+import { Context } from "@monorepolint/config";
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import * as r from "runtypes";
 import { coerce, SemVer } from "semver";
-import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+import { makeRule } from "./util/makeRule.js";
 export const Options = r.Record({
   matchDependencyVersions: r.Dictionary(r.Union(r.String, r.Array(r.String))),
 });
 
 export type Options = r.Static<typeof Options>;
 
-export const consistentVersions: RuleModule<typeof Options> = {
+export const consistentVersions = makeRule({
+  name: "consistentVersions",
   check: checkConsistentVersions,
   optionsRuntype: Options,
-};
+});
 
 function checkConsistentVersions(context: Context, options: Options) {
   for (const [dependencyPackageName, expectedPackageDependencyValue] of Object.entries(
@@ -138,5 +139,3 @@ const ensurePackageMatchesSomeVersion = (
     });
   }
 };
-
-export const ConsistentVersions = createNewRuleConversion("ConsistentVersions", consistentVersions);