@tricoteuses/assemblee 1.0.0-next.2 → 1.0.2

package/lib/scripts/bugs_helper.mjs

@@ -0,0 +1,286 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import fs from "fs-extra";
+import commandLineArgs from "command-line-args";
+import commandLineUsage from "command-line-usage";
+import { load, getFiles, GetFileNotFoundError } from "../file_systems.mjs";
+import { SchemaBugs } from "../../src/bugs/index.mjs";
+import * as git from "../../src/git.mjs";
+import { validDataset, getDatasets, getSchemas, datasetDirectorySchema, diffUpstream, masterUrl } from "../../src/datasets.mjs";
+
+function parseArgs(argv) {
+  const optionsDefinitions = [{
+    description: "pathname to the directory containing the dataset",
+    defaultOption: true,
+    name: "data",
+    type: String
+  }, {
+    description: "pathname to the directory containing the HTML comptes rendus de seance",
+    name: "cr",
+    type: String
+  }, {
+    description: "pathname to the directory to commit",
+    name: "commit",
+    type: String
+  }, {
+    description: "only consider this bug",
+    name: "bug",
+    type: String
+  }, {
+    description: "pathname to the directory where the check outputs will be stored",
+    name: "output",
+    type: String
+  }, {
+    description: `dataset (possible values must include exactly one of ${getDatasets()})`,
+    name: "dataset",
+    type: String
+  }, {
+    description: `schema (possible values are ${getSchemas()})`,
+    name: "schema",
+    type: String
+  }, {
+    description: "directory in which bugs are found (default .)",
+    name: "bugs-dir",
+    type: String
+  }, {
+    description: "increase verbosity",
+    name: "verbose",
+    type: Boolean
+  }, {
+    description: "debug information",
+    name: "debug",
+    type: Boolean
+  }, {
+    description: "check",
+    name: "check",
+    type: Boolean
+  }, {
+    description: "fix",
+    name: "fix",
+    type: Boolean
+  }, {
+    name: "help",
+    description: "Print this usage guide."
+  }];
+  const sections = [{
+    header: "Cross check data consistency and fix problems",
+    content: ""
+  }, {
+    header: "Options",
+    optionList: optionsDefinitions
+  }];
+  const options = commandLineArgs(optionsDefinitions, {
+    argv: argv
+  });
+
+  if (options.dataset) {
+    if (!validDataset(options.dataset)) {
+      console.error(`--dataset ${options.dataset}`);
+      options.help = true;
+    }
+  }
+
+  if (options.schema) {
+    if (!getSchemas().includes(options.schema)) {
+      console.error(`--schema ${options.schema}`);
+      options.help = true;
+    }
+  }
+
+  if (options.commit) {
+    if (!fs.existsSync(options.commit)) {
+      console.error(`${options.commit} does not exist`);
+      options.help = true;
+    }
+  }
+
+  if (options.debug) options.verbose = true;
+
+  if ("help" in options) {
+    const usage = commandLineUsage(sections);
+    console.warn(usage);
+    return null;
+  }
+
+  return options;
+}
+
+export class BugsHelper {
+  constructor(options) {
+    _defineProperty(this, "options", void 0);
+
+    _defineProperty(this, "bugs", void 0);
+
+    this.options = options;
+    this.bugs = new SchemaBugs(this.options);
+  }
+
+  async check() {
+    const analysis = {};
+    await this.bugs.preCheck();
+    if (this.options.verbose) console.log(`check ${this.options.data}`);
+
+    for (const file of getFiles([this.options.data])) {
+      const content = load(file);
+      analysis[file] = await this.bugs.check(content, file);
+    }
+
+    await this.bugs.postCheck(analysis);
+    await this.show(analysis);
+    if (this.options.output) await this.store(analysis);
+    return 0;
+  }
+
+  async show(analysis) {
+    for (const filename of Object.keys(analysis)) {
+      const bug = analysis[filename];
+
+      for (const name of Object.keys(bug)) {
+        const result = bug[name];
+
+        if (result != null) {
+          let log;
+
+          if (result["status"] == "needs-fixing") {
+            log = console.error;
+          } else if (this.options.verbose) {
+            log = console.log;
+          }
+
+          if (log != undefined) {
+            log(`${name} finds ${filename} ${result["status"]}`);
+            log(result["info"].join("\n"));
+          }
+        }
+      }
+    }
+  }
+
+  async store(analysis) {
+    const name2reports = {};
+
+    for (const filename of Object.keys(analysis)) {
+      const bug = analysis[filename];
+
+      for (const name of Object.keys(bug)) {
+        if (!(name in name2reports)) name2reports[name] = {};
+        name2reports[name][filename] = bug[name];
+      }
+    }
+
+    for (const name of Object.keys(name2reports)) {
+      const reports = name2reports[name];
+      const n = name.split("-")[1];
+      let lines = [`## Bug [${name}](https://git.en-root.org/tricoteuses/tricoteuses-assemblee-qa/issues/${Number(n)})`, `This report was created by the **check** function of [${name}](https://git.en-root.org/tricoteuses/tricoteuses-assemblee/-/blob/master/src/bugs/${name}.ts).`];
+      const status2lines = {
+        "needs-fixing": [],
+        "will-be-fixed": [],
+        "already-fixed": []
+      };
+
+      for (const filename of Object.keys(reports)) {
+        const report = reports[filename];
+        if (report == null || report["status"] == "ok") continue;
+        if (!(report["status"] in status2lines)) console.error(`${filename} status ${report["status"]} unknown`);
+        const status = report["status"];
+        let l = status2lines[status];
+        if (status == "will-be-fixed") l.push(`* ${diffUpstream(filename)}`);else l.push(`* ${masterUrl(filename)}`);
+
+        for (const info of report["info"]) l.push(`  * ${info}`);
+      }
+
+      for (const [status, label] of [["needs-fixing", "The following files must be fixed"], ["already-fixed", "The following files no longer need a fix"], ["will-be-fixed", "The following files have been successfully fixed"]]) {
+        lines.push(`### ${label}`);
+        lines = lines.concat(status2lines[status]);
+      }
+
+      const output = `${this.options.output}/${name}.md`;
+      fs.writeFileSync(output, lines.join("\n"), {
+        encoding: "utf8"
+      });
+    }
+  }
+
+  async fix() {
+    await this.bugs.preFix();
+    await this.bugs.fix(getFiles([this.options.data]));
+    return 0;
+  }
+
+  async main() {
+    if (this.options.check) return this.check();else return this.fix();
+  }
+
+}
+export async function checkoutFix(options) {
+  const c = options.commit;
+  if (c == undefined) return;
+  const v = options.verbose;
+  git.run(c, "checkout --quiet master", v);
+  if (/tmp/.test(git.run(c, "branch", v))) git.run(c, "branch -D tmp", v);
+  git.run(c, "checkout --quiet -b tmp master", v);
+  if (/Merge bugfixes/.test(git.run(c, "log --oneline -1", v))) git.run(c, "revert --mainline 1 --no-edit HEAD", v);
+  git.run(c, "merge --no-ff -m 'Merge upstream' upstream/uid", v);
+  if (/bugfixes/.test(git.run(c, "branch", v))) git.run(c, "branch -D bugfixes", v);
+  git.run(c, "checkout --quiet -b bugfixes", v);
+}
+export async function mergeFix(options) {
+  const c = options.commit;
+  if (c == undefined) return;
+  const v = options.verbose;
+  git.run(c, "checkout --quiet tmp", v);
+  git.run(c, "merge --no-ff -m 'Merge bugfixes' bugfixes", v);
+  git.run(c, "branch -D bugfixes", v);
+  git.run(c, "checkout --quiet master", v);
+  if (!git.test(c, "diff --quiet tmp master", v)) git.run(c, "merge --ff-only tmp", v);
+  git.run(c, "branch -D tmp", v);
+}
+export async function main(argv) {
+  const options = parseArgs(argv);
+  if (options === null) return 1;
+  let directorySchema = [];
+
+  if (options.schema) {
+    directorySchema = [[options.data, options.schema]];
+  } else if (options.dataset) {
+    directorySchema = datasetDirectorySchema(options.dataset);
+  } else {
+    console.error("either --schema or --dataset is required");
+    return 1;
+  }
+
+  await checkoutFix(options);
+
+  for (const d of directorySchema) {
+    options.schema = d[1];
+    options.data = d[0];
+    if (options.debug) console.log(`working on ${options.data} with schema ${options.schema}`);
+    let helper;
+
+    try {
+      helper = new BugsHelper(options);
+    } catch (e) {
+      if (!(e instanceof GetFileNotFoundError)) {
+        throw e;
+      }
+
+      continue;
+    }
+
+    if (options.verbose) console.log(`working on files ${options.data} with schema ${options.schema}`);
+    const status = await helper.main();
+    if (status != 0) return status;
+  }
+
+  await mergeFix(options);
+  return 0;
+}
+/* istanbul ignore if */
+
+if (process.argv[1].endsWith("bugs_helper.ts")) main(process.argv).then(status => {
+  process.exit(status);
+}).catch(error => {
+  console.error(error);
+  process.exit(1);
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","commandLineArgs","commandLineUsage","load","getFiles","GetFileNotFoundError","SchemaBugs","git","validDataset","getDatasets","getSchemas","datasetDirectorySchema","diffUpstream","masterUrl","parseArgs","argv","optionsDefinitions","description","defaultOption","name","type","String","Boolean","sections","header","content","optionList","options","dataset","console","error","help","schema","includes","commit","existsSync","debug","verbose","usage","warn","BugsHelper","constructor","bugs","check","analysis","preCheck","log","data","file","postCheck","show","output","store","filename","Object","keys","bug","result","undefined","join","name2reports","reports","n","split","lines","Number","status2lines","report","status","l","push","info","label","concat","writeFileSync","encoding","fix","preFix","main","checkoutFix","c","v","run","test","mergeFix","directorySchema","d","helper","e","process","endsWith","then","exit","catch"],"sources":["../../src/scripts/bugs_helper.ts"],"sourcesContent":["import fs from \"fs-extra\"\nimport commandLineArgs from \"command-line-args\"\nimport commandLineUsage from \"command-line-usage\"\nimport { load, getFiles, GetFileNotFoundError } from \"../file_systems\"\nimport { SchemaBugs } from \"../../src/bugs\"\nimport * as git from \"../../src/git\"\nimport {\n  validDataset,\n  getDatasets,\n  getSchemas,\n  datasetDirectorySchema,\n  diffUpstream,\n  masterUrl,\n} from \"../../src/datasets\"\n\nfunction parseArgs(argv: string[]): any {\n  const optionsDefinitions = [\n    {\n      description: \"pathname to the directory containing the dataset\",\n      defaultOption: true,\n      name: \"data\",\n      type: String,\n    },\n    {\n      description:\n        \"pathname to the directory containing the HTML comptes rendus de seance\",\n      name: \"cr\",\n      type: String,\n    },\n    {\n      description: \"pathname to the directory to commit\",\n      name: \"commit\",\n      type: String,\n    },\n    {\n      description: \"only consider this bug\",\n      name: \"bug\",\n      type: String,\n    },\n    {\n      description:\n        \"pathname to the directory where the check outputs will be stored\",\n      name: \"output\",\n      type: String,\n    },\n    {\n      description: `dataset (possible values must include exactly one of ${getDatasets()})`,\n      name: \"dataset\",\n      type: String,\n    },\n    {\n      description: `schema (possible values are ${getSchemas()})`,\n      name: \"schema\",\n      type: String,\n    },\n    {\n      description: \"directory in which bugs are found (default .)\",\n      name: \"bugs-dir\",\n      type: String,\n    },\n    {\n      description: \"increase verbosity\",\n      name: \"verbose\",\n      type: Boolean,\n    },\n    {\n      description: \"debug information\",\n      name: \"debug\",\n      type: Boolean,\n    },\n    {\n      description: \"check\",\n      name: \"check\",\n      type: Boolean,\n    },\n    {\n      description: \"fix\",\n      name: \"fix\",\n      type: Boolean,\n    },\n    {\n      name: \"help\",\n      description: \"Print this usage guide.\",\n    },\n  ]\n  const sections = [\n    {\n      header: \"Cross check data consistency and fix problems\",\n      content: \"\",\n    },\n    {\n      header: \"Options\",\n      optionList: optionsDefinitions,\n    },\n  ]\n  const options = commandLineArgs(optionsDefinitions, {\n    argv: argv,\n  })\n\n  if (options.dataset) {\n    if (!validDataset(options.dataset)) {\n      console.error(`--dataset ${options.dataset}`)\n      options.help = true\n    }\n  }\n\n  if (options.schema) {\n    if (!getSchemas().includes(options.schema)) {\n      console.error(`--schema ${options.schema}`)\n      options.help = true\n    }\n  }\n\n  if (options.commit) {\n    if (!fs.existsSync(options.commit)) {\n      console.error(`${options.commit} does not exist`)\n      options.help = true\n    }\n  }\n\n  if (options.debug) options.verbose = true\n\n  if (\"help\" in options) {\n    const usage = commandLineUsage(sections)\n    console.warn(usage)\n    return null\n  }\n  return options\n}\n\nexport class BugsHelper {\n  options: any\n  bugs: any\n\n  constructor(options: any) {\n    this.options = options\n    this.bugs = new SchemaBugs(this.options)\n  }\n\n  async check(): Promise<number> {\n    const analysis: any = {}\n    await this.bugs.preCheck()\n    if (this.options.verbose) console.log(`check ${this.options.data}`)\n    for (const file of getFiles([this.options.data])) {\n      const content = load(file)\n      analysis[file] = await this.bugs.check(content, file)\n    }\n    await this.bugs.postCheck(analysis)\n    await this.show(analysis)\n    if (this.options.output) await this.store(analysis)\n    return 0\n  }\n\n  async show(analysis: any): Promise<void> {\n    for (const filename of Object.keys(analysis)) {\n      const bug = analysis[filename]\n      for (const name of Object.keys(bug)) {\n        const result = bug[name]\n        if (result != null) {\n          let log\n          if (result[\"status\"] == \"needs-fixing\") {\n            log = console.error\n          } else if (this.options.verbose) {\n            log = console.log\n          }\n          if (log != undefined) {\n            log(`${name} finds ${filename} ${result[\"status\"]}`)\n            log(result[\"info\"].join(\"\\n\"))\n          }\n        }\n      }\n    }\n  }\n\n  async store(analysis: any): Promise<void> {\n    const name2reports: any = {}\n    for (const filename of Object.keys(analysis)) {\n      const bug = analysis[filename]\n      for (const name of Object.keys(bug)) {\n        if (!(name in name2reports)) name2reports[name] = {}\n        name2reports[name][filename] = bug[name]\n      }\n    }\n    for (const name of Object.keys(name2reports)) {\n      const reports = name2reports[name]\n      const n = name.split(\"-\")[1]\n      let lines: any = [\n        `## Bug [${name}](https://git.en-root.org/tricoteuses/tricoteuses-assemblee-qa/issues/${Number(\n          n,\n        )})`,\n        `This report was created by the **check** function of [${name}](https://git.en-root.org/tricoteuses/tricoteuses-assemblee/-/blob/master/src/bugs/${name}.ts).`,\n      ]\n      const status2lines: any = {\n        \"needs-fixing\": [],\n        \"will-be-fixed\": [],\n        \"already-fixed\": [],\n      }\n      for (const filename of Object.keys(reports)) {\n        const report = reports[filename]\n        if (report == null || report[\"status\"] == \"ok\") continue\n        if (!(report[\"status\"] in status2lines))\n          console.error(`${filename} status ${report[\"status\"]} unknown`)\n        const status = report[\"status\"]\n        let l = status2lines[status]\n        if (status == \"will-be-fixed\") l.push(`* ${diffUpstream(filename)}`)\n        else l.push(`* ${masterUrl(filename)}`)\n        for (const info of report[\"info\"]) l.push(`  * ${info}`)\n      }\n      for (const [status, label] of [\n        [\"needs-fixing\", \"The following files must be fixed\"],\n        [\"already-fixed\", \"The following files no longer need a fix\"],\n        [\"will-be-fixed\", \"The following files have been successfully fixed\"],\n      ]) {\n        lines.push(`### ${label}`)\n        lines = lines.concat(status2lines[status])\n      }\n      const output = `${this.options.output}/${name}.md`\n      fs.writeFileSync(output, lines.join(\"\\n\"), {\n        encoding: \"utf8\",\n      })\n    }\n  }\n\n  async fix(): Promise<number> {\n    await this.bugs.preFix()\n    await this.bugs.fix(getFiles([this.options.data]))\n    return 0\n  }\n\n  async main(): Promise<number> {\n    if (this.options.check) return this.check()\n    else return this.fix()\n  }\n}\n\nexport async function checkoutFix(options: any): Promise<void> {\n  const c = options.commit\n  if (c == undefined) return\n  const v = options.verbose\n  git.run(c, \"checkout --quiet master\", v)\n  if (/tmp/.test(git.run(c, \"branch\", v))) git.run(c, \"branch -D tmp\", v)\n  git.run(c, \"checkout --quiet -b tmp master\", v)\n  if (/Merge bugfixes/.test(git.run(c, \"log --oneline -1\", v)))\n    git.run(c, \"revert --mainline 1 --no-edit HEAD\", v)\n  git.run(c, \"merge --no-ff -m 'Merge upstream' upstream/uid\", v)\n  if (/bugfixes/.test(git.run(c, \"branch\", v)))\n    git.run(c, \"branch -D bugfixes\", v)\n  git.run(c, \"checkout --quiet -b bugfixes\", v)\n}\n\nexport async function mergeFix(options: any): Promise<void> {\n  const c = options.commit\n  if (c == undefined) return\n  const v = options.verbose\n  git.run(c, \"checkout --quiet tmp\", v)\n  git.run(c, \"merge --no-ff -m 'Merge bugfixes' bugfixes\", v)\n  git.run(c, \"branch -D bugfixes\", v)\n  git.run(c, \"checkout --quiet master\", v)\n  if (!git.test(c, \"diff --quiet tmp master\", v))\n    git.run(c, \"merge --ff-only tmp\", v)\n  git.run(c, \"branch -D tmp\", v)\n}\n\nexport async function main(argv: any): Promise<number> {\n  const options = parseArgs(argv)\n  if (options === null) return 1\n  let directorySchema = []\n  if (options.schema) {\n    directorySchema = [[options.data, options.schema]]\n  } else if (options.dataset) {\n    directorySchema = datasetDirectorySchema(options.dataset)\n  } else {\n    console.error(\"either --schema or --dataset is required\")\n    return 1\n  }\n  await checkoutFix(options)\n  for (const d of directorySchema) {\n    options.schema = d[1]\n    options.data = d[0]\n    if (options.debug)\n      console.log(`working on ${options.data} with schema ${options.schema}`)\n    let helper\n    try {\n      helper = new BugsHelper(options)\n    } catch (e) {\n      if (!(e instanceof GetFileNotFoundError)) {\n        throw e\n      }\n      continue\n    }\n    if (options.verbose)\n      console.log(\n        `working on files ${options.data} with schema ${options.schema}`,\n      )\n    const status = await helper.main()\n    if (status != 0) return status\n  }\n  await mergeFix(options)\n  return 0\n}\n\n/* istanbul ignore if */\nif (process.argv[1].endsWith(\"bugs_helper.ts\"))\n  main(process.argv)\n    .then((status) => {\n      process.exit(status)\n    })\n    .catch((error) => {\n      console.error(error)\n      process.exit(1)\n    })\n"],"mappings":"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"}