@hanseltime/template-repo-sync 1.0.1

package/src/diff-drivers/types.ts

@@ -0,0 +1,8 @@
+/**
+ * A function that operates within the gitDir, and returns the list of file paths
+ * since the last sha
+ */
+export type TemplateDiffDriverFn = (
+  gitDir: string,
+  afterRef: string,
+) => Promise<string[]>;

package/src/formatting/__snapshots__/sync-results-to-md.spec.ts.snap

@@ -0,0 +1,22 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`syncResultsToMd snapshots 1`] = `
+"# templatesync.local 
+
+## Stopped the following files from syncing:
+
+* src/file1.ts
+
+
+## Changed the following files from what they would have synced:
+
+package.json
+\`\`\`diff
+
++my thing
+
+-your thang
+
+\`\`\`
+"
+`;

package/src/formatting/index.ts

@@ -0,0 +1,2 @@
+export * from "./sync-results-to-md";
+export * from "./infer-json-indent";

package/src/formatting/infer-json-indent.spec.ts

@@ -0,0 +1,49 @@
+import { inferJSONIndent } from "./infer-json-indent";
+
+const withNewLine = `{
+
+    "whoa": true,
+    "thing": here,
+    "something": {
+        "nested": false
+    }
+}`;
+
+const fourSpaces = `{
+    "whoa": true,
+    "thing": here,
+    "something": {
+        "nested": false
+    }
+}`;
+
+const tabSpaces = `{
+	"whoa": true,
+	"thing": here,
+	"something": {
+		"nested": false
+	}
+}`;
+
+const twoSpaces = `{
+  "whoa": true,
+  "thing": here,
+  "something": {
+    "nested": false
+  }
+}`;
+
+describe("inferJSONIndent", () => {
+  it("returns spaces when the first indent is spaces with a new line", () => {
+    expect(inferJSONIndent(withNewLine)).toBe("    ");
+  });
+  it("returns spaces when the first indent is spaces", () => {
+    expect(inferJSONIndent(fourSpaces)).toBe("    ");
+  });
+  it("returns spaces when the first indent is spaces", () => {
+    expect(inferJSONIndent(twoSpaces)).toBe("  ");
+  });
+  it("returns tabs when the first indent is a tab", () => {
+    expect(inferJSONIndent(tabSpaces)).toBe("\t");
+  });
+});

package/src/formatting/infer-json-indent.ts

@@ -0,0 +1,16 @@
+const spacingRegex = /[{[]\n?(?<spacing>\s+)["tf\d]/;
+export function inferJSONIndent(rawJSON: string) {
+  const match = spacingRegex.exec(rawJSON);
+  if (!match?.groups?.spacing) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `Could not find json indentation for json string: ${rawJSON.slice(40)} ... \nDefaulting to 4 spaces`,
+    );
+    // Four spaces
+    return "    ";
+  }
+  const spacing = match.groups.spacing;
+  // Handle the case where there were multiple newlines before a value
+  const lastNewLine = spacing.lastIndexOf("\n");
+  return match?.groups.spacing.slice(lastNewLine >= 0 ? lastNewLine + 1 : 0);
+}

package/src/formatting/sync-results-to-md.spec.ts

@@ -0,0 +1,25 @@
+import { syncResultsToMd } from "./sync-results-to-md";
+
+describe("syncResultsToMd", () => {
+  it("snapshots", () => {
+    expect(
+      syncResultsToMd({
+        localSkipFiles: ["src/file1.ts"],
+        localFileChanges: {
+          "package.json": [
+            {
+              count: 8,
+              value: "my thing",
+              added: true,
+            },
+            {
+              count: 10,
+              value: "your thang",
+              removed: true,
+            },
+          ],
+        },
+      }),
+    ).toMatchSnapshot();
+  });
+});

package/src/formatting/sync-results-to-md.ts

@@ -0,0 +1,46 @@
+import { Change } from "diff";
+import {
+  TEMPLATE_SYNC_LOCAL_CONFIG,
+  TemplateSyncReturn,
+} from "../template-sync";
+
+export function syncResultsToMd(result: TemplateSyncReturn) {
+  return `# ${TEMPLATE_SYNC_LOCAL_CONFIG} 
+
+## Stopped the following files from syncing:
+
+${result.localSkipFiles.reduce((s, file) => {
+  return `${s}* ${file}\n`;
+}, "")}
+
+## Changed the following files from what they would have synced:
+
+${Object.keys(result.localFileChanges).reduce((s, file) => {
+  return `${s}${file}
+\`\`\`diff
+${result.localFileChanges[file].reduce((diffS, change) => {
+  return `${diffS}\n${makeChangeIntoDiffLines(change)}`;
+}, "")}
+\`\`\``;
+}, "")}
+`;
+}
+
+function makeChangeIntoDiffLines(change: Change, nonchangeMax = 3) {
+  const operator = change.added ? "+" : change.removed ? "-" : "";
+
+  if (
+    !operator &&
+    nonchangeMax > 0 &&
+    change.count &&
+    change.count > nonchangeMax
+  ) {
+    const lines = change.value.split("\n");
+    const partial = lines.slice(lines.length - nonchangeMax);
+    return `...\n${partial.join("\n")}\n`;
+  }
+
+  return change.value.split("\n").reduce((s, line) => {
+    return `${s}${operator}${line}\n`;
+  }, "");
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./template-sync";
+export * from "./formatting";

package/src/load-plugin.ts

@@ -0,0 +1,42 @@
+import { defaultExtensionMap } from "./plugins";
+import { MergeConfig, MergePlugin } from "./types";
+import { existsSync } from "fs";
+import { resolve } from "path";
+
+export async function loadPlugin<T>(
+  mergeConfig: MergeConfig<T>,
+  forExt: string,
+  configDir: string,
+): Promise<MergePlugin<T>> {
+  let handler: MergePlugin<unknown>;
+  if (mergeConfig.plugin) {
+    // First check if this is a loal .js file
+    const localPath = resolve(configDir, mergeConfig.plugin);
+    const importPath = existsSync(localPath) ? localPath : mergeConfig.plugin;
+    try {
+      // Sad workaround for testing since dynamic import segfaults
+      if (process.env.JEST_WORKER_ID !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        handler = require(importPath) as MergePlugin<unknown>;
+      } else {
+        handler = (await import(importPath)) as MergePlugin<unknown>;
+      }
+      if (!handler.merge) {
+        handler = (handler as unknown as { default: MergePlugin<unknown> })
+          .default;
+      }
+    } catch (err) {
+      console.error(err);
+      throw err;
+    }
+  } else {
+    if (!defaultExtensionMap[forExt]) {
+      throw new Error(
+        `No default merge function supplied for ${forExt}.  Cannot have mere config without custom plugin supplied.`,
+      );
+    }
+    handler = defaultExtensionMap[forExt];
+  }
+
+  return handler as MergePlugin<T>;
+}

package/src/match.spec.ts

@@ -0,0 +1,68 @@
+import { resolve } from "path";
+import { getAllFilesInDir } from "./match";
+import { TEST_FIXTURES_DIR } from "./test-utils";
+
+const TEST_GLOB_DIR = resolve(TEST_FIXTURES_DIR, "glob-test");
+
+describe("getAllFilesInDir", () => {
+  it("gets all files in the directory with no ignores", () => {
+    const files = getAllFilesInDir(TEST_GLOB_DIR, []);
+    expect(files).toEqual(
+      expect.arrayContaining([
+        "folder1/something.js",
+        "folder1/something.ts",
+        "toplevel.js",
+        "toplevel.txt",
+      ]),
+    );
+    try {
+      expect(files.length).toBe(4);
+    } catch (err) {
+      console.error("All found files: " + files);
+      throw err;
+    }
+  });
+  it("gets all files in the directory that do not match the ignore (single)", () => {
+    const files = getAllFilesInDir(TEST_GLOB_DIR, ["**/*.ts"]);
+    expect(files).toEqual(
+      expect.arrayContaining([
+        "folder1/something.js",
+        "toplevel.js",
+        "toplevel.txt",
+      ]),
+    );
+    try {
+      expect(files.length).toBe(3);
+    } catch (err) {
+      console.error("All found files: " + files);
+      throw err;
+    }
+  });
+  it("gets all files in the directory that do not match the ignore (multiple)", () => {
+    const files = getAllFilesInDir(TEST_GLOB_DIR, ["**/*.ts", "**/*.txt"]);
+    expect(files).toEqual(
+      expect.arrayContaining(["folder1/something.js", "toplevel.js"]),
+    );
+    try {
+      expect(files.length).toBe(2);
+    } catch (err) {
+      console.error("All found files: " + files);
+      throw err;
+    }
+  });
+
+  it("gets all files in the directory that do not match the ignore with a folder level directive (multiple)", () => {
+    const files = getAllFilesInDir(TEST_GLOB_DIR, [
+      "**/*.ts",
+      "**/*.txt",
+      "folder1",
+    ]);
+    expect(files).toEqual(expect.arrayContaining(["toplevel.js"]));
+    try {
+      expect(files.length).toBe(1);
+    } catch (err) {
+      console.error("All found files: " + files);
+      throw err;
+    }
+  });
+});

package/src/match.ts

@@ -0,0 +1,52 @@
+import { readdirSync } from "fs";
+import { some } from "micromatch";
+import { join } from "path";
+
+export function invertMatchPatterns(patterns: string[]) {
+  return patterns.map((pattern) => {
+    if (pattern.startsWith("!")) {
+      return pattern.slice(1);
+    }
+    return `!${pattern}`;
+  });
+}
+
+/**
+ * Gets all the files in the directory recursively while avoiding any micromatch patterns
+ * that would match for ignoring
+ *
+ * @param dir
+ * @param ignorePatterns
+ * @returns
+ */
+export function getAllFilesInDir(
+  dir: string,
+  ignorePatterns: string[],
+): string[] {
+  return recurseDirsForFiles(dir, ignorePatterns);
+}
+
+function recurseDirsForFiles(
+  dirpath: string,
+  ignorePatterns: string[],
+  relativeRoot = "",
+): string[] {
+  return readdirSync(dirpath, {
+    withFileTypes: true,
+  }).reduce((files, f) => {
+    const relPath = join(relativeRoot, f.name);
+    if (some(relPath, ignorePatterns)) {
+      return files;
+    }
+
+    // Ensure we aren't ignoring these folders explicitly
+    if (f.isDirectory()) {
+      files.push(
+        ...recurseDirsForFiles(join(dirpath, f.name), ignorePatterns, relPath),
+      );
+    } else {
+      files.push(relPath);
+    }
+    return files;
+  }, [] as string[]);
+}