@hanseltime/template-repo-sync 2.2.1 → 2.4.0-alpha.0

package/dist/esm/match.spec.mjs

@@ -0,0 +1,71 @@
+import { resolve } from "path";
+import { getAllFilesInDir } from "./match.mjs";
+import { TEST_FIXTURES_DIR } from "./test-utils/index.mjs";
+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;
+        }
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/merge-file.mjs

@@ -0,0 +1,88 @@
+import { diffLines } from "diff";
+import { existsSync } from "fs";
+import { readFile, rm } from "node:fs/promises";
+import { outputFile } from "fs-extra";
+import { isMatch, some } from "micromatch";
+import { extname, join } from "path";
+import { loadPlugin } from "./load-plugin.mjs";
+/**
+ * Applies the merge to a file according to the context information.
+ *
+ * Returns true if merged and false if skipped
+ * @param relPath
+ * @param context
+ * @returns
+ */ export async function mergeFile(relPath, context) {
+    const { localTemplateSyncConfig, templateSyncConfig, tempCloneDir, cwd } = context;
+    if (some(relPath, localTemplateSyncConfig.ignore)) {
+        return {
+            ignoredDueToLocal: true
+        };
+    }
+    const ext = extname(relPath);
+    const filePath = join(cwd, relPath);
+    const templatePath = join(tempCloneDir, relPath);
+    // Unless there's a need, we remove files that were deleted and don't pass them to plugins yet
+    if (context.fileOperation === "deleted") {
+        if (existsSync(filePath)) {
+            await rm(filePath);
+        }
+        return {
+            ignoredDueToLocal: false,
+            localChanges: []
+        };
+    }
+    const mergeConfig = templateSyncConfig.merge?.find((mc)=>isMatch(relPath, mc.glob));
+    const localMergeConfig = localTemplateSyncConfig.merge?.find((mc)=>isMatch(relPath, mc.glob));
+    const mergeHandler = mergeConfig ? await loadPlugin(mergeConfig, tempCloneDir) : undefined;
+    const localMergeHandler = localMergeConfig ? await loadPlugin(localMergeConfig, cwd) : undefined;
+    // Either write the merge or write the file
+    let fileContents;
+    const localChanges = [];
+    if (existsSync(filePath) && (mergeHandler || localMergeHandler)) {
+        const originalCurrentFile = (await readFile(filePath)).toString();
+        if (mergeHandler) {
+            fileContents = await safeMerge(mergeHandler, mergeConfig?.plugin ?? `default for ${ext}`, originalCurrentFile, (await readFile(templatePath)).toString(), {
+                relFilePath: relPath,
+                mergeArguments: mergeConfig?.options ?? {},
+                isLocalOptions: false
+            });
+        } else {
+            // Apply overwrite if we didn't set up merge
+            fileContents = (await readFile(templatePath)).toString();
+        }
+        // We apply the localMerge Config to the fileContent output by the template merge
+        if (localMergeHandler) {
+            const localContents = await safeMerge(localMergeHandler, localMergeConfig?.plugin ?? `default for ${ext}`, originalCurrentFile, fileContents, {
+                relFilePath: relPath,
+                mergeArguments: localMergeConfig?.options ?? {},
+                isLocalOptions: true
+            });
+            localChanges.push(...diffLines(fileContents, localContents));
+            fileContents = localContents;
+        }
+    } else {
+        // Just perform simple overwrite
+        fileContents = (await readFile(templatePath)).toString();
+    }
+    await outputFile(filePath, fileContents);
+    return {
+        ignoredDueToLocal: false,
+        localChanges
+    };
+}
+/**
+ * Simple helper function to ensure that we don't let bad plugins corrupt the call flow
+ * @param plugin
+ */ async function safeMerge(plugin, pluginPath, current, fromTemplate, context) {
+    const ret = await plugin.merge(current, fromTemplate, context);
+    if (typeof ret !== "string") {
+        throw new Error(`Plugin ${pluginPath} did not return string for merge function!  This is not allowed!`);
+    }
+    if (!ret) {
+        throw new Error(`Plugin ${pluginPath} should not make a merge be an empty string!`);
+    }
+    return ret;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/merge-file.ts"],"sourcesContent":["import type { Change } from \"diff\";\nimport { diffLines } from \"diff\";\nimport { existsSync } from \"fs\";\nimport { readFile, rm } from \"fs/promises\";\nimport { outputFile } from \"fs-extra\";\nimport { isMatch, some } from \"micromatch\";\nimport { extname, join } from \"path\";\nimport { loadPlugin } from \"./load-plugin\";\nimport type { Config, FileOperation, MergeContext, MergePlugin } from \"./types\";\n\ninterface MergeFileOptions {\n\tlocalTemplateSyncConfig: Config;\n\ttemplateSyncConfig: Config;\n\ttempCloneDir: string;\n\tcwd: string;\n\tfileOperation: FileOperation;\n}\n\ninterface MergeFileReturn {\n\t/**\n\t * If the file was ignored due to the local config\n\t */\n\tignoredDueToLocal: boolean;\n\t/**\n\t * Only available if the file wasn't ignored, this is a list of lineDiffs\n\t * from the diff library that were applied to what would've been changed by\n\t * the base templatesync repo\n\t */\n\tlocalChanges?: Change[];\n}\n\n/**\n * Applies the merge to a file according to the context information.\n *\n * Returns true if merged and false if skipped\n * @param relPath\n * @param context\n * @returns\n */\nexport async function mergeFile(\n\trelPath: string,\n\tcontext: MergeFileOptions,\n): Promise<MergeFileReturn> {\n\tconst { localTemplateSyncConfig, templateSyncConfig, tempCloneDir, cwd } =\n\t\tcontext;\n\n\tif (some(relPath, localTemplateSyncConfig.ignore)) {\n\t\treturn {\n\t\t\tignoredDueToLocal: true,\n\t\t};\n\t}\n\n\tconst ext = extname(relPath);\n\tconst filePath = join(cwd, relPath);\n\tconst templatePath = join(tempCloneDir, relPath);\n\n\t// Unless there's a need, we remove files that were deleted and don't pass them to plugins yet\n\tif (context.fileOperation === \"deleted\") {\n\t\tif (existsSync(filePath)) {\n\t\t\tawait rm(filePath);\n\t\t}\n\t\treturn {\n\t\t\tignoredDueToLocal: false,\n\t\t\tlocalChanges: [],\n\t\t};\n\t}\n\n\tconst mergeConfig = templateSyncConfig.merge?.find((mc) =>\n\t\tisMatch(relPath, mc.glob),\n\t);\n\tconst localMergeConfig = localTemplateSyncConfig.merge?.find((mc) =>\n\t\tisMatch(relPath, mc.glob),\n\t);\n\n\tconst mergeHandler = mergeConfig\n\t\t? await loadPlugin(mergeConfig, tempCloneDir)\n\t\t: undefined;\n\tconst localMergeHandler = localMergeConfig\n\t\t? await loadPlugin(localMergeConfig, cwd)\n\t\t: undefined;\n\n\t// Either write the merge or write the file\n\tlet fileContents: string;\n\tconst localChanges: Change[] = [];\n\tif (existsSync(filePath) && (mergeHandler || localMergeHandler)) {\n\t\tconst originalCurrentFile = (await readFile(filePath)).toString();\n\t\tif (mergeHandler) {\n\t\t\tfileContents = await safeMerge(\n\t\t\t\tmergeHandler,\n\t\t\t\tmergeConfig?.plugin ?? `default for ${ext}`,\n\t\t\t\toriginalCurrentFile,\n\t\t\t\t(await readFile(templatePath)).toString(),\n\t\t\t\t{\n\t\t\t\t\trelFilePath: relPath,\n\t\t\t\t\tmergeArguments: mergeConfig?.options ?? {},\n\t\t\t\t\tisLocalOptions: false,\n\t\t\t\t},\n\t\t\t);\n\t\t} else {\n\t\t\t// Apply overwrite if we didn't set up merge\n\t\t\tfileContents = (await readFile(templatePath)).toString();\n\t\t}\n\n\t\t// We apply the localMerge Config to the fileContent output by the template merge\n\t\tif (localMergeHandler) {\n\t\t\tconst localContents = await safeMerge(\n\t\t\t\tlocalMergeHandler,\n\t\t\t\tlocalMergeConfig?.plugin ?? `default for ${ext}`,\n\t\t\t\toriginalCurrentFile,\n\t\t\t\tfileContents,\n\t\t\t\t{\n\t\t\t\t\trelFilePath: relPath,\n\t\t\t\t\tmergeArguments: localMergeConfig?.options ?? {},\n\t\t\t\t\tisLocalOptions: true,\n\t\t\t\t},\n\t\t\t);\n\t\t\tlocalChanges.push(...diffLines(fileContents, localContents));\n\t\t\tfileContents = localContents;\n\t\t}\n\t} else {\n\t\t// Just perform simple overwrite\n\t\tfileContents = (await readFile(templatePath)).toString();\n\t}\n\tawait outputFile(filePath, fileContents);\n\treturn {\n\t\tignoredDueToLocal: false,\n\t\tlocalChanges,\n\t};\n}\n\n/**\n * Simple helper function to ensure that we don't let bad plugins corrupt the call flow\n * @param plugin\n */\nasync function safeMerge(\n\tplugin: MergePlugin<unknown>,\n\tpluginPath: string,\n\tcurrent: string,\n\tfromTemplate: string,\n\tcontext: MergeContext,\n) {\n\tconst ret = await plugin.merge(current, fromTemplate, context);\n\tif (typeof ret !== \"string\") {\n\t\tthrow new Error(\n\t\t\t`Plugin ${pluginPath} did not return string for merge function!  This is not allowed!`,\n\t\t);\n\t}\n\n\tif (!ret) {\n\t\tthrow new Error(\n\t\t\t`Plugin ${pluginPath} should not make a merge be an empty string!`,\n\t\t);\n\t}\n\treturn ret as string;\n}\n"],"names":["diffLines","existsSync","readFile","rm","outputFile","isMatch","some","extname","join","loadPlugin","mergeFile","relPath","context","localTemplateSyncConfig","templateSyncConfig","tempCloneDir","cwd","ignore","ignoredDueToLocal","ext","filePath","templatePath","fileOperation","localChanges","mergeConfig","merge","find","mc","glob","localMergeConfig","mergeHandler","undefined","localMergeHandler","fileContents","originalCurrentFile","toString","safeMerge","plugin","relFilePath","mergeArguments","options","isLocalOptions","localContents","push","pluginPath","current","fromTemplate","ret","Error"],"mappings":"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"}