Replace CMD: to cmd

Author: ryo-ma

README.md

@@ -202,16 +202,16 @@ $ dim install https://example.com -n "example" -p xlsx-to-csv
 
 Postprocess custom command
 
-You can specify a custom command after **"CMD:"**.
+You can specify a custom command after **"cmd"**.
 
 ```
-$ dim install https://example.com -n "example" -p "CMD:******"
+$ dim install https://example.com -n "example" -p "cmd ******"
 ```
 
 The file path will be passed as an argument at the end of the specified command.
 
 ```
-$ dim install https://example.com -n "example" -p "CMD:python ./tests/test_custom_command.py"
+$ dim install https://example.com -n "example" -p "cmd python ./tests/test_custom_command.py"
 ```
 
 Command to be executed during postprocessing.
@@ -223,6 +223,7 @@ $ python ./tests/test_custom_command.py ./data_files/***/***.xx
 #### Forced execution
 
 Forced install. Overwrite already exist data file.
+
 ```
 $ dim install https://example.com -n "example" -F
 ```

libs/actions.ts

@@ -25,11 +25,8 @@ import {
   DimLockJSON,
   LockContent,
 } from "./types.ts";
-import { Encoder } from "./postprocess/encoder.ts";
-import { Unzipper } from "./postprocess/unzipper.ts";
-import { XLSXConverter } from "./postprocess/xlsx_converter.ts";
-import { Command } from "./postprocess/command.ts";
 import { CkanApiClient } from "./ckan_api_client.ts";
+import { PostprocessDispatcher } from "./postprocess/postprocess_dispatcher.ts";
 
 const initDimFile = async () => {
   const dimData: DimJSON = { fileVersion: DIM_FILE_VERSION, contents: [] };
@@ -256,70 +253,15 @@ const installFromCatalog = async (
   return fullPath;
 };
 
+const postprocessDispatcher = new PostprocessDispatcher();
+
 const executePostprocess = async (
   postProcesses: string[],
   targetPath: string,
 ) => {
   for (const postProcess of postProcesses) {
     const [type, ...argumentList] = postProcess.split(" ");
-    if (type === "encode") {
-      if (argumentList.length === 0) {
-        console.log(
-          Colors.red("Argument not specified."),
-        );
-        Deno.exit(1);
-      } else if (argumentList.length > 1) {
-        console.log(
-          Colors.red("error: Too many arguments:"),
-          Colors.red(type + " " + argumentList.join(" ")),
-        );
-        Deno.exit(1);
-      }
-      const encodingTo = argumentList[0].toUpperCase();
-      await new Encoder().encodeFile(targetPath, encodingTo);
-      console.log("Converted encoding to", encodingTo);
-    } else if (type === "unzip") {
-      if (argumentList.length > 0) {
-        console.log(
-          Colors.red("error: Too many arguments:"),
-          Colors.red(type + " " + argumentList.join(" ")),
-        );
-        Deno.exit(1);
-      }
-      const targetDir = await new Unzipper().unzip(targetPath);
-      console.log(`Unzip the file to ${targetDir}`);
-    } else if (type === "xlsx-to-csv") {
-      if (argumentList.length > 0) {
-        console.log(
-          Colors.red("error: Too many arguments:"),
-          Colors.red(type + " " + argumentList.join(" ")),
-        );
-        Deno.exit(1);
-      }
-      await new XLSXConverter().convertToCSV(targetPath);
-      console.log(`Convert xlsx to csv.`);
-    } else if (postProcess.startsWith("CMD:")) {
-      const script = postProcess.replace("CMD:", "").trim();
-      if (script === "") {
-        console.log(
-          Colors.red("No command entered"),
-        );
-        Deno.exit(1);
-      }
-      try {
-        console.log("Execute Command: ", script, targetPath);
-        const result = await new Command().execute(script, targetPath);
-        console.log(result);
-      } catch (e) {
-        console.log(
-          Colors.red(`Failed to execute the "${script}"\n`),
-          Colors.red(`${e}`),
-        );
-        // Do not `exit` because there are commands that do not correspond when obtained from external dim.json.
-      }
-    } else {
-      console.log(`No support a postprocess '${postProcess}'.`);
-    }
+    await postprocessDispatcher.dispatch(type, argumentList, targetPath);
   }
 };
 
@@ -716,9 +658,9 @@ export class SearchAction {
         message:
           "Enter the post-processing you want to add. Enter blank if not required.",
         hint:
-          "(ex.: > unzip, xlsx-to-csv, encode utf-8 or CMD:[some cli command])",
+          "(ex.: > unzip, xlsx-to-csv, encode utf-8 or cmd [some cli command])",
         validate: (text) => {
-          return text === "" || text.startsWith("CMD:") ||
+          return text === "" || text.startsWith("cmd ") ||
             availablePostProcesses.includes(text);
         },
         suggestions: availablePostProcesses,

libs/postprocess/base_postprocess.ts

@@ -0,0 +1,16 @@
+export abstract class BasePostprocess {
+  type: string;
+  argumentNameList: string[];
+  constructor(type: string, argumentNameList: string[]) {
+    this.type = type;
+    this.argumentNameList = argumentNameList;
+  }
+  abstract execute(argumentList: string[], targetPath: string): Promise<string>;
+  abstract validate(argumentList: string[]): boolean;
+  printUsage() {
+    console.log(
+      "usage: " + this.type + " " +
+        this.argumentNameList.map((arg) => `[${arg}]`).join(" "),
+    );
+  }
+}

libs/postprocess/command.ts

@@ -1,12 +1,25 @@
-export class Command {
-  async execute(script: string, path: string) {
-    const cmd = script.split(" ");
-    cmd.push(path);
+import { Colors } from "../../deps.ts";
+import { BasePostprocess } from "./base_postprocess.ts";
+
+export class Command extends BasePostprocess {
+  async execute(argumentList: string[], targetPath: string): Promise<string> {
+    const cmd = argumentList[0].split(" ");
+    cmd.push(targetPath);
     const p = Deno.run({
       cmd: cmd,
       stdout: "piped",
     });
     const o = await p.output();
     return new TextDecoder().decode(o);
   }
+  validate(argumentList: string[]) {
+    if (argumentList.length < 1) {
+      console.log(
+        Colors.red("No command entered"),
+      );
+      this.printUsage();
+      return false;
+    }
+    return true;
+  }
 }

libs/postprocess/encoder.ts

@@ -1,14 +1,34 @@
-import { encoding } from "./../../deps.ts";
-export class Encoder {
-  async encodeFile(filePath: string, to: string, from = "AUTO") {
-    const byteArray = Deno.readFileSync(filePath);
+import { Colors, encoding } from "./../../deps.ts";
+import { BasePostprocess } from "./base_postprocess.ts";
+
+export class Encoder extends BasePostprocess {
+  async execute(argumentList: string[], targetPath: string): Promise<string> {
+    const byteArray = Deno.readFileSync(targetPath);
     const encodedByteArray = encoding.default.convert(byteArray, {
-      to,
-      from,
+      to: argumentList[0],
+      from: "AUTO",
     });
     await Deno.writeFile(
-      filePath,
+      targetPath,
       Uint8Array.from(encodedByteArray),
     );
+    return targetPath;
+  }
+  validate(argumentList: string[]) {
+    if (argumentList.length === 0) {
+      console.log(
+        Colors.red("Argument not specified."),
+      );
+      this.printUsage();
+      return false;
+    } else if (argumentList.length > 1) {
+      console.log(
+        Colors.red("error: Too many arguments:"),
+        Colors.red(this.type + " " + argumentList.join(" ")),
+      );
+      this.printUsage();
+      return false;
+    }
+    return true;
   }
 }

libs/postprocess/postprocess_dispatcher.ts

@@ -0,0 +1,60 @@
+import { Colors } from "../../deps.ts";
+import { Command } from "./command.ts";
+import { Encoder } from "./encoder.ts";
+import { Unzipper } from "./unzipper.ts";
+import { XlsxToCsvConverter } from "./xlsx_to_csv_converter.ts";
+
+export class PostprocessDispatcher {
+  private encoder;
+  private unzipper;
+  private xlsxToCsvConverter;
+  private command;
+  constructor() {
+    this.encoder = new Encoder("encode", ["encoding-to"]);
+    this.unzipper = new Unzipper("unzip", []);
+    this.xlsxToCsvConverter = new XlsxToCsvConverter("xlsx-to-csv", []);
+    this.command = new Command("cmd", ["script"]);
+  }
+  async dispatch(type: string, argumentList: string[], targetPath: string) {
+    if (type === this.encoder.type) {
+      if (this.encoder.validate(argumentList)) {
+        const encodingTo = argumentList[0].toUpperCase();
+        await this.encoder.execute([encodingTo], targetPath);
+        console.log("Converted encoding to", encodingTo);
+      } else {
+        Deno.exit(1);
+      }
+    } else if (type === this.unzipper.type) {
+      if (this.unzipper.validate(argumentList)) {
+        const targetDir = await this.unzipper.execute([], targetPath);
+        console.log(`Unzip the file to ${targetDir}`);
+      } else {
+        Deno.exit(1);
+      }
+    } else if (type === this.xlsxToCsvConverter.type) {
+      if (this.xlsxToCsvConverter.validate(argumentList)) {
+        await this.xlsxToCsvConverter.execute([], targetPath);
+        console.log(`Convert xlsx to csv.`);
+      } else {
+        Deno.exit(1);
+      }
+    } else if (type === this.command.type) {
+      const script = argumentList.join(" ");
+      try {
+        if (this.command.validate(argumentList)) {
+          console.log("Execute Command: ", argumentList, targetPath);
+          const result = await this.command.execute([script], targetPath);
+          console.log(result);
+        }
+      } catch (e) {
+        console.log(
+          Colors.red(`Failed to execute the "${script}"\n`),
+          Colors.red(`${e}`),
+        );
+        // Do not `exit` because there are commands that do not correspond when obtained from external dim.json.
+      }
+    } else {
+      console.log(`No support a postprocess '${type}' '${argumentList}'.`);
+    }
+  }
+}

libs/postprocess/unzipper.ts

@@ -1,7 +1,8 @@
-import { decompress } from "../../deps.ts";
+import { Colors, decompress } from "../../deps.ts";
+import { BasePostprocess } from "./base_postprocess.ts";
 
-export class Unzipper {
-  async unzip(targetPath: string) {
+export class Unzipper extends BasePostprocess {
+  async execute(_: string[], targetPath: string): Promise<string> {
     const splitedPath = targetPath.split("/");
     const targetDir = splitedPath.slice(0, splitedPath.length - 1).join("/");
     if (Deno.build.os === "darwin") {
@@ -17,4 +18,15 @@ export class Unzipper {
     }
     return targetDir;
   }
+  validate(argumentList: string[]) {
+    if (argumentList.length > 0) {
+      console.log(
+        Colors.red("error: Too many arguments:"),
+        Colors.red(this.type + " " + argumentList.join(" ")),
+      );
+      this.printUsage();
+      return false;
+    }
+    return true;
+  }
 }

libs/postprocess/xlsx_converter.ts

@@ -0,0 +1,23 @@
+import { Colors, readXLSX, xlsx } from "../../deps.ts";
+import { BasePostprocess } from "./base_postprocess.ts";
+
+export class XlsxToCsvConverter extends BasePostprocess {
+  async execute(_: string[], targetPath: string): Promise<string> {
+    const workbook = await readXLSX(targetPath);
+    const sheetData = workbook.Sheets[workbook.SheetNames[0]];
+    const csv = xlsx.utils.sheet_to_csv(sheetData);
+    Deno.writeTextFileSync(targetPath.replace(/\.xlsx$/, ".csv"), csv);
+    return targetPath;
+  }
+  validate(argumentList: string[]) {
+    if (argumentList.length > 0) {
+      console.log(
+        Colors.red("error: Too many arguments:"),
+        Colors.red(this.type + " " + argumentList.join(" ")),
+      );
+      this.printUsage();
+      return false;
+    }
+    return true;
+  }
+}