@tellahq/rescript 10.1.0-alpha.1

package/scripts/curry_gen.ml

@@ -0,0 +1,167 @@
+
+
+(* no mli file emitted, since mli is not very meaningful 
+   except which identifiers are exposed 
+   exported functions:
+
+   - [ app f args]
+      called when apply a curried function with a list of arugments
+   - [ _1 o arg ]  .. [ _n]
+      called when apply a curried function with [n] argument
+   - [ __1 o] .. [ __n o]
+*)
+let prelude ={|
+(* Copyright (C) 2015 -  Hongbo Zhang, Authors of ReScript
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * In addition to the permissions granted to you by the LGPL, you may combine
+ * or link a "work that uses the Library" with a publicly distributed version
+ * of this file to produce a combined library or application, then distribute
+ * that combined work under the terms of your choosing, with no requirement
+ * to comply with the obligations normally placed on you by section 4 of the
+ * LGPL version 3 (or the corresponding section of a later version of the LGPL
+ * should you choose to use a later version).
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
+
+(* Generated by scripts/curry_gen.ml *)  
+external function_length : 'a -> int = "#function_length"
+external apply_args : ('a -> 'b) -> _ array -> 'b = "#apply"
+external sub : 'a array -> int -> int -> 'a array = "?array_sub"
+
+(* Public *)
+let rec app f args = 
+  let init_arity = function_length f in
+  let arity = if init_arity = 0 then 1 else init_arity in (* arity fixing *)
+  let len = Caml_array_extern.length args in
+  let d = arity - len in 
+  if d = 0 then 
+    apply_args f  args (* f.apply (null,args) *)
+  else if d < 0 then 
+    (* TODO: could avoid copy by tracking the index *)
+    app (Obj.magic (apply_args f (sub args 0 arity)))
+      (sub args arity (-d))
+  else 
+    Obj.magic (fun x -> app f (Caml_array_extern.append args [|x|] ))
+  
+|}
+
+let list_init n  fn = Array.to_list (Array.init n fn)
+    
+let generate_case
+    ?arity
+    ~args_number args_array args =
+  match arity with
+  | None ->
+    Printf.sprintf " _ -> Obj.magic (app o [|%s|])"
+      (String.concat ";"args)      
+  | Some arity ->     
+    Printf.sprintf " %d -> %s" arity
+      (if arity >= args_number then
+         Printf.sprintf "apply%d (Obj.magic o) %s"
+           arity (String.concat " " args)
+       else
+         Printf.sprintf
+           "app (apply%d (Obj.magic o) %s) [|%s|]"
+           arity
+           (String.concat " "(Array.to_list (Array.sub args_array 0 arity)))          
+           (String.concat ";"
+              (Array.to_list (Array.sub args_array arity (args_number - arity)))))
+
+
+
+let number = 8
+
+let generate_apply arity =
+  let vars =
+    list_init (arity + 1)
+      (fun i -> Printf.sprintf "'a%d" i) in
+  let ty =
+    match vars with
+    | [] -> assert false
+    | x::xs
+      ->       
+      List.fold_left
+        (fun acc x -> acc ^ " -> " ^ x )
+        x xs in         
+  Printf.sprintf
+    "(* Internal use *)\n\
+    external apply%d : (%s) -> %s = \"#apply%d\""
+    arity ty ty arity
+    
+
+
+let generate_fun args_number =
+  let args_array =
+    Array.init args_number (fun i -> Printf.sprintf "a%d" i) in
+  let args =  Array.to_list args_array in
+  let args_string =  (String.concat " " args) in
+
+  Printf.sprintf {|
+
+let %%private curry_%d o %s arity =
+  match arity with
+  |%s    
+
+(* Public *)  
+let _%d o %s =
+  let arity = function_length o in
+  if arity = %d then apply%d o %s
+  else curry_%d o %s arity     
+
+(* Public *)
+let __%d o =
+  let arity = function_length o in
+  if arity = %d then o
+  else fun %s -> _%d o %s
+|}
+    args_number
+    args_string
+    (String.concat "\n  |"
+
+       (list_init (number - 1) 
+          (fun arity -> generate_case ~arity:(arity + 1) ~args_number args_array args)
+        @ [ generate_case ~args_number args_array args]          
+       )
+    )
+
+    args_number
+    args_string
+    args_number
+    args_number
+    args_string
+    args_number
+    args_string
+    
+
+    args_number
+    args_number
+    args_string
+    args_number
+    args_string
+    
+let () =
+  print_endline
+  @@ Printf.sprintf
+    "%s\n%s\n%s"
+    prelude
+    (String.concat "\n"
+       (list_init number (fun i -> generate_apply (i + 1)))       
+    )    
+    (String.concat "\n"
+       (list_init 8 (fun i -> generate_fun (i + 1))))
+
+(* local variables: *)
+(* compile-command: "ocaml curry_gen.ml > ../jscomp/runtime/curry.ml" *)
+(* end: *)

package/scripts/dbg

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+var cp = require("child_process");
+var path = require("path");
+
+var file = process.argv[2];
+console.log(file);
+var fmt = path.parse(file);
+
+process.env.RES_DEBUG_FILE = 1;
+var ninja = path.join(__dirname, "..", process.platform, "ninja.exe");
+cp.execSync(`touch ${file} && ${ninja} ${fmt.dir}/${fmt.name}.cmj`, {
+  stdio: [0, 1, 2]
+});

package/scripts/dedupe.js

@@ -0,0 +1,44 @@
+//@ts-check
+var fs = require("fs");
+var cp = require("child_process");
+var path = require("path");
+
+var jscompDir = path.join(__dirname, "..", "jscomp");
+
+var sourceDirs = [
+  "stubs",
+  "ext",
+  "common",
+  "syntax",
+  "depends",
+  "core",
+  "super_errors",
+  "outcome_printer",
+  "bsb",
+  "ounit",
+  "ounit_tests",
+  "main",
+];
+
+var files = cp.execSync(`git ls-files ${sourceDirs.join(" ")}`, {
+  cwd: jscompDir,
+  encoding: "utf8",
+});
+
+var filesPath = files.split("\n");
+
+/**
+ * @type {Map<string,string>}
+ */
+var collection = new Map();
+for (let file of filesPath) {
+  let base = path.basename(file);
+  if (collection.has(base)) {
+    if (base.endsWith(".ml") && !file.includes("templates")) {
+      console.log(`duplicate ${base} : ${collection.get(base)} vs ${file}`);
+    }
+  } else {
+    collection.set(base, file);
+  }
+}
+debugger;

package/scripts/doc_gen.js

@@ -0,0 +1,117 @@
+//@ts-check
+
+// This assume you already have cmi at hand
+// Okay to use ES6 since it is generated before shipping
+
+var fs = require("fs");
+
+var path = require("path");
+var child_process = require("child_process");
+
+var versionPrefix = require("./buildocaml.js").getVersionPrefix();
+var stdlibVersion = versionPrefix.includes("4.02")
+  ? "stdlib-402"
+  : "stdlib-406";
+var runtime_dir = path.join(__dirname, "..", "jscomp", "runtime");
+var others_dir = path.join(__dirname, "..", "jscomp", "others");
+var stdlib_dir = path.join(__dirname, "..", "jscomp", stdlibVersion);
+var jscomp = path.join(__dirname, "..", "jscomp");
+var runtime_prefix = path.relative(jscomp, runtime_dir);
+var others_prefix = path.relative(jscomp, others_dir);
+var ocamldoc = path.join(
+  __dirname,
+  "..",
+  "native",
+  versionPrefix,
+  "bin",
+  "ocamldoc.opt"
+);
+
+/**
+ *
+ * @param {string} s
+ */
+const capitalize = s => {
+  if (typeof s !== "string") return "";
+  return s.charAt(0).toUpperCase() + s.slice(1);
+};
+/**
+ *
+ * @param {string} filename
+ */
+const strip = filename => filename.split(".").slice(0, -1).join(".");
+function main() {
+  /**
+   * @type {string[]}
+   */
+  var hidden_list = [];
+  var runtime_files = fs
+    .readdirSync(runtime_dir)
+    .filter(
+      file =>
+        file.startsWith("js") &&
+        (file.endsWith(".ml") || file.endsWith(".mli")) &&
+        !file.endsWith(".cppo.ml") &&
+        !file.endsWith(".cppo.mli")
+    )
+    .map(x => {
+      if (x.includes("internal")) {
+        hidden_list.push(capitalize(strip(x)));
+      }
+      return path.join(runtime_prefix, x);
+    })
+    .join(" ");
+
+  var others_files = fs
+    .readdirSync(others_dir)
+    .filter(
+      file =>
+        (file.endsWith(".ml") || file.endsWith(".mli")) &&
+        !file.endsWith(".cppo.ml") &&
+        !file.endsWith(".cppo.mli")
+    )
+    .map(x => {
+      if (x.includes("internal")) {
+        hidden_list.push(capitalize(strip(x)));
+      }
+      return path.join(others_prefix, x);
+    })
+    .join(" ");
+
+  var odoc_gendir = path.join(__dirname, "..", "odoc_gen");
+
+  var api_doc_dir = path.join(__dirname, "..", "docs", "api");
+  var intro = path.join(__dirname, "..", "jscomp", "others", "intro.txt");
+  //
+  var generator = `-g ${odoc_gendir}/generator.cmxs`;
+  // var generator = `-html`
+
+  var hidden_modules = ``;
+  // hidden_modules =  `-hide ${hidden_list.join(',')}`
+
+  var prefix_flags = `${ocamldoc}  ${generator} ${hidden_modules} -w -40 -nostdlib -nopervasives  -I ${others_dir} -I ${runtime_dir} -open Bs_stdlib_mini -charset utf-8  -intro ${intro} -sort -ppx '${path.join(
+    __dirname,
+    "..",
+    process.platform,
+    "bsc"
+  )} -as-ppx'  -d ${api_doc_dir}`;
+
+  // -html it is weird
+  // It is weird, -html will unload the plugin
+
+  // It seems ocamldoc does need require all files for indexing modules, WTF ocamldoc !!
+  var cmd = `${prefix_flags}  ${runtime_files} ${others_files}`;
+
+  console.log(`Running ${cmd}`);
+
+  child_process.execSync(cmd, { cwd: jscomp, encoding: "utf8" });
+}
+exports.main = main;
+if (require.main === module) {
+  main();
+}
+// console.log(`runtime files : ${runtime_files}`)
+// child_process.execSync(`${prefix_flags} ${runtime_files} `, {cwd : runtime_dir})
+
+// console.log(`others files : ${others_files}`)
+// child_process.execSync(`${prefix_flags} ${others_files} `, {cwd : others_dir})

package/scripts/install.js

@@ -0,0 +1,237 @@
+//@ts-check
+// For Windows, we distribute a prebuilt bsc.exe
+// To build on windows, we still need figure out constructing config.ml
+// from existing  compiler
+
+// For other OSes, we detect
+// if there is other compiler installed and the version matches,
+// we get the config.ml from existing OCaml compiler and build whole_compiler
+
+// Otherwise, we build the compiler shipped with Buckle and use the
+// old compiler.ml
+// This will be run in npm postinstall, don't use too fancy features here
+
+var child_process = require("child_process");
+var fs = require("fs");
+var path = require("path");
+var root_dir = path.join(__dirname, "..");
+var lib_dir = path.join(root_dir, "lib");
+var jscomp_dir = path.join(root_dir, "jscomp");
+
+var supported_os = ["darwin", "freebsd", "linux", "openbsd", "win32"];
+if (supported_os.indexOf(process.platform) < 0) {
+  throw new Error("Not supported platform" + process.platform);
+}
+var is_windows = process.platform === "win32";
+
+var bsc_exe = require("./bin_path").bsc_exe;
+
+var ninja_bin_filename = process.platform === "win32" ? "ninja.exe" : "ninja";
+var ninja_bin_output = require("./bin_path").ninja_exe;
+
+var force_compiler_rebuild = process.argv.includes("-force-compiler-rebuild");
+var force_lib_rebuild = process.argv.includes("-force-lib-rebuild");
+/**
+ * Make sure `ninja_bin_output` exists
+ * The installation of `ninja.exe` is re-entrant, since we always pre-check if it is already installed
+ * This is less problematic since `ninja.exe` is very stable
+ */
+function provideNinja() {
+  var vendor_ninja_version = "1.9.0.git";
+  var ninja_source_dir = path.join(root_dir, "vendor", "ninja");
+  function build_ninja() {
+    console.log(`building ninja`);
+    ensureExists(ninja_source_dir);
+    if (fs.existsSync(path.join(root_dir, "vendor", "ninja.tar.gz"))) {
+      console.log("Extracting ninja sources...");
+      child_process.execSync(`tar xzf ../ninja.tar.gz`, {
+        cwd: ninja_source_dir,
+        stdio: [0, 1, 2],
+      });
+      console.log("No prebuilt Ninja, building Ninja now");
+      var build_ninja_command = "./configure.py --bootstrap";
+      child_process.execSync(build_ninja_command, {
+        cwd: ninja_source_dir,
+        stdio: [0, 1, 2],
+      });
+      fs.copyFileSync(
+        path.join(ninja_source_dir, ninja_bin_filename),
+        ninja_bin_output
+      );
+    } else {
+      console.log(`ninja.tar.gz not availble in CI mode`);
+      require("../ninja/snapshot").build();
+      fs.copyFileSync(
+        path.join(root_dir, "ninja", ninja_bin_filename),
+        ninja_bin_output
+      );
+    }
+
+    console.log("ninja binary is ready: ", ninja_bin_output);
+  }
+
+  // sanity check to make sure the binary actually runs. Used for Linux. Too many variants
+  /**
+   *
+   * @param {string} binary_path
+   */
+  function test_ninja_compatible(binary_path) {
+    var version;
+    try {
+      version = child_process
+        .execSync(JSON.stringify(binary_path) + " --version", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"], // execSync outputs to stdout even if we catch the error. Silent it here
+        })
+        .trim();
+    } catch (e) {
+      console.log("ninja not compatible?", String(e));
+      return false;
+    }
+    return version === vendor_ninja_version;
+  }
+
+  if (
+    process.env.NINJA_FORCE_REBUILD === undefined &&
+    fs.existsSync(ninja_bin_output) &&
+    test_ninja_compatible(ninja_bin_output)
+  ) {
+    console.log(
+      "ninja binary is already cached and installed: ",
+      ninja_bin_output
+    );
+    return;
+  }
+
+  build_ninja();
+}
+
+/**
+ *
+ * @param {string} dir
+ * TODO: `mkdirSync` may fail
+ */
+function ensureExists(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+}
+
+/**
+ * @returns {string|undefined}
+ */
+function checkPrebuiltBscCompiler() {
+  if (process.env.RESCRIPT_FORCE_REBUILD || force_compiler_rebuild) {
+    return;
+  }
+  try {
+    var version = String(child_process.execFileSync(bsc_exe, ["-v"]));
+
+    var myOCamlVersion = version.substr(
+      version.indexOf(":") + 1,
+      version.lastIndexOf(" ") - version.indexOf(":") - 1
+    );
+    console.log("checkoutput:", version, "ocaml version", myOCamlVersion);
+    console.log("Prebuilt compiler works good");
+
+    return myOCamlVersion;
+  } catch (e) {
+    console.log("No working prebuilt ReScript compiler");
+    if (is_windows) {
+      throw new Error("no prebuilt bsc compiler on windows");
+    }
+    return;
+  }
+}
+/**
+ *
+ * @param {string} stdlib
+ */
+function buildLibs(stdlib) {
+  ensureExists(lib_dir);
+  ensureExists(path.join(lib_dir, "js"));
+  ensureExists(path.join(lib_dir, "es6"));
+  process.env.NINJA_IGNORE_GENERATOR = "true";
+  var releaseNinja = `
+bsc = ${bsc_exe}
+stdlib = ${stdlib}
+subninja runtime/release.ninja
+subninja others/release.ninja
+subninja $stdlib/release.ninja
+${process.env.RESCRIPT_FORCE_REBUILD ? "subninja test/build.ninja\n" : "\n"}
+o all: phony runtime others $stdlib
+`;
+  var filePath = path.join(jscomp_dir, "release.ninja");
+  fs.writeFileSync(filePath, releaseNinja, "ascii");
+  var cleanArgs = ["-f", "release.ninja", "-t", "clean"];
+  child_process.execFileSync(ninja_bin_output, cleanArgs, {
+    cwd: jscomp_dir,
+    stdio: [0, 1, 2],
+    shell: false,
+  });
+  var buildArgs = ["-f", "release.ninja", "--verbose", "-k", "1"];
+  child_process.execFileSync(ninja_bin_output, buildArgs, {
+    cwd: jscomp_dir,
+    stdio: [0, 1, 2],
+    shell: false,
+  });
+  fs.unlinkSync(filePath);
+  console.log("Build finished");
+}
+
+/**
+ * @returns {string}
+ */
+function provideCompiler() {
+  var myVersion = checkPrebuiltBscCompiler();
+  if (myVersion !== undefined) {
+    return myVersion;
+  } else {
+    var ocamlopt = "ocamlopt.opt";
+    myVersion = "4.06.1";
+    if (!require("./buildocaml.js").checkEnvCompiler()) {
+      // no compiler available
+      var prefix = require("./buildocaml.js").build(true);
+      ocamlopt = `${prefix}/bin/${ocamlopt}`;
+    }
+    // Note this ninja file only works under *nix due to the suffix
+    // under windows require '.exe'
+    var releaseNinja = require("./ninjaFactory.js").libNinja({
+      ocamlopt: ocamlopt,
+      INCL: myVersion,
+      isWin: is_windows,
+    });
+
+    var filePath = path.join(lib_dir, "release.ninja");
+    fs.writeFileSync(filePath, releaseNinja, "ascii");
+    child_process.execFileSync(
+      ninja_bin_output,
+      ["-f", "release.ninja", "-t", "clean"],
+      {
+        cwd: lib_dir,
+        stdio: [0, 1, 2],
+      }
+    );
+    child_process.execFileSync(
+      ninja_bin_output,
+      ["-f", "release.ninja", "-v"],
+      {
+        cwd: lib_dir,
+        stdio: [0, 1, 2],
+      }
+    );
+    fs.unlinkSync(filePath);
+    return myVersion;
+  }
+}
+
+provideNinja();
+
+provideCompiler();
+
+var stdlib = "stdlib-406";
+
+if (process.env.RESCRIPT_FORCE_REBUILD || force_lib_rebuild) {
+  buildLibs(stdlib);
+  require("./installUtils.js").install();
+}

package/scripts/installUtils.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+//@ts-check
+var fs = require("fs");
+var path = require("path");
+var assert = require("assert");
+/**
+ *
+ * @param {string} src
+ * @param {(file:string)=>boolean} filter
+ * @param {string} dest
+ */
+function installDirBy(src, dest, filter) {
+  fs.readdir(src, function (err, files) {
+    if (err === null) {
+      files.forEach(function (file) {
+        if (filter(file)) {
+          var x = path.join(src, file);
+          var y = path.join(dest, file);
+          // console.log(x, '----->', y )
+          fs.copyFile(x, y, err => assert.equal(err, null));
+        }
+      });
+    } else {
+      throw err;
+    }
+  });
+}
+
+function install() {
+  var root_dir = path.join(__dirname, "..");
+  var lib_dir = path.join(root_dir, "lib");
+  var jscomp_dir = path.join(root_dir, "jscomp");
+  var runtime_dir = path.join(jscomp_dir, "runtime");
+  var others_dir = path.join(jscomp_dir, "others");
+  var ocaml_dir = path.join(lib_dir, "ocaml");
+  var stdlib_dir = path.join(jscomp_dir, "stdlib-406");
+  if (!fs.existsSync(ocaml_dir)) {
+    fs.mkdirSync(ocaml_dir);
+  }
+  // sync up with cmij_main.ml
+  installDirBy(runtime_dir, ocaml_dir, function (file) {
+    var y = path.parse(file);
+    return y.name === "js" && y.ext !== ".cmj";
+    // install js.cmi, js.mli
+  });
+
+  // for merlin or other IDE
+  var installed_suffixes = [".ml", ".mli", ".cmi", ".cmt", ".cmti"];
+  installDirBy(others_dir, ocaml_dir, function (file) {
+    var y = path.parse(file);
+    if (y.ext === ".cmi") {
+      return !y.base.match(/Belt_internal/i);
+    }
+    return installed_suffixes.includes(y.ext);
+  });
+  installDirBy(stdlib_dir, ocaml_dir, function (file) {
+    var y = path.parse(file);
+    return installed_suffixes.includes(y.ext);
+  });
+}
+exports.install = install;