@tricoteuses/assemblee 1.0.0-next.2 → 1.0.2

package/lib/scripts/diff_amendements.mjs

@@ -0,0 +1,234 @@
+import commandLineArgs from "command-line-args";
+import fs from "fs-extra";
+import path from "path";
+import { detailedDiff } from "deep-object-diff";
+import { datasets, DatasetStructure } from "../datasets.mjs";
+import { walkDir } from "../file_systems.mjs";
+const diffedAmendments = [];
+const newAmendments = [];
+const optionsDefinitions = [{
+  alias: "s",
+  help: "don't log anything",
+  name: "silent",
+  type: Boolean
+}, {
+  alias: "v",
+  help: "verbose logs",
+  name: "verbose",
+  type: Boolean
+}, {
+  alias: "m",
+  help: "Diff modes.",
+  name: "mode",
+  defaultValue: "merged",
+  type: String
+}, {
+  defaultOption: true,
+  help: "directory containing Assemblée open data files",
+  name: "dataDir",
+  type: String
+}, {
+  alias: "p",
+  help: "Directory containing the previous dump of amendments",
+  name: "previous",
+  type: String
+}, {
+  alias: "o",
+  help: "Output directory for diff files",
+  name: "output",
+  defaultValue: "./diff_outputs/",
+  type: String
+}];
+const options = commandLineArgs(optionsDefinitions);
+
+function diffAmendements(dataDir) {
+  if (!options.previous) {
+    console.error("No previous data folder specified. You must provide one with the -p or --previous option. Exiting...");
+    process.exit();
+  }
+
+  if (!fs.existsSync(options.output)) {
+    console.error("The output dir does not exists. You must provide an existing directory. Default directory is ./diff_outputs/");
+    process.exit();
+  }
+
+  for (const dataset of datasets.amendements) {
+    switch (dataset.structure) {
+      case DatasetStructure.SegmentedFiles:
+        {
+          const originalJsonDir = path.join(dataDir, dataset.filename);
+
+          if (!options.silent) {
+            console.log(`Diffing ${originalJsonDir} folder...`);
+          }
+
+          for (const amendementSplitPath of walkDir(originalJsonDir)) {
+            const newFilePath = originalJsonDir + "/" + amendementSplitPath.join("/");
+            const newFile = JSON.parse(fs.readFileSync(newFilePath).toLocaleString());
+            const oldFilePath = options.previous + dataset.filename + "/" + amendementSplitPath.join("/");
+            const oldFileExists = fs.existsSync(oldFilePath);
+
+            if (!oldFileExists) {
+              // If file found does not exist in the previous dump
+              if (!options.silent) {
+                console.log("File did not exists previously. Guessing it's a new amendment. Adding to the diff list for new objects");
+              }
+
+              addToQueueForNewAmendments(newFile, amendementSplitPath);
+              continue;
+            } // File already existed in previous dump
+
+
+            let oldFile = JSON.parse("{}");
+
+            try {
+              // Gather data of the file and retranscript as a Json object
+              oldFile = JSON.parse(fs.readFileSync(oldFilePath).toLocaleString());
+            } catch (e) {
+              // Skip the process to the next iteration in case of corrupt JSON data
+              continue;
+            } // Generate the diff beetween the two JSON objects (old & new dump)
+
+
+            const diff = detailedDiff(oldFile, newFile); // If no changes beetween the two dumps
+
+            if (Object.keys(diff.added).length === 0 && Object.keys(diff.updated).length === 0 && Object.keys(diff.deleted).length === 0) {
+              // Skip to next iteration as there is no need to generate a file
+              continue;
+            } else {
+              if (!options.silent) {
+                console.log("Changes found !");
+              }
+
+              addToQueueForDiffedAmendments(diff, amendementSplitPath);
+            }
+
+            break;
+          }
+        }
+    }
+
+    if (!options.silent) {
+      console.log("Generating output(s)");
+    }
+
+    generateDiffFiles();
+  }
+}
+/**
+ * General process for output of diffs.
+ * The script handles two different modes :
+ * - merged : Will output a single file for new amendements and a single file
+ *            for updated amendements
+ * - splitted : Will output a single file for each amendments, either its new or updated.
+ *
+ */
+
+
+function generateDiffFiles() {
+  // Handles merged mode
+  if (options.mode === "merged") {
+    if (!options.silent) {
+      console.log("Generating merged files");
+    }
+
+    if (diffedAmendments.length > 0) {
+      if (!options.silent) {
+        console.log("Generating diffed amendments files");
+      }
+
+      fs.writeFileSync(options.output + "amendements_XV_diffed.json", JSON.stringify(diffedAmendments), {
+        encoding: "utf8",
+        flag: "w"
+      });
+    } else {
+      if (!options.silent) {
+        console.log("No diff in the already existing amendments");
+      }
+    }
+
+    if (newAmendments.length > 0) {
+      if (!options.silent) {
+        console.log("Generating new amendments file");
+      }
+
+      fs.writeFileSync(options.output + "amendements_XV_new.json", JSON.stringify(newAmendments), {
+        encoding: "utf8",
+        flag: "w"
+      });
+    } else {
+      if (!options.silent) {
+        console.log("No new amendement. Skipping file generation");
+      }
+    }
+  } else if (options.mode === "splitted") {
+    // Handles splitted mode
+    if (!options.silent) {
+      console.log("Generating separated files");
+    }
+    /**
+     * Process the copy action of the new and diffed amendments
+     */
+
+
+    diffedAmendments.forEach(diffedAmendment => {
+      generateSingleDiffedAmendment(diffedAmendment);
+    });
+    newAmendments.forEach(newAmendment => {
+      generateSingleNewAmendment(newAmendment);
+    });
+  } else {
+    console.error("Unknown output mode. Aborting...");
+    process.exit();
+  }
+} // Pushes an amendment to the queue that will be processed to copy new amendments files
+
+
+function addToQueueForNewAmendments(file, path) {
+  const amendment = {
+    path: path,
+    data: file
+  };
+  newAmendments.push(amendment);
+} // Pushes an amendment to the queue that will be processed to copy updated amendments files
+
+
+function addToQueueForDiffedAmendments(diffedData, path) {
+  const amendment = {
+    path: path,
+    data: diffedData
+  };
+  diffedAmendments.push(amendment);
+} // generates a file with a copy of the new amendement
+
+
+function generateSingleNewAmendment(newAmendment) {
+  newAmendment.path.shift();
+  const shortDir = [...newAmendment.path];
+  shortDir.pop();
+  console.log(options.output + shortDir.join("/"));
+  fs.mkdirSync(options.output + shortDir.join("/"), {
+    recursive: true
+  });
+  fs.writeFileSync(options.output + newAmendment.path.join("/").replace(/(\.json)/, ".new$1"), JSON.stringify(newAmendment.data), {
+    encoding: "utf8",
+    flag: "w"
+  });
+} // generates a file with a copy of the modified data of the previously existing amendment;
+
+
+function generateSingleDiffedAmendment(diffedAmendment) {
+  diffedAmendment.path.shift();
+  const shortDir = [...diffedAmendment.path];
+  shortDir.pop();
+  fs.mkdirSync(options.output + shortDir.join("/"), {
+    recursive: true
+  });
+  fs.writeFileSync(options.output + diffedAmendment.path.join("/").replace(/(\.json)/, ".diff$1"), JSON.stringify(diffedAmendment.data), {
+    encoding: "utf8",
+    flag: "w"
+  });
+}
+
+diffAmendements(options.dataDir);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["commandLineArgs","fs","path","detailedDiff","datasets","DatasetStructure","walkDir","diffedAmendments","newAmendments","optionsDefinitions","alias","help","name","type","Boolean","defaultValue","String","defaultOption","options","diffAmendements","dataDir","previous","console","error","process","exit","existsSync","output","dataset","amendements","structure","SegmentedFiles","originalJsonDir","join","filename","silent","log","amendementSplitPath","newFilePath","newFile","JSON","parse","readFileSync","toLocaleString","oldFilePath","oldFileExists","addToQueueForNewAmendments","oldFile","e","diff","Object","keys","added","length","updated","deleted","addToQueueForDiffedAmendments","generateDiffFiles","mode","writeFileSync","stringify","encoding","flag","forEach","diffedAmendment","generateSingleDiffedAmendment","newAmendment","generateSingleNewAmendment","file","amendment","data","push","diffedData","shift","shortDir","pop","mkdirSync","recursive","replace"],"sources":["../../src/scripts/diff_amendements.ts"],"sourcesContent":["import commandLineArgs from \"command-line-args\"\nimport fs from \"fs-extra\"\nimport path from \"path\"\nimport { detailedDiff } from \"deep-object-diff\"\nimport { datasets, DatasetStructure } from \"../datasets\"\nimport { walkDir } from \"../file_systems\"\nconst diffedAmendments: Array<any> = []\nconst newAmendments: Array<any> = []\n\nconst optionsDefinitions = [\n  {\n    alias: \"s\",\n    help: \"don't log anything\",\n    name: \"silent\",\n    type: Boolean,\n  },\n  {\n    alias: \"v\",\n    help: \"verbose logs\",\n    name: \"verbose\",\n    type: Boolean,\n  },\n  {\n    alias: \"m\",\n    help: \"Diff modes.\",\n    name: \"mode\",\n    defaultValue: \"merged\",\n    type: String,\n  },\n  {\n    defaultOption: true,\n    help: \"directory containing Assemblée open data files\",\n    name: \"dataDir\",\n    type: String,\n  },\n  {\n    alias: \"p\",\n    help: \"Directory containing the previous dump of amendments\",\n    name: \"previous\",\n    type: String,\n  },\n  {\n    alias: \"o\",\n    help: \"Output directory for diff files\",\n    name: \"output\",\n    defaultValue: \"./diff_outputs/\",\n    type: String,\n  },\n]\nconst options = commandLineArgs(optionsDefinitions)\n\nfunction diffAmendements(dataDir: string) {\n  if (!options.previous) {\n    console.error(\n      \"No previous data folder specified. You must provide one with the -p or --previous option. Exiting...\",\n    )\n    process.exit()\n  }\n\n  if (!fs.existsSync(options.output)) {\n    console.error(\n      \"The output dir does not exists. You must provide an existing directory. Default directory is ./diff_outputs/\",\n    )\n    process.exit()\n  }\n\n  for (const dataset of datasets.amendements) {\n    switch (dataset.structure) {\n      case DatasetStructure.SegmentedFiles: {\n        const originalJsonDir: string = path.join(dataDir, dataset.filename)\n        if (!options.silent) {\n          console.log(`Diffing ${originalJsonDir} folder...`)\n        }\n\n        for (const amendementSplitPath of walkDir(originalJsonDir)) {\n          const newFilePath =\n            originalJsonDir + \"/\" + amendementSplitPath.join(\"/\")\n          const newFile = JSON.parse(\n            fs.readFileSync(newFilePath).toLocaleString(),\n          )\n\n          const oldFilePath =\n            options.previous +\n            dataset.filename +\n            \"/\" +\n            amendementSplitPath.join(\"/\")\n          const oldFileExists = fs.existsSync(oldFilePath)\n          if (!oldFileExists) {\n            // If file found does not exist in the previous dump\n            if (!options.silent) {\n              console.log(\n                \"File did not exists previously. Guessing it's a new amendment. Adding to the diff list for new objects\",\n              )\n            }\n            addToQueueForNewAmendments(newFile, amendementSplitPath)\n            continue\n          }\n\n          // File already existed in previous dump\n          let oldFile: JSON = JSON.parse(\"{}\")\n          try {\n            // Gather data of the file and retranscript as a Json object\n            oldFile = JSON.parse(fs.readFileSync(oldFilePath).toLocaleString())\n          } catch (e) {\n            // Skip the process to the next iteration in case of corrupt JSON data\n            continue\n          }\n\n          // Generate the diff beetween the two JSON objects (old & new dump)\n          const diff: any = detailedDiff(oldFile, newFile)\n\n          // If no changes beetween the two dumps\n          if (\n            Object.keys(diff.added).length === 0 &&\n            Object.keys(diff.updated).length === 0 &&\n            Object.keys(diff.deleted).length === 0\n          ) {\n            // Skip to next iteration as there is no need to generate a file\n            continue\n          } else {\n            if (!options.silent) {\n              console.log(\"Changes found !\")\n            }\n            addToQueueForDiffedAmendments(diff, amendementSplitPath)\n          }\n          break\n        }\n      }\n    }\n\n    if (!options.silent) {\n      console.log(\"Generating output(s)\")\n    }\n\n    generateDiffFiles()\n  }\n}\n\n/**\n * General process for output of diffs.\n * The script handles two different modes :\n * - merged : Will output a single file for new amendements and a single file\n *            for updated amendements\n * - splitted : Will output a single file for each amendments, either its new or updated.\n *\n */\nfunction generateDiffFiles() {\n  // Handles merged mode\n  if (options.mode === \"merged\") {\n    if (!options.silent) {\n      console.log(\"Generating merged files\")\n    }\n\n    if (diffedAmendments.length > 0) {\n      if (!options.silent) {\n        console.log(\"Generating diffed amendments files\")\n      }\n      fs.writeFileSync(\n        options.output + \"amendements_XV_diffed.json\",\n        JSON.stringify(diffedAmendments),\n        { encoding: \"utf8\", flag: \"w\" },\n      )\n    } else {\n      if (!options.silent) {\n        console.log(\"No diff in the already existing amendments\")\n      }\n    }\n\n    if (newAmendments.length > 0) {\n      if (!options.silent) {\n        console.log(\"Generating new amendments file\")\n      }\n      fs.writeFileSync(\n        options.output + \"amendements_XV_new.json\",\n        JSON.stringify(newAmendments),\n        { encoding: \"utf8\", flag: \"w\" },\n      )\n    } else {\n      if (!options.silent) {\n        console.log(\"No new amendement. Skipping file generation\")\n      }\n    }\n  } else if (options.mode === \"splitted\") {\n    // Handles splitted mode\n    if (!options.silent) {\n      console.log(\"Generating separated files\")\n    }\n\n    /**\n     * Process the copy action of the new and diffed amendments\n     */\n\n    diffedAmendments.forEach((diffedAmendment: any) => {\n      generateSingleDiffedAmendment(diffedAmendment)\n    })\n\n    newAmendments.forEach((newAmendment: any) => {\n      generateSingleNewAmendment(newAmendment)\n    })\n  } else {\n    console.error(\"Unknown output mode. Aborting...\")\n    process.exit()\n  }\n}\n\n// Pushes an amendment to the queue that will be processed to copy new amendments files\nfunction addToQueueForNewAmendments(file: any, path: any): void {\n  const amendment: any = {\n    path: path,\n    data: file,\n  }\n  newAmendments.push(amendment)\n}\n// Pushes an amendment to the queue that will be processed to copy updated amendments files\nfunction addToQueueForDiffedAmendments(diffedData: any, path: any): void {\n  const amendment: any = {\n    path: path,\n    data: diffedData,\n  }\n  diffedAmendments.push(amendment)\n}\n\n// generates a file with a copy of the new amendement\nfunction generateSingleNewAmendment(newAmendment: {\n  path: Array<string>\n  data: any\n}) {\n  newAmendment.path.shift()\n\n  const shortDir: Array<any> = [...newAmendment.path]\n  shortDir.pop()\n  console.log(options.output + shortDir.join(\"/\"))\n  fs.mkdirSync(options.output + shortDir.join(\"/\"), {\n    recursive: true,\n  })\n  fs.writeFileSync(\n    options.output + newAmendment.path.join(\"/\").replace(/(\\.json)/, \".new$1\"),\n    JSON.stringify(newAmendment.data),\n    { encoding: \"utf8\", flag: \"w\" },\n  )\n}\n\n// generates a file with a copy of the modified data of the previously existing amendment;\nfunction generateSingleDiffedAmendment(diffedAmendment: {\n  path: Array<string>\n  data: any\n}) {\n  diffedAmendment.path.shift()\n\n  const shortDir: Array<any> = [...diffedAmendment.path]\n  shortDir.pop()\n  fs.mkdirSync(options.output + shortDir.join(\"/\"), {\n    recursive: true,\n  })\n\n  fs.writeFileSync(\n    options.output +\n      diffedAmendment.path.join(\"/\").replace(/(\\.json)/, \".diff$1\"),\n    JSON.stringify(diffedAmendment.data),\n    { encoding: \"utf8\", flag: \"w\" },\n  )\n}\n\ndiffAmendements(options.dataDir)\n"],"mappings":"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"}