@tellahq/rescript 10.1.0-alpha.1

package/scripts/rescript_convert.js

@@ -0,0 +1,128 @@
+//@ts-check
+var arg = require("./rescript_arg.js");
+var format_usage = `Usage: rescript convert <options> [files]
+
+\`rescript convert\` converts the current directory
+
+**This command removes old Reason/OCaml files and creates new ReScript 
+files. Make sure your work is saved first!**
+`;
+
+var child_process = require("child_process");
+var path = require("path");
+var fs = require("fs");
+
+/**
+ * @type {arg.boolref}
+ */
+var formatProject = { val: undefined };
+
+/**
+ * @type{arg.specs}
+ */
+var specs = [
+  [
+    "-all",
+    { kind: "Unit", data: { kind: "Unit_set", data: formatProject } },
+    "Convert the whole project",
+  ],
+];
+
+/**
+ *
+ * @param {string} file
+ */
+function shouldConvert(file) {
+  return [".ml", ".mli", ".re", ".rei"].some(x => file.endsWith(x));
+}
+
+/**
+ *
+ * @param {string} file
+ * @param {string} bsc_exe
+ * assume the file is convertible
+ */
+function handleOneFile(file, bsc_exe) {
+  // console.log(`processing ${arg}`);
+  var nextExt = file.endsWith("i") ? ".resi" : ".res";
+  child_process.execFile(
+    bsc_exe,
+    ["-o", file.substr(0, file.lastIndexOf(".")) + nextExt, "-format", file],
+    (error, stdout, stderr) => {
+      if (error === null) {
+        // todo
+        fs.unlink(file, () => {
+          //ignore
+        });
+      } else {
+        // todo error handling
+        console.error(`Error when converting ${file}`);
+        console.log(stderr);
+      }
+    }
+  );
+}
+/**
+ * @param {string[]} argv
+ * @param {string} rescript_exe
+ * @param {string} bsc_exe
+ */
+function main(argv, rescript_exe, bsc_exe) {
+  try {
+    /**
+     * @type {string[]}
+     */
+    var files = [];
+    arg.parse_exn(format_usage, argv, specs, xs => {
+      files = xs;
+    });
+
+    var format_project = formatProject.val;
+
+    if (format_project) {
+      if (files.length !== 0) {
+        console.error("convert -all can not be in use with other flags");
+        process.exit(2);
+      }
+      // -all
+      // TODO: check the rest arguments
+      var output = child_process.spawnSync(
+        rescript_exe,
+        ["info", "-list-files"],
+        {
+          encoding: "utf-8",
+        }
+      );
+      if (output.status !== 0) {
+        console.error(output.stdout);
+        console.error(output.stderr);
+        process.exit(2);
+      }
+      files = output.stdout.split("\n").map(x => x.trim());
+      for (let file of files) {
+        if (shouldConvert(file)) {
+          handleOneFile(file, bsc_exe);
+        }
+      }
+    } else {
+      for (let i = 0; i < files.length; ++i) {
+        let file = files[i];
+        if (!shouldConvert(file)) {
+          console.error(`don't know what do with ${file}`);
+          process.exit(2);
+        }
+      }
+      files.forEach(file => {
+        handleOneFile(file, bsc_exe);
+      });
+    }
+  } catch (e) {
+    if (e instanceof arg.ArgError) {
+      console.error(e.message);
+      process.exit(2);
+    } else {
+      throw e;
+    }
+  }
+}
+exports.main = main;

package/scripts/rescript_dump.js

@@ -0,0 +1,48 @@
+//@ts-check
+var arg = require("./rescript_arg.js");
+var dump_usage = `Usage: rescript dump <options> [target]
+\`rescript dump\` dumps the information for the target
+`;
+var child_process = require("child_process");
+var path = require("path");
+var specs = [];
+
+/**
+ * @param {string[]} argv
+ * @param {string} rescript_exe
+ * @param {string} bsc_exe
+ */
+function main(argv, rescript_exe, bsc_exe) {
+  var target;
+  arg.parse_exn(dump_usage, argv, specs, xs => {
+    if (xs.length !== 1) {
+      arg.bad_arg(`Expect only one target, ${xs.length} found`);
+    }
+    target = xs[0];
+  });
+
+  var { ext } = path.parse(target);
+  if (ext !== ".cmi") {
+    console.error("Only .cmi target allowed");
+    process.exit(2);
+  }
+
+  var output = child_process.spawnSync(rescript_exe, ["build", "--", target], {
+    encoding: "utf-8",
+  });
+  if (output.status !== 0) {
+    console.log(output.stdout);
+    console.error(output.stderr);
+    process.exit(2);
+  }
+  output = child_process.spawnSync(bsc_exe, [path.join("lib", "bs", target)], {
+    encoding: "utf-8",
+  });
+  console.log(output.stdout.trimEnd());
+  if (output.status !== 0) {
+    console.error(output.stderr);
+    process.exit(2);
+  }
+}
+
+exports.main = main;

package/scripts/rescript_format.js

@@ -0,0 +1,194 @@
+//@ts-check
+var arg = require("./rescript_arg.js");
+var format_usage = `Usage: rescript format <options> [files]
+
+\`rescript format\` formats the current directory
+`;
+var child_process = require("child_process");
+var path = require("path");
+var fs = require("fs");
+/**
+ * @type {arg.stringref}
+ */
+var stdin = { val: undefined };
+
+/**
+ * @type {arg.boolref}
+ */
+var format = { val: undefined };
+
+/**
+ * @type{arg.specs}
+ */
+var specs = [
+  [
+    "-stdin",
+    { kind: "String", data: { kind: "String_set", data: stdin } },
+    `[.res|.resi|.ml|.mli] Read the code from stdin and print
+the formatted code to stdout in ReScript syntax`,
+  ],
+  //  ml|mli
+  [
+    "-all",
+    { kind: "Unit", data: { kind: "Unit_set", data: format } },
+    "Format the whole project ",
+  ],
+];
+var formattedStdExtensions = [".res", ".resi", ".ml", ".mli"];
+var formattedFileExtensions = [".res", ".resi"];
+
+/**
+ *
+ * @param {string[]} extensions
+ */
+function hasExtension(extensions) {
+  /**
+   * @param {string} x
+   */
+  var pred = x => extensions.some(ext => x.endsWith(ext));
+  return pred;
+}
+async function readStdin() {
+  var stream = process.stdin;
+  const chunks = [];
+  for await (const chunk of stream) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+/**
+ * @param {string[]} argv
+ * @param {string} rescript_exe
+ * @param {string} bsc_exe
+ */
+function main(argv, rescript_exe, bsc_exe) {
+  var isSupportedFile = hasExtension(formattedFileExtensions);
+  var isSupportedStd = hasExtension(formattedStdExtensions);
+
+  try {
+    /**
+     * @type {string[]}
+     */
+    var files = [];
+    arg.parse_exn(format_usage, argv, specs, xs => {
+      files = xs;
+    });
+
+    var format_project = format.val;
+    var use_stdin = stdin.val;
+    if (format_project) {
+      if (use_stdin || files.length !== 0) {
+        console.error("format -all can not be in use with other flags");
+        process.exit(2);
+      }
+      // -all
+      // TODO: check the rest arguments
+      var output = child_process.spawnSync(
+        rescript_exe,
+        ["info", "-list-files"],
+        {
+          encoding: "utf-8",
+        }
+      );
+      if (output.status !== 0) {
+        console.error(output.stdout);
+        console.error(output.stderr);
+        process.exit(2);
+      }
+      files = output.stdout.split("\n").map(x => x.trim());
+      var hasError = false;
+      for (let arg of files) {
+        if (isSupportedFile(arg)) {
+          // console.log(`processing ${arg}`);
+          child_process.execFile(
+            bsc_exe,
+            ["-o", arg, "-format", arg],
+            (error, _stdout, stderr) => {
+              if (error !== null) {
+                console.error(stderr);
+                hasError = true;
+              }
+            }
+          );
+        }
+      }
+      if (hasError) {
+        process.exit(2);
+      }
+    } else if (use_stdin) {
+      if (isSupportedStd(use_stdin)) {
+        var crypto = require("crypto");
+        var os = require("os");
+        var filename = path.join(
+          os.tmpdir(),
+          "rescript_" +
+            crypto.randomBytes(8).toString("hex") +
+            path.parse(use_stdin).base
+        );
+        (async function () {
+          var content = await readStdin();
+          var fd = fs.openSync(filename, "wx", 0o600); // Avoid overwriting existing file
+          fs.writeFileSync(fd, content, "utf8");
+          fs.closeSync(fd);
+          process.addListener("exit", () => fs.unlinkSync(filename));
+          child_process.execFile(
+            bsc_exe,
+            ["-format", filename],
+            (error, stdout, stderr) => {
+              if (error === null) {
+                process.stdout.write(stdout);
+              } else {
+                console.error(stderr);
+                process.exit(2);
+              }
+            }
+          );
+        })();
+      } else {
+        console.error(`Unsupported exetnsion ${use_stdin}`);
+        console.error(`Supported extensions: ${formattedStdExtensions} `);
+        process.exit(2);
+      }
+    } else {
+      if (files.length === 0) {
+        // none of argumets set
+        // format the current directory
+        files = fs.readdirSync(process.cwd()).filter(isSupportedFile);
+      }
+
+      for (let i = 0; i < files.length; ++i) {
+        let file = files[i];
+        if (!isSupportedStd(file)) {
+          console.error(`Don't know what do with ${file}`);
+          console.error(`Supported extensions: ${formattedFileExtensions}`);
+          process.exit(2);
+        }
+      }
+      var hasError = false;
+      files.forEach(file => {
+        var write = isSupportedFile(file);
+        var flags = write ? ["-o", file, "-format", file] : ["-format", file];
+        child_process.execFile(bsc_exe, flags, (error, stdout, stderr) => {
+          if (error === null) {
+            if (!write) {
+              process.stdout.write(stdout);
+            }
+          } else {
+            console.error(stderr);
+            hasError = true;
+          }
+        });
+      });
+      if (hasError) {
+        process.exit(2);
+      }
+    }
+  } catch (e) {
+    if (e instanceof arg.ArgError) {
+      console.error(e.message);
+      process.exit(2);
+    } else {
+      throw e;
+    }
+  }
+}
+exports.main = main;

package/scripts/shake.js

@@ -0,0 +1,138 @@
+//@ts-check
+// usage : node ./script/shake.js bsb
+var cp = require("child_process");
+var path = require("path");
+var fs = require("fs");
+
+var bsc = path.join(__dirname, "..", process.platform, "bsc");
+var ocamlopt = path.join(
+  __dirname,
+  "..",
+  "native",
+  "4.06.1",
+  "bin",
+  "ocamlopt.opt"
+);
+
+var base = process.argv[2];
+if (base === undefined) {
+  console.error(`please specifiy a base`);
+  process.exit(2);
+}
+var file = `${base}.ml`;
+var cwd = path.join(__dirname, "..", "lib", "4.06.1");
+
+// TODO replace it with yours
+var esy = `/Users/hongbozhang/git/genType/_esy/default/build/install/default/bin`;
+
+/**
+ *
+ * @param {string} file
+ */
+function dsource(file) {
+  let tmp = path.join(cwd, "tmp.ml");
+  var output = cp.spawnSync(
+    `${bsc} -bs-no-builtin-ppx -bs-syntax-only -dsource  -c ${file} 2>${tmp}`,
+    {
+      cwd,
+      encoding: "utf8",
+      shell: true,
+    }
+  );
+  // check output.status
+  if (output.status === 0) {
+    //  fs.writeFileSync(path.join(cwd, file), output.stderr);
+    fs.copyFileSync(tmp, path.join(cwd, file));
+    fs.unlinkSync(tmp);
+  } else {
+    console.error(`dsource failure`);
+    console.error(fs.readFileSync(tmp) + "");
+    process.exit(2);
+  }
+
+  // fs.copyFileSync(path.join(cwd, tmp), path.join(cwd, file));
+}
+
+/**
+ *
+ * @param {string} file
+ * @param {string} msg
+ */
+function checkDiff(file, msg) {
+  var output = cp.spawnSync(`git diff --quiet ${file}`, {
+    shell: true,
+    encoding: "utf8",
+    cwd,
+  });
+  if (output.status !== 0) {
+    var output = cp.spawnSync(
+      `git add ${file} && git commit -m "${msg} for ${file}"`,
+      { shell: true, encoding: "utf8", cwd }
+    );
+    if (output.status !== 0) {
+      console.error(`diff failure for ${file} -- ${msg}`);
+      process.exit(2);
+    } else {
+      console.log(output.stdout);
+    }
+  } else {
+    console.log(`nothing changes to ${file}`);
+  }
+}
+/**
+ *
+ * @param {string} file
+ */
+function shake(file) {
+  let tmp = path.join(cwd, "tmp.ml");
+  var output = cp.spawnSync(
+    `${bsc} -bs-no-builtin-ppx -bs-syntax-only -dsource  -ppx ${esy}/deadcodeppx.exe -c ${file} 2>${tmp}`,
+    {
+      cwd,
+      encoding: "utf8",
+      shell: true,
+    }
+  );
+  if (output.status !== 0) {
+    console.error(`shake failure`);
+    console.error(fs.readFileSync(tmp) + "");
+    process.exit(2);
+  } else {
+    // fs.writeFileSync(path.join(cwd, file), output.stderr);
+    fs.copyFileSync(tmp, path.join(cwd, file));
+    fs.unlinkSync(tmp);
+  }
+}
+
+/**
+ *
+ * @param {string} file
+ */
+function attachDead(file) {
+  var output = cp.spawnSync(`${ocamlopt} -bin-annot  -c ${file}`, {
+    cwd,
+    encoding: "utf8",
+    shell: true,
+  });
+
+  var genType = path.join(esy, "genType.exe");
+
+  output = cp.spawnSync(`Write=1 ${genType} -dce-cmt ${base}.cmt`, {
+    cwd,
+    encoding: "utf8",
+    shell: true,
+  });
+  if (output.status !== 0) {
+    console.error(`dce failure`);
+    console.error(output.stderr);
+    process.exit(2);
+  }
+  // fs.writeFileSync(path.join(cwd,file),output.stderr)
+}
+
+// normalize files
+dsource(file);
+checkDiff(file, `dsource changes`);
+attachDead(file);
+shake(file);
+checkDiff(file, `shake`);

package/scripts/tasks.js

@@ -0,0 +1,149 @@
+//@ts-check
+
+process.env["BS_VSCODE"] = "1";
+
+var fs = require("fs");
+var path = require("path");
+var cp = require("child_process");
+var sourceDirs = [
+  "ext",
+  "common",
+  "frontend",
+  "depends",
+  "core",
+  "super_errors",
+  "outcome_printer",
+  "bsb",
+  "main",
+  "others",
+  "stdlib-406",
+  "runtime",
+  "test",
+  "ml",
+  "ounit_tests",
+  "bsb_helper",
+  "refmt",
+  "napkin",
+  "js_parser",
+];
+
+var buildAppending = false;
+var isBuilding = false;
+
+var jscompDir = path.join("..", "jscomp");
+/**
+ *
+ * @param {Date} d
+ */
+function showDate(d) {
+  return `${d.getHours()}:${d.getMinutes()}:${d.getSeconds()}`;
+}
+function rebuild() {
+  if (isBuilding) {
+    buildAppending = true;
+  } else {
+    console.log(">>>> Start compiling");
+    isBuilding = true;
+
+    cp.fork(path.join(__dirname, "ninja.js"), ["build"]).on(
+      "exit",
+      buildFinished
+    );
+  }
+}
+/**
+ *
+ * @param {number} code
+ * @param {string} signal
+ */
+function buildFinished(code, signal) {
+  isBuilding = false;
+  if (buildAppending) {
+    buildAppending = false;
+    rebuild();
+  } else {
+    if (code !== 0) {
+      // console.log(`File "package.json", line 1, characters 1-1:`);
+      // console.log(`Error: Failed to build ${showDate(new Date())}`);
+    }
+    console.log(">>>> Finish compiling (options: R|clean|config)");
+    // TODO: check ninja exit error code
+    if (code === 0) {
+      // This is not always correct
+      // ninjaFile.updateDev();
+      // This file is cached
+      cp.fork(path.join(__dirname, "ninja.js"), ["-dev"]);
+    }
+  }
+}
+/**
+ *
+ * @param {string} eventType
+ * @param {string} filename
+ */
+function onSourceChange(eventType, filename) {
+  // console.log('event ', eventType,filename)
+  if (
+    filename.endsWith(".ml") ||
+    filename.endsWith(".mli") ||
+    filename.endsWith(".mll") ||
+    filename.endsWith(".mly") ||
+    filename.endsWith(".json") ||
+    filename.endsWith(".re") ||
+    filename.endsWith(".rei") ||
+    filename.endsWith(".res") ||
+    filename.endsWith(".resi")
+  ) {
+    rebuild();
+  }
+}
+
+sourceDirs.forEach(x => {
+  fs.watch(path.join(jscompDir, x), "utf8", onSourceChange);
+});
+
+fs.watch(path.join("..", "package.json"), "utf8", onSourceChange);
+
+rebuild();
+
+var readline = require("readline");
+readline
+  .createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+  .on("line", input => {
+    switch (input.toLowerCase()) {
+      case "r":
+        rebuild();
+        break;
+      case "config":
+        if (isBuilding) {
+          console.log(`it's building`);
+        } else {
+          isBuilding = true;
+          cp.fork(path.join(__dirname, "ninja.js"), ["config"]).on(
+            "close",
+            () => {
+              isBuilding = false;
+              rebuild();
+            }
+          );
+        }
+        break;
+      case "clean":
+        if (isBuilding) {
+          console.log(`it's building`);
+        } else {
+          isBuilding = true;
+          cp.fork(path.join(__dirname, "ninja.js"), ["cleanbuild"]).on(
+            "close",
+            () => {
+              isBuilding = false;
+            }
+          );
+        }
+
+        break;
+    }
+  });

package/scripts/test.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+set -e
+node ./node_modules/mocha/bin/mocha './jscomp/test/**/*_test.js'  -R list "$@"