@monorepolint/rules 0.5.0-alpha.7 → 0.5.0-alpha.73

package/src/__tests__/nestedWorkspaces.spec.ts

@@ -0,0 +1,146 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { WorkspaceContext } from "@monorepolint/core";
+import { writeFileSync } from "fs";
+import * as path from "path";
+import * as tmp from "tmp";
+import { nestedWorkspaces } from "../nestedWorkspaces";
+import { makeDirectoryRecursively } from "../util/makeDirectory";
+import { jsonToString } from "./utils";
+
+const EMPTY_PACKAGE = jsonToString({});
+
+const PACKAGE_ROOT_WITH_PACKAGES_STAR = jsonToString({
+  workspaces: {
+    packages: ["packages/*"],
+  },
+});
+
+const PACKAGE_ROOT_WITH_TWO_LEVEL = jsonToString({
+  workspaces: {
+    packages: ["packages/*", "packages/deep/*"],
+  },
+});
+
+const PACKAGE_ROOT_WITH_THREE_LEVEL = jsonToString({
+  workspaces: {
+    packages: ["packages/*", "packages/deep/*", "packages/very/deep/*"],
+  },
+});
+
+describe("nestedWorkspaces", () => {
+  tmp.setGracefulCleanup();
+
+  let cleanupJobs: Array<() => void> = [];
+  let cwd: string | undefined;
+
+  beforeEach(() => {
+    const dir = tmp.dirSync({ unsafeCleanup: true });
+    cleanupJobs.push(() => dir.removeCallback());
+    cwd = dir.name;
+
+    const spy = jest.spyOn(process, "cwd");
+    spy.mockReturnValue(cwd);
+  });
+
+  afterEach(() => {
+    for (const cleanupJob of cleanupJobs) {
+      cleanupJob();
+    }
+    cleanupJobs = [];
+  });
+
+  function makeWorkspace() {
+    const workspaceContext = new WorkspaceContext(cwd!, {
+      rules: [],
+      fix: false,
+      verbose: false,
+      silent: true,
+    });
+
+    async function checkAndSpy() {
+      const addErrorSpy = jest.spyOn(workspaceContext, "addError");
+
+      await nestedWorkspaces.check(workspaceContext, undefined);
+      return { addErrorSpy };
+    }
+
+    function addFile(filePath: string, content: string) {
+      const dirPath = path.resolve(cwd!, path.dirname(filePath));
+      const resolvedFilePath = path.resolve(cwd!, filePath);
+
+      makeDirectoryRecursively(dirPath);
+      writeFileSync(resolvedFilePath, content);
+      return resolvedFilePath;
+    }
+
+    return { addFile, workspaceContext, checkAndSpy };
+  }
+
+  it("checks correctly when no packages", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    addFile("./package.json", EMPTY_PACKAGE);
+
+    expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("checks correctly when one level packages", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    addFile("./package.json", PACKAGE_ROOT_WITH_PACKAGES_STAR);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+
+    expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("checks fail when one level packages with no workspaces field", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const packageJsonPath = addFile("./package.json", EMPTY_PACKAGE);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+
+    const spy = (await checkAndSpy()).addErrorSpy;
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith({
+      file: packageJsonPath,
+      message: 'The "workspace" field is missing, even though there are workspaces in the repository.',
+    });
+  });
+
+  it("checks correctly when two level packages with two level workspaces field", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    addFile("./package.json", PACKAGE_ROOT_WITH_TWO_LEVEL);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+    addFile("./packages/deep/star/package.json", EMPTY_PACKAGE);
+
+    expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("checks fail when two level packages with one level workspaces field", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    const packageJsonPath = addFile("./package.json", PACKAGE_ROOT_WITH_PACKAGES_STAR);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+    addFile("./packages/deep/star/package.json", EMPTY_PACKAGE);
+
+    const spy = (await checkAndSpy()).addErrorSpy;
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith({
+      file: packageJsonPath,
+      message:
+        'The "workspace" field is missing one or more values: packages/deep/star. ' +
+        'You may be able to use a glob to avoid listing each workspace individually, e.g. "packages/nested-workspace/*".',
+    });
+  });
+
+  it("checks correctly when three level packages with three level workspaces field", async () => {
+    const { addFile, checkAndSpy } = makeWorkspace();
+    addFile("./package.json", PACKAGE_ROOT_WITH_THREE_LEVEL);
+    addFile("./packages/star/package.json", EMPTY_PACKAGE);
+    addFile("./packages/deep/star/package.json", EMPTY_PACKAGE);
+    addFile("./packages/very/deep/star/package.json", EMPTY_PACKAGE);
+
+    expect((await checkAndSpy()).addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+});

package/src/__tests__/packageEntry.spec.ts

@@ -0,0 +1,181 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+// tslint:disable:no-console
+import { createMockFiles } from "./utils";
+
+// done first since this also mocks 'fs'
+const mockFiles: Map<string, string> = createMockFiles();
+
+import { Failure, PackageContext } from "@monorepolint/core";
+import { packageEntry } from "../packageEntry";
+
+const PACKAGE_MISSING_ENTRY =
+  JSON.stringify(
+    {
+      name: "package",
+      version: {},
+      scripts: {},
+      dependencies: {},
+    },
+    undefined,
+    2
+  ) + "\n";
+
+const PACKAGE_LICENSE =
+  JSON.stringify(
+    {
+      name: "package",
+      version: {},
+      scripts: {},
+      dependencies: {},
+      license: "UNLICENSED",
+    },
+    undefined,
+    2
+  ) + "\n";
+
+const PACKAGE_REPOSITORY =
+  JSON.stringify(
+    {
+      name: "package",
+      version: {},
+      scripts: {},
+      dependencies: {},
+      repository: {
+        type: "git",
+        url: "https://github.com:foo/foo",
+      },
+    },
+    undefined,
+    2
+  ) + "\n";
+
+describe("expectPackageEntries", () => {
+  afterEach(() => {
+    mockFiles.clear();
+  });
+
+  describe("fix: true", () => {
+    const context = new PackageContext(".", {
+      rules: [],
+      fix: true,
+      verbose: false,
+      silent: true,
+    });
+    const spy = jest.spyOn(context, "addError");
+
+    afterEach(() => {
+      spy.mockClear();
+    });
+
+    it("fixes missing entries", () => {
+      mockFiles.set("package.json", PACKAGE_MISSING_ENTRY);
+
+      packageEntry.check(context, {
+        entries: {
+          license: "UNLICENSED",
+        },
+        entriesExist: undefined,
+      });
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure.file).toBe("package.json");
+      expect(failure.fixer).not.toBeUndefined();
+      expect(failure.message).toBe("Expected standardized entry for 'license'");
+
+      expect(mockFiles.get("package.json")).toEqual(PACKAGE_LICENSE);
+    });
+
+    it("fixes missing nested entries", () => {
+      mockFiles.set("package.json", PACKAGE_MISSING_ENTRY);
+
+      packageEntry.check(context, {
+        entries: {
+          repository: {
+            type: "git",
+            url: "https://github.com:foo/foo",
+          },
+        },
+        entriesExist: undefined,
+      });
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure.file).toBe("package.json");
+      expect(failure.fixer).not.toBeUndefined();
+      expect(failure.message).toBe("Expected standardized entry for 'repository'");
+
+      expect(mockFiles.get("package.json")).toEqual(PACKAGE_REPOSITORY);
+    });
+
+    it("doesn't error for nested entries that are defined", () => {
+      mockFiles.set("package.json", PACKAGE_REPOSITORY);
+
+      packageEntry.check(context, {
+        entries: {
+          repository: {
+            type: "git",
+            url: "https://github.com:foo/foo",
+          },
+        },
+        entriesExist: undefined,
+      });
+
+      expect(spy).toHaveBeenCalledTimes(0);
+      expect(mockFiles.get("package.json")).toEqual(PACKAGE_REPOSITORY);
+    });
+
+    it("errors for keys that are missing", () => {
+      mockFiles.set("package.json", PACKAGE_REPOSITORY);
+
+      packageEntry.check(context, {
+        entries: undefined,
+        entriesExist: ["bugs"],
+      });
+
+      expect(spy).toHaveBeenCalledTimes(1);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure.file).toBe("package.json");
+      expect(failure.fixer).toBeUndefined();
+      expect(failure.message).toBe("Expected entry for 'bugs' to exist");
+      expect(mockFiles.get("package.json")).toEqual(PACKAGE_REPOSITORY);
+    });
+
+    it("handles both entries and entriesExist", () => {
+      mockFiles.set("package.json", PACKAGE_MISSING_ENTRY);
+
+      packageEntry.check(context, {
+        entries: {
+          repository: {
+            type: "git",
+            url: "https://github.com:foo/foo",
+          },
+        },
+        entriesExist: ["bugs"],
+      });
+
+      expect(spy).toHaveBeenCalledTimes(2);
+
+      const failure: Failure = spy.mock.calls[0][0];
+      expect(failure.file).toBe("package.json");
+      expect(failure.fixer).not.toBeUndefined();
+      expect(failure.message).toBe("Expected standardized entry for 'repository'");
+
+      const failure2: Failure = spy.mock.calls[1][0];
+      expect(failure2.file).toBe("package.json");
+      expect(failure2.fixer).toBeUndefined();
+      expect(failure2.message).toBe("Expected entry for 'bugs' to exist");
+
+      expect(mockFiles.get("package.json")).toEqual(PACKAGE_REPOSITORY);
+    });
+  });
+});

package/src/__tests__/requireDependency.spec.ts

@@ -0,0 +1,146 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { WorkspaceContext } from "@monorepolint/core";
+import { readFileSync, writeFileSync } from "fs";
+import * as path from "path";
+import * as tmp from "tmp";
+import { requireDependency } from "../requireDependency";
+import { makeDirectoryRecursively } from "../util/makeDirectory";
+import { jsonToString } from "./utils";
+
+const PACKAGE_ROOT = jsonToString({
+  workspaces: {
+    packages: ["packages/*"],
+  },
+  dependencies: {
+    foo: "5",
+  },
+});
+
+const PACKAGE_WITH_NO_ENTRIES = jsonToString({});
+
+const PACKAGE_WITH_ENTRIES_MISSING = jsonToString({
+  dependencies: {},
+  devDependencies: {},
+});
+
+const PACKAGE_WITH_WRONG_ENTRIES = jsonToString({
+  dependencies: {
+    foo: "0.1.0",
+  },
+  devDependencies: {
+    bar: "1.0.0",
+  },
+});
+
+const PACKAGE_WITH_RIGHT_ENTRIES = jsonToString({
+  dependencies: {
+    foo: "1.0.0",
+  },
+  devDependencies: {
+    bar: "^2.0.0",
+  },
+});
+
+const OPTIONS = {
+  dependencies: {
+    foo: "1.0.0",
+  },
+  devDependencies: {
+    bar: "^2.0.0",
+  },
+} as const;
+
+const CORRECT_OUTPUT = jsonToString(OPTIONS);
+
+describe("requireDependency", () => {
+  tmp.setGracefulCleanup();
+
+  let cleanupJobs: Array<() => void> = [];
+
+  afterEach(() => {
+    for (const cleanupJob of cleanupJobs) {
+      cleanupJob();
+    }
+    cleanupJobs = [];
+  });
+
+  function makeWorkspace({ fix }: { fix: boolean }) {
+    const dir: tmp.DirResult = tmp.dirSync({ unsafeCleanup: true });
+    cleanupJobs.push(() => dir.removeCallback());
+
+    const workspaceContext = new WorkspaceContext(dir.name, {
+      rules: [],
+      fix,
+      verbose: false,
+      silent: true,
+    });
+
+    function checkAndSpy(q: string) {
+      const context = workspaceContext.createChildContext(path.resolve(dir.name, q));
+      const addErrorSpy = jest.spyOn(context, "addError");
+      requireDependency.check(context, OPTIONS);
+      return { context, addErrorSpy };
+    }
+
+    function addFile(filePath: string, content: string) {
+      const dirPath = path.resolve(dir.name, path.dirname(filePath));
+      const resolvedFilePath = path.resolve(dir.name, filePath);
+
+      makeDirectoryRecursively(dirPath);
+      writeFileSync(resolvedFilePath, content);
+    }
+
+    function readFile(filePath: string) {
+      return readFileSync(path.resolve(dir.name, filePath)).toString();
+    }
+
+    return { addFile, readFile, workspaceContext, checkAndSpy };
+  }
+
+  it("checks correctly", () => {
+    const { addFile, workspaceContext, checkAndSpy } = makeWorkspace({ fix: false });
+    addFile("./package.json", PACKAGE_ROOT);
+    addFile("./packages/none/package.json", PACKAGE_WITH_NO_ENTRIES);
+    addFile("./packages/missing/package.json", PACKAGE_WITH_ENTRIES_MISSING);
+    addFile("./packages/wrong/package.json", PACKAGE_WITH_WRONG_ENTRIES);
+    addFile("./packages/right/package.json", PACKAGE_WITH_RIGHT_ENTRIES);
+
+    requireDependency.check(workspaceContext, OPTIONS);
+
+    const none = checkAndSpy("./packages/none");
+    expect(none.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const missing = checkAndSpy("./packages/missing");
+    expect(missing.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const wrong = checkAndSpy("./packages/wrong");
+    expect(wrong.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const right = checkAndSpy("./packages/right");
+    expect(right.addErrorSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("fixes correctly", () => {
+    const { addFile, readFile, checkAndSpy } = makeWorkspace({ fix: true });
+    addFile("./package.json", PACKAGE_ROOT);
+    addFile("./packages/missing/package.json", PACKAGE_WITH_ENTRIES_MISSING);
+    addFile("./packages/wrong/package.json", PACKAGE_WITH_WRONG_ENTRIES);
+
+    const missing = checkAndSpy("./packages/missing");
+    expect(missing.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const wrong = checkAndSpy("./packages/wrong");
+    expect(wrong.addErrorSpy).toHaveBeenCalledTimes(2);
+
+    const missingContents = readFile("./packages/missing/package.json");
+    expect(missingContents).toEqual(CORRECT_OUTPUT);
+
+    const contents = readFile("./packages/wrong/package.json");
+    expect(contents).toEqual(CORRECT_OUTPUT);
+  });
+});

package/src/__tests__/utils.ts

@@ -17,7 +17,19 @@ export function createMockFiles() {
     readFileSync: function readFileSync(filePath: string, _contentType: string) {
       return mockFiles.get(filePath);
     },
+
+    existsSync: function existsSync(filePath: string) {
+      return mockFiles.has(filePath);
+    },
+
+    mkdirSync: function mkdirSync(directoryPath: string) {
+      return mockFiles.set(directoryPath, "");
+    },
   }));
 
   return mockFiles;
 }
+
+export function jsonToString(obj: {}) {
+  return JSON.stringify(obj, undefined, 2) + "\n";
+}

package/src/alphabeticalDependencies.ts

@@ -6,60 +6,16 @@
  */
 
 import { Context, RuleModule } from "@monorepolint/core";
-import { writeJson } from "@monorepolint/utils";
-import diff from "jest-diff";
 import * as r from "runtypes";
+import { checkAlpha } from "./util/checkAlpha";
 
 const Options = r.Undefined;
 
-export const alphabeticalDependencies = {
+export const alphabeticalDependencies: RuleModule<typeof Options> = {
   check: function expectAlphabeticalDependencies(context: Context) {
     checkAlpha(context, "dependencies");
     checkAlpha(context, "devDependencies");
     checkAlpha(context, "peerDependencies");
   },
   optionsRuntype: Options,
-} as RuleModule<typeof Options>;
-
-function checkAlpha(context: Context, block: "dependencies" | "devDependencies" | "peerDependencies") {
-  const packageJson = context.getPackageJson();
-  const packagePath = context.getPackageJsonPath();
-
-  const dependencies = packageJson[block];
-
-  if (dependencies === undefined) {
-    return;
-  }
-
-  const actualOrder = Object.keys(dependencies);
-  const expectedOrder = actualOrder.slice().sort(); // sort mutates, so we need to copy the previous result
-
-  if (!arrayOrderCompare(actualOrder, expectedOrder)) {
-    context.addError({
-      file: packagePath,
-      message: `Incorrect order of ${block} in package.json`,
-      longMessage: diff(expectedOrder, actualOrder, { expand: true }),
-      fixer: () => {
-        const expectedDependencies: Record<string, string> = {};
-
-        expectedOrder.forEach(dep => {
-          expectedDependencies[dep] = dependencies[dep];
-        });
-
-        const newPackageJson = { ...packageJson };
-        newPackageJson[block] = expectedDependencies;
-        writeJson(packagePath, newPackageJson);
-      },
-    });
-  }
-}
-
-function arrayOrderCompare(a: ReadonlyArray<string>, b: ReadonlyArray<string>) {
-  for (let index = 0; index < a.length; index++) {
-    if (a[index] !== b[index]) {
-      return false;
-    }
-  }
-
-  return true;
-}
+};

package/src/alphabeticalScripts.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Context, RuleModule } from "@monorepolint/core";
+import * as r from "runtypes";
+import { checkAlpha } from "./util/checkAlpha";
+
+const Options = r.Undefined;
+
+export const alphabeticalScripts: RuleModule<typeof Options> = {
+  check: function expectAlphabeticalScripts(context: Context) {
+    checkAlpha(context, "scripts");
+  },
+  optionsRuntype: Options,
+};

package/src/bannedDependencies.ts

@@ -9,22 +9,51 @@ import { Context, RuleModule } from "@monorepolint/core";
 import { writeJson } from "@monorepolint/utils";
 import diff from "jest-diff";
 import minimatch from "minimatch";
+import path from "path";
 import * as r from "runtypes";
+import { IPackageDependencyGraphNode, PackageDependencyGraphService } from "./util/packageDependencyGraphService";
 
-const Options = r.Record({
-  bannedDependencies: r.Array(r.String),
-});
+const Options = r.Union(
+  r
+    .Record({
+      bannedDependencies: r.Array(r.String),
+    })
+    .And(
+      r.Partial({
+        bannedTransitiveDependencies: r.Undefined,
+      })
+    ),
+  r
+    .Record({
+      bannedTransitiveDependencies: r.Array(r.String),
+    })
+    .And(
+      r.Partial({
+        bannedDependencies: r.Undefined,
+      })
+    ),
+  r.Record({
+    bannedDependencies: r.Array(r.String),
+    bannedTransitiveDependencies: r.Array(r.String),
+  })
+);
 
-type Options = r.Static<typeof Options>;
+export type Options = r.Static<typeof Options>;
 
 export const bannedDependencies: RuleModule<typeof Options> = {
   check: function expectAllowedDependencies(context: Context, opts: Options) {
     // tslint:disable-next-line:no-shadowed-variable
-    const { bannedDependencies } = opts;
+    const { bannedDependencies, bannedTransitiveDependencies } = opts;
 
-    checkBanned(context, bannedDependencies, "dependencies");
-    checkBanned(context, bannedDependencies, "devDependencies");
-    checkBanned(context, bannedDependencies, "peerDependencies");
+    if (bannedDependencies) {
+      checkBanned(context, bannedDependencies, "dependencies");
+      checkBanned(context, bannedDependencies, "devDependencies");
+      checkBanned(context, bannedDependencies, "peerDependencies");
+    }
+
+    if (bannedTransitiveDependencies) {
+      checkTransitives(context, bannedTransitiveDependencies);
+    }
   },
   optionsRuntype: Options,
 };
@@ -44,26 +73,55 @@ function checkBanned(
     return;
   }
 
-  const expectedDependencies: Record<string, string> = {};
+  const newPackageJson = { ...packageJson };
+  const violations: string[] = [];
 
   for (const dependency of Object.keys(dependencies)) {
     for (const bannedDependency of bannedDependencies) {
-      if (!minimatch(dependency, bannedDependency)) {
-        expectedDependencies[dependency] = dependencies[dependency];
+      if (minimatch(dependency, bannedDependency)) {
+        violations.push(dependency);
+        delete newPackageJson[block]![dependency];
       }
     }
   }
 
-  if (Object.keys(expectedDependencies).length !== Object.keys(dependencies).length) {
+  if (violations.length > 0) {
     context.addError({
       file: packagePath,
-      message: `Banned depdendencies in ${block} in package.json`,
-      longMessage: diff(expectedDependencies, dependencies, { expand: true }),
+      message:
+        `Found ${violations.length} banned dependencies in '${block}' block of package.json:\n\t` +
+        violations.map((v) => `'${v}'`).join(", "),
+      longMessage: diff(newPackageJson[block], dependencies, { expand: true }),
       fixer: () => {
-        const newPackageJson = { ...packageJson };
-        newPackageJson[block] = expectedDependencies;
         writeJson(packagePath, newPackageJson);
       },
     });
   }
 }
+
+function checkTransitives(
+  context: Context,
+  // tslint:disable-next-line: no-shadowed-variable
+  bannedDependencies: ReadonlyArray<string>
+) {
+  const graphService = new PackageDependencyGraphService();
+  const root = graphService.buildDependencyGraph(path.resolve(context.getPackageJsonPath()));
+  for (const { dependencies, importPath } of graphService.traverse(root)) {
+    for (const [dependency] of dependencies) {
+      if (bannedDependencies.includes(dependency)) {
+        // Remove the starting package since it's obvious in CLI output.
+        const [, ...importPathWithoutRoot] = importPath;
+        const pathing = [...importPathWithoutRoot.map(nameOrPackageJsonPath), dependency].join(" -> ");
+
+        context.addError({
+          file: root.paths.packageJsonPath,
+          message: `Banned transitive dependencies in repo: ${pathing}`,
+        });
+      }
+    }
+  }
+}
+
+function nameOrPackageJsonPath(node: IPackageDependencyGraphNode): string {
+  return node.packageJson.name ?? node.paths.packageJsonPath;
+}