@baravak/risloo-profile-cli 3.1.0

package/src/cli-commands/ExtractExecutor.js

@@ -0,0 +1,194 @@
+const path = require("path");
+const chokidar = require("chokidar");
+const Executor = require("./Executor");
+const { checkAndImport, checkAndLoad } = require("./utilities/BaseOps");
+const { EXTRACT_STATUS } = require("./utilities/STATUSES");
+const { FileNotFoundError } = require("./utilities/CustomErrors");
+
+class ExtractExecutor extends Executor {
+  samplesJSDir = path.join(__dirname, "..", "samples");
+  profilesTemplatesDir = path.join(__dirname, "..", "..", "views", "profiles", "samples");
+
+  constructor(options) {
+    super(options);
+    this.sample = {
+      name: options.sampleName,
+      outputs: options.sampleOutputs,
+    };
+
+    this.dirs = {};
+
+    this._addJSPromise();
+    this._initSettings(options);
+
+    this._extract();
+
+    if (options.watch) this._watch();
+  }
+
+  _addJSPromise() {
+    const { sample, dirs, samplesJSDir, response, promises } = this;
+
+    const sampleJSDir = path.join(samplesJSDir, `${sample.name}.js`);
+
+    dirs["sampleJS"] = sampleJSDir;
+
+    promises["js"] = checkAndImport(sampleJSDir).catch((err) => {
+      if (err instanceof FileNotFoundError) response.setStatus(EXTRACT_STATUS["INVALID_SAMPLE_NAME"], err);
+      else response.setStatus(EXTRACT_STATUS["GENERAL_ERROR"], err);
+    });
+  }
+
+  _addProfilesTemplatePromises() {
+    const { sample, dirs, profilesTemplatesDir, promises, response } = this;
+
+    promises["templates"] = [];
+
+    dirs["templates"] = [];
+
+    promises["miscellaneous_1"] = promises["js"].then((Profile) => {
+      let n = Profile.pages;
+      for (let i = 0; i < n; i++) {
+        let templateFileDir = path.join(profilesTemplatesDir, `${sample.name}${n !== 1 ? "_" + (i + 1) : ""}.hbs`);
+        dirs["templates"].push(templateFileDir);
+        promises["templates"].push(
+          checkAndLoad(templateFileDir).catch((err) => response.setStatus(EXTRACT_STATUS["TEMPLATE_NOT_FOUND"], err))
+        );
+      }
+      return Promise.all(promises.templates);
+    });
+  }
+
+  _initSettings(options) {
+    const { sample } = this;
+
+    let settings = {};
+
+    if (sample.outputs.includes("profile")) {
+      let variants = {
+        both: ["raw", "with-sidebar"],
+        raw: ["raw"],
+        "with-sidebar": ["with-sidebar"],
+      }[options.profileVariant];
+
+      settings["profile"] = {
+        measure: options.measure,
+        variants,
+        name: options.name,
+      };
+
+      this._addProfilesTemplatePromises();
+    }
+
+    this.settings = settings;
+  }
+
+  _extract() {
+    const { sample, promises, response, benchmarker, settings } = this;
+
+    const extractPromises = [];
+
+    if (sample.outputs.includes("profile")) {
+      let { variants } = settings["profile"];
+
+      extractPromises.push(Promise.all(variants.map((variant) => this._createProfile(variant))));
+    }
+
+    if (sample.outputs.includes("report")) extractPromises.push(this._createReport(options));
+
+    if (sample.outputs.includes("sheet")) extractPromises.push(this._createSheet(options));
+
+    promises["extract"] = Promise.all(extractPromises).then(() => {
+      benchmarker?.end();
+      response.setTime(benchmarker?.totalTime);
+      response.setStatus(EXTRACT_STATUS["SUCCESS"]);
+    });
+  }
+
+  async _createProfile(variant, exts = ["svg", "png"]) {
+    const {
+      promises,
+      response,
+      settings: {
+        profile: { measure },
+      },
+    } = this;
+
+    const outputFileName = this._createProfileOutputName(variant);
+
+    return Promise.all([promises.input, promises.js])
+      .then(([dataset, Profile]) => new Profile(dataset, { variant, measure }).getTemplateEngineParams())
+      .catch((err) => response.setStatus(EXTRACT_STATUS["JS_ERROR"], err))
+      .then((contexts) => this._renderAndCreateOutputs(contexts, promises.templates, outputFileName, exts))
+      .then((pages) => pages.map((dirs) => dirs.map((dir) => response.addOutput(dir, "profiles"))));
+  }
+
+  _watch() {
+    const { command, dirs, input, response, benchmarker, promises } = this;
+
+    const opts = {
+      awaitWriteFinish: {
+        stabilityThreshold: 500,
+        pollInterval: 100,
+      },
+    };
+
+    promises["js"].then(() => {
+      dirs.templates.map((templateFileDir, index) => {
+        chokidar.watch(templateFileDir, opts).on("change", () => {
+          promises["templates"][index] = checkAndLoad(templateFileDir);
+          benchmarker?.restart(command);
+          this._createProfile("with-sidebar", ["svg"]).then(() => {
+            benchmarker?.end();
+            response.setTime(benchmarker?.totalTime);
+            response.showOutput();
+          });
+        });
+      });
+    });
+
+    chokidar.watch(dirs.sampleJS, opts).on("change", () => {
+      promises["js"] = checkAndImport(dirs.sampleJS);
+      benchmarker?.restart(command);
+      this._createProfile("with-sidebar", ["svg"]).then(() => {
+        benchmarker?.end();
+        response.setTime(benchmarker?.totalTime);
+        response.showOutput();
+      });
+    });
+    
+    if(input.type === 'local') chokidar.watch(input.data, opts).on('change', () => {
+      promises["input"] = checkAndLoad(input.data).then((json) => Promise.resolve(JSON.parse(json)));
+      benchmarker?.restart(command);
+      this._createProfile("with-sidebar", ["svg"]).then(() => {
+        benchmarker?.end();
+        response.setTime(benchmarker?.totalTime);
+        response.showOutput();
+      });
+
+    })
+  }
+
+  _createProfileOutputName(variant) {
+    const {
+      settings: {
+        profile: { measure, name },
+      },
+      input,
+    } = this;
+
+    let variantSuffix = {
+      raw: ".raw",
+      "with-sidebar": "",
+    }[variant];
+    let measureSuffix = measure ? "-m" : "";
+
+    const fileName = input.type === "local" ? path.parse(input.data).name : "";
+
+    if (!(name || fileName)) throw new Error("No Name Provided for Profile Output Files!");
+
+    return `${name || fileName}${variantSuffix}${measureSuffix}`;
+  }
+}
+
+module.exports = ExtractExecutor;

package/src/cli-commands/GiftExecutor.js

@@ -0,0 +1,56 @@
+const fs = require("fs/promises");
+const path = require("path");
+const Executor = require("./Executor");
+const { GIFT_STATUS } = require("./utilities/STATUSES");
+const Gift = require("../Gift");
+const { loadStdin } = require("./utilities/BaseOps");
+
+class GiftExecutor extends Executor {
+  giftTemplateFile = path.join(__dirname, "..", "..", "views", "gift.hbs");
+
+  constructor(options) {
+    super(options);
+
+    this._addTemplatePromise();
+    this._addAvatarPromise();
+
+    this._gift();
+  }
+
+  _addTemplatePromise() {
+    const { promises, giftTemplateFile } = this;
+
+    promises["template"] = fs.readFile(giftTemplateFile);
+  }
+
+  _addAvatarPromise() {
+    const { promises } = this;
+
+    promises["avatar"] = loadStdin("binary");
+  }
+
+  _gift() {
+    const { promises, response, benchmarker } = this;
+
+    response.addBranch("gifts");
+
+    promises["gift"] = this._createGift().then(() => {
+      if (benchmarker) {
+        benchmarker.end();
+        response.setTime(benchmarker.totalTime);
+      }
+      response.setStatus(GIFT_STATUS["SUCCESS"]);
+    });
+  }
+
+  async _createGift() {
+    const { promises, response } = this;
+
+    return Promise.all([promises.input, promises.avatar])
+      .then(([dataset, avatar]) => new Gift(dataset, avatar))
+      .then((ctx) => this._renderAndCreateOutput(ctx, promises.template, ctx.name, ["png"]))
+      .then((dirs) => dirs.map((dir) => response.addOutput(dir, "gifts")));
+  }
+}
+
+module.exports = GiftExecutor;

package/src/cli-commands/utilities/BaseOps.js

@@ -0,0 +1,71 @@
+const { FileNotFoundError } = require("./CustomErrors");
+const fs = require("fs/promises");
+const { writeFile, constants } = require("fs");
+const sharp = require("sharp");
+
+const checkAndLoad = async (dir) =>
+  fs
+    .access(dir, constants.F_OK)
+    .catch(() => {
+      throw new FileNotFoundError(dir);
+    })
+    .then(() => fs.readFile(dir));
+
+function requireUncached(dir) {
+  delete require.cache[require.resolve(dir)];
+  return require(dir);
+}
+
+const checkAndImport = async (dir) =>
+  fs
+    .access(dir, constants.F_OK)
+    .catch(() => {
+      throw new FileNotFoundError(dir);
+    })
+    .then(() => requireUncached(dir));
+
+const loadStdin = async (encoding) => {
+  process.stdin.setEncoding(encoding);
+
+  let data = "";
+
+  if (!process.stdin.isTTY) process.stdin.on("data", (chunk) => (data += chunk));
+
+  return new Promise(function (resolve, reject) {
+    if (!process.stdin.readableFlowing) resolve(data);
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", (err) => reject(err));
+  });
+};
+
+const ensureDirExistence = async (dir) =>
+  fs.access(dir, constants.F_OK).catch(() => fs.mkdir(dir, { recursive: true }));
+
+async function createSVG(xml, dir) {
+  return new Promise((resolve, reject) => {
+    writeFile(dir, xml, (err) => {
+      if (err) reject(err);
+      resolve(dir);
+    });
+  });
+}
+
+async function createPNG(xml, dir) {
+  xml = xml.replace(/<style.*?>.*?<\/style>/s, "");
+  const buf = Buffer.from(xml, "utf8");
+  return new Promise((resolve, reject) => {
+    sharp(buf, { density: 100 }).toFile(dir, (err) => {
+      if (err) return reject(err);
+      resolve(dir);
+    });
+  });
+}
+
+module.exports = {
+  checkAndLoad,
+  checkAndImport,
+  loadStdin,
+  ensureDirExistence,
+  createSVG,
+  createPNG,
+};

package/src/cli-commands/utilities/Benchmarker.js

@@ -0,0 +1,88 @@
+const chalk = require("chalk");
+
+class Benchmarker {
+  constructor() {
+    this.depth = 0;
+    this.branches = [];
+    // this.branches = [{ name, timeSteps: [], currentStep: 0 }];
+  }
+
+  start(name) {
+    const newBranch = {
+      name,
+      timeSteps: [],
+      currentStep: 0,
+      depth: this.depth++,
+    };
+    newBranch.timeSteps.push(Date.now());
+    this.branches.push(newBranch);
+
+    // console.log(
+    //   chalk`${"".padStart(newBranch.depth * 2)}{magenta.bold ${
+    //     newBranch.name
+    //   }}${newBranch.depth ? "" : " Benchmarking"} Started!`
+    // );
+  }
+
+  addStep(stepName) {
+    const { branches, depth } = this;
+
+    let lastBranch = branches[depth - 1];
+    lastBranch.timeSteps.push(Date.now());
+    lastBranch.currentStep++;
+
+    const time =
+      (lastBranch.timeSteps[lastBranch.currentStep] - lastBranch.timeSteps[lastBranch.currentStep - 1]) / 1000;
+    const timeColor = this._timeColor(time);
+
+    // console.log(
+    //   chalk`${"".padStart(lastBranch.depth * 2 + 2)}{italic Step #${
+    //     lastBranch.currentStep
+    //   }:} {blue.bold ${stepName}}: {${timeColor}.bold ${time}} Seconds.`.padStart(
+    //     lastBranch.depth * 2,
+    //     " "
+    //   )
+    // );
+  }
+
+  end() {
+    const { branches } = this;
+
+    this.depth--;
+
+    let lastBranch = branches.pop();
+    const totalTime = (Date.now() - lastBranch.timeSteps[0]) / 1000;
+    const timeColor = this._timeColor(totalTime);
+
+    this.totalTime = totalTime;
+
+    // console.log(
+    //   chalk`${"".padStart(lastBranch.depth * 2)}{magenta.bold ${
+    //     lastBranch.name
+    //   }}${
+    //     lastBranch.depth ? "" : " Benchmarking"
+    //   } Completed. Total Time: {${timeColor}.bgGrey.bold  ${totalTime} } Seconds`
+    // );
+  }
+
+  restart(name) {
+    this.depth = 0;
+    this.branches = [];
+    this.start(name)
+  }
+
+  _timeColor(time) {
+    // time <= 0.4s ==> Good
+    // 0.4s < time <= 1s ==> Medium
+    // 1s < time ==> Bad
+
+    const interpret = time <= 0.4 ? "Good" : time <= 1 ? "Medium" : "Bad";
+    return {
+      Good: "green",
+      Medium: "yellow",
+      Bad: "red",
+    }[interpret];
+  }
+}
+
+module.exports = Benchmarker;

package/src/cli-commands/utilities/CustomErrors.js

@@ -0,0 +1,14 @@
+class MyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+}
+
+class FileNotFoundError extends MyError {
+  constructor(dir) {
+    super(`File Not Found in ${dir}`);
+  }
+}
+
+module.exports = { MyError, FileNotFoundError };

package/src/cli-commands/utilities/Response.js

@@ -0,0 +1,59 @@
+const path = require("path");
+
+class Response {
+  constructor() {
+    this.files = {};
+  }
+
+  addBranch(name) {
+    this.files[name] = {};
+  }
+
+  addOutput(dir, branch) {
+    const base = path.parse(dir).base.split(".").slice(1);
+    let ext = base.pop();
+    let name = base.join(".") || "_";
+
+    if (!this.files[branch]) this.addBranch(branch)
+
+    this.files[branch][name] = [...(this.files[branch][name] || []), ext];
+  }
+
+  setStatus({ code, label, message }, err = null) {
+    if (!this.status) {
+      this.status = {
+        code,
+        label,
+        message,
+      };
+    }
+    process.exitCode = code;
+
+    if (err) throw err;
+  }
+
+  setTime(time) {
+    if (!this.time) this.time = time;
+  }
+
+  showOutput() {
+    const { files, status, time } = this;
+    const output = {
+      ...files,
+      message_code: status && status.code,
+      message: status && `(${status.label}) ${status.message}`,
+      time,
+    };
+
+    console.log(JSON.stringify(output));
+    this._clear();
+  }
+
+  _clear() {
+    this.files = {};
+    this.status = null;
+    this.time = null;
+  }
+}
+
+module.exports = Response;

package/src/cli-commands/utilities/STATUSES.js

@@ -0,0 +1,16 @@
+const Status = require("./Status");
+
+const EXTRACT_STATUS = {
+  SUCCESS: new Status(0, "Success", "Outputs Successfully Extracted!"),
+  "INPUT_NOT_FOUND": new Status(1, "Not Found", "Input Data File Does Not Exist!"),
+  "JS_ERROR": new Status(2, "Profile JS Error", "Error in Instantiating the Profile Object"),
+  "INVALID_SAMPLE_NAME": new Status(3, "Invalid Name", "Sample Name Is Not Valid"),
+  "TEMPLATE_NOT_FOUND": new Status(4, "Not Found", "Profile Template File Does Not Exist"),
+  "GENERAL_ERROR": new Status(5, "General Error", "Something Went Wrong!"),
+};
+
+const GIFT_STATUS = {
+  SUCCESS: new Status(0, "Success", "Gift Successfully Created!"),
+};
+
+module.exports = { EXTRACT_STATUS, GIFT_STATUS };

package/src/cli-commands/utilities/Status.js

@@ -0,0 +1,9 @@
+class Status {
+  constructor(code, label, message) {
+    this.code = code;
+    this.label = label;
+    this.message = message;
+  }
+}
+
+module.exports = Status;

package/src/cli.js

@@ -0,0 +1,125 @@
+const { Argument, Command, Option } = require("commander");
+
+const program = new Command();
+
+function parseArgumentsIntoOptions(rawArgs) {
+  let output = {};
+
+  program
+    .command("extract")
+    .alias("E")
+    .argument("<sampleName>", "sample name")
+    .addArgument(
+      new Argument("[sampleOutputs...]", "sample outputs").choices(["profile", "report", "sheet"]).default(["profile"])
+    )
+    .description("Extract outputs of a sample")
+    .addOption(
+      new Option("-p, --profile-variant <variant>", "profile variant")
+        .choices(["both", "raw", "with-sidebar"])
+        .default("both")
+        .makeOptionMandatory()
+    )
+    .addOption(
+      new Option("-i, --input-type <type>", "input type")
+        .choices(["local", "remote", "raw-json", "stdin"])
+        .default("local")
+        .makeOptionMandatory()
+    )
+
+    .addOption(new Option("-d, --input-data <data>", "input data"))
+
+    .addOption(
+      new Option("-o, --output-type <type>", "output type")
+        .choices(["local", "remote"])
+        .default("local")
+        .makeOptionMandatory()
+    )
+
+    .addOption(new Option("-a, --output-address <address>", "output address").makeOptionMandatory())
+
+    .addOption(new Option("-m, --measure", "measure feature in SVG").default(false))
+
+    .addOption(new Option("-n, --name <name>", "name of output profile"))
+
+    .addOption(new Option("-b, --benchmark", "time benchmarking").default(false))
+
+    .addOption(new Option("-w, --watch", "watch files").default(false))
+
+    .action((sampleName, sampleOutputs, options, command) => {
+      output = {
+        command: command.name(),
+        sampleName,
+        sampleOutputs,
+        ...options,
+      };
+    });
+
+  program
+    .command("test")
+    .alias("T")
+    .description("Test Commands of CLI")
+    .addOption(
+      new Option("-c, --command-test <name>", "command name to be tested").choices(["extract"]).makeOptionMandatory()
+    )
+    .action((options, command) => {
+      output = {
+        command: command.name(),
+        ...options,
+      };
+    });
+
+  program
+    .command("gift")
+    .alias("G")
+    .description("Create Gift Card")
+    .addOption(
+      new Option("-i, --input-type <type>", "input type")
+        .choices(["raw-json", "local"])
+        .default("raw-json")
+        .makeOptionMandatory()
+    )
+    .addOption(new Option("-d, --input-data <data>", "input data"))
+    .addOption(
+      new Option("-o, --output-type <type>", "output type")
+        .choices(["local", "remote"])
+        .default("local")
+        .makeOptionMandatory()
+    )
+    .addOption(new Option("-a, --output-address <address>", "output address").makeOptionMandatory())
+    .addOption(new Option("-b, --benchmark", "time benchmarking").default(false))
+    .action((options, command) => {
+      output = {
+        command: command.name(),
+        ...options,
+      };
+    });
+
+  program.showHelpAfterError();
+
+  program.showSuggestionAfterError();
+
+  program.parse(rawArgs);
+
+  return output;
+}
+
+async function cli(args) {
+  let options = parseArgumentsIntoOptions(args);
+
+  switch (options.command) {
+    case "extract":
+      const ExtractExecutor = require("./cli-commands/ExtractExecutor");
+      return new ExtractExecutor(options).getFinalPromise();
+    case "gift":
+      const GiftExecutor = require("./cli-commands/GiftExecutor");
+      return new GiftExecutor(options).getFinalPromise();
+    case "test":
+      const test = require("./cli-commands/test");
+      test(options)
+        .then(() => console.log("0 (Success): Draw Command Tested Completely!"))
+        .catch((err) => console.error(err));
+      break;
+  }
+}
+
+module.exports = { cli };

package/src/handlebars/helpers/abs.js

@@ -0,0 +1,8 @@
+// abs Helper
+// Get Absolute Value of a Number
+
+function abs(num) {
+  return Math.abs(num);
+}
+
+module.exports = abs;

package/src/handlebars/helpers/addCommas.js

@@ -0,0 +1,8 @@
+// addCommas Helper
+// Add Commas to Numbers
+
+function addCommas(num) {
+  return num.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1,');
+};
+
+module.exports = addCommas;

package/src/handlebars/helpers/array.js

@@ -0,0 +1,8 @@
+// array Helper
+// This helper is used to defined array literals in handlebars
+
+function array() {
+  return Array.from(arguments).slice(0, arguments.length - 1);
+}
+
+module.exports = array;

package/src/handlebars/helpers/assignGlobal.js

@@ -0,0 +1,9 @@
+// assignGlobal Helper
+// Globally assign a variable that can be accessed via root in handlebars
+
+function assignGlobal(name, val, options) {
+  if (!options.data.root) options.data.root = {};
+  options.data.root[name] = val;
+}
+
+module.exports = assignGlobal;

package/src/handlebars/helpers/boolean.js

@@ -0,0 +1,19 @@
+// boolean Helper
+// Evaluates Comparison and Logical Operations
+
+function boolean(v1, operator, v2, options) {
+  return {
+    "==": v1 == v2,
+    "===": v1 === v2,
+    "!=": v1 != v2,
+    "!==": v1 !== v2,
+    "<": v1 < v2,
+    "<=": v1 <= v2,
+    ">": v1 > v2,
+    ">=": v1 >= v2,
+    "&&": v1 && v2,
+    "||": v1 || v2,
+  }[operator]
+}
+
+module.exports = boolean;