Initial commit

Author: kddnewton

.github/workflows/main.yml

@@ -0,0 +1,32 @@
+name: Github Pages
+on: [push]
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@master
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: head
+
+      - name: Setup node
+        uses: actions/setup-node@v2
+        with:
+          node-version: 14.x
+          cache: yarn
+
+      - name: Package application
+        run: |
+          bundle exec rake
+          yarn install --frozen-lockfile
+          yarn build
+
+      - name: Deploy
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./docs

.gitignore

@@ -0,0 +1,10 @@
+/docs/index.js*
+/head-wasm32-unknown-wasi-full-js/
+/lib/lib/
+/node_modules/
+/ruby.wasm
+/src/app.wasm
+/vendor/
+/wasi-vfs
+/wasmtime
+/yarn-error.log

Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "bundler"
+gem "rake"
+gem "syntax_tree"

Gemfile.lock

@@ -0,0 +1,17 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.0.6)
+    syntax_tree (2.3.1)
+
+PLATFORMS
+  x86_64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  bundler
+  rake
+  syntax_tree
+
+BUNDLED WITH
+   2.3.6

Rakefile

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+file "wasi-vfs" do
+  version = "0.1.1"
+  filename =
+    if ENV["CI"]
+      "wasi-vfs-cli-x86_64-unknown-linux-gnu.zip"
+    else
+      "wasi-vfs-cli-x86_64-apple-darwin.zip"
+    end
+
+  `curl -LO "https://github.com/kateinoigakukun/wasi-vfs/releases/download/v#{version}/#{filename}"`
+  `unzip #{filename}`
+  rm filename
+end
+
+file "wasmtime" do
+  `curl https://wasmtime.dev/install.sh -sSf | bash`
+  cp "#{ENV["HOME"]}/.wasmtime/bin/wasmtime", "wasmtime"
+end
+
+file "head-wasm32-unknown-wasi-full-js" do
+  require "json"
+  version = JSON.parse(File.read("package.json"))["dependencies"]["ruby-head-wasm-wasi"][1..]
+  filename = "ruby-head-wasm32-unknown-wasi-full-js.tar.gz"
+
+  `curl -LO https://github.com/ruby/ruby.wasm/releases/download/ruby-head-wasm-wasi-#{version}/#{filename}`
+  `tar xfz #{filename}`
+  rm filename
+end
+
+file "ruby.wasm" => ["head-wasm32-unknown-wasi-full-js"] do
+  mv "head-wasm32-unknown-wasi-full-js/usr/local/bin/ruby", "ruby.wasm"
+end
+
+file "src/app.wasm" => ["wasi-vfs", "wasmtime", "ruby.wasm", "lib/app.rb"] do
+  require "bundler/setup"
+  cp_r $:.find { _1.include?("syntax_tree") }, "lib/lib"
+
+  `./wasi-vfs pack ruby.wasm --mapdir /lib::./lib --mapdir /usr::./head-wasm32-unknown-wasi-full-js/usr -o src/app.wasm`
+  rm_rf "lib/lib"
+end
+
+task default: ["src/app.wasm"]

bin/build

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+const esbuild = require("esbuild");
+const path = require("path");
+
+const wasmPlugin = require("./wasmPlugin");
+
+esbuild.build({
+  bundle: true,
+  entryPoints: [path.join(__dirname, "../src/index.tsx")],
+  format: "esm",
+  minify: true,
+  outdir: path.join(__dirname, "../docs"),
+  plugins: [wasmPlugin],
+  sourcemap: true,
+  splitting: true,
+  target: "es6"
+});

bin/serve

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const esbuild = require("esbuild");
+const path = require("path");
+
+const wasmPlugin = require("./wasmPlugin");
+
+const serveOptions = {
+  servedir: path.join(__dirname, "../docs")
+};
+
+const buildOptions = {
+  bundle: true,
+  entryPoints: [path.join(__dirname, "../src/index.tsx")],
+  format: "esm",
+  outdir: path.join(__dirname, "../docs"),
+  plugins: [wasmPlugin],
+  sourcemap: true,
+  splitting: true,
+  target: "esnext"
+};
+
+esbuild.serve(serveOptions, buildOptions).then((result) => {
+  console.log(`Listening at ${result.host}:${result.port}`);
+});

bin/wasmPlugin.js

@@ -0,0 +1,52 @@
+module.exports = {
+  name: 'wasm',
+  setup(build) {
+    let path = require('path')
+    let fs = require('fs')
+
+    // Resolve ".wasm" files to a path with a namespace
+    build.onResolve({ filter: /\.wasm$/ }, args => {
+      // If this is the import inside the stub module, import the
+      // binary itself. Put the path in the "wasm-binary" namespace
+      // to tell our binary load callback to load the binary file.
+      if (args.namespace === 'wasm-stub') {
+        return {
+          path: args.path,
+          namespace: 'wasm-binary',
+        }
+      }
+
+      // Otherwise, generate the JavaScript stub module for this
+      // ".wasm" file. Put it in the "wasm-stub" namespace to tell
+      // our stub load callback to fill it with JavaScript.
+      //
+      // Resolve relative paths to absolute paths here since this
+      // resolve callback is given "resolveDir", the directory to
+      // resolve imports against.
+      if (args.resolveDir === '') {
+        return // Ignore unresolvable paths
+      }
+      return {
+        path: path.isAbsolute(args.path) ? args.path : path.join(args.resolveDir, args.path),
+        namespace: 'wasm-stub',
+      }
+    })
+
+    // Virtual modules in the "wasm-stub" namespace are filled with
+    // the JavaScript code for compiling the WebAssembly binary. The
+    // binary itself is imported from a second virtual module.
+    build.onLoad({ filter: /.*/, namespace: 'wasm-stub' }, async (args) => ({
+      contents: `import wasm from ${JSON.stringify(args.path)}
+        export default (imports) => WebAssembly.instantiate(wasm, imports).then((result) => result.instance)`,
+    }))
+
+    // Virtual modules in the "wasm-binary" namespace contain the
+    // actual bytes of the WebAssembly file. This uses esbuild's
+    // built-in "binary" loader instead of manually embedding the
+    // binary data inside JavaScript code ourselves.
+    build.onLoad({ filter: /.*/, namespace: 'wasm-binary' }, async (args) => ({
+      contents: await fs.promises.readFile(args.path),
+      loader: 'binary',
+    }))
+  },
+}

docs/index.css

@@ -0,0 +1,18 @@
+html, body {
+  height: 100vh;
+  margin: 0;
+}
+
+#root {
+  box-sizing: border-box;
+  display: flex;
+  gap: 0.5em;
+  height: 100vh;
+  padding: 0.5em;
+}
+
+textarea {
+  box-sizing: border-box;
+  height: 100%;
+  width: 100%;
+}

docs/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="initial-scale=1, maximum-scale=5">
+    <title>Syntax Tree</title>
+    <link rel="stylesheet" type="text/css" href="index.css">
+  </head>
+  <body>
+    <noscript>JavaScript must be enabled in order to run this application.</noscript>
+    <div id="root"></div>
+    <script type="module" src="index.js"></script>
+  </body>
+</html>

lib/app.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+$:.unshift(File.expand_path("lib", __dir__))
+require "syntax_tree"

package.json

@@ -0,0 +1,22 @@
+{
+  "license": "MIT",
+  "scripts": {
+    "build": "bin/build",
+    "serve": "bin/serve"
+  },
+  "dependencies": {
+    "@wasmer/wasi": "^0.12.0",
+    "@wasmer/wasmfs": "^0.12.0",
+    "path-browserify": "^1.0.1",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "ruby-head-wasm-wasi": "^0.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^17.0.27",
+    "@types/path-browserify": "^1.0.0",
+    "@types/react": "^18.0.6",
+    "@types/react-dom": "^18.0.2",
+    "esbuild": "^0.14.38"
+  }
+}

src/createRuby.ts

@@ -0,0 +1,86 @@
+import { WASI } from "@wasmer/wasi";
+import { WasmFs } from "@wasmer/wasmfs";
+import path from "path-browserify";
+import { RubyVM } from "ruby-head-wasm-wasi/dist/index";
+
+import load from "./app.wasm";
+
+// This overwrites the default writeSync function used by the WasmFs to instead
+// pipe it out to the console.
+function createWriter(originalWriter: Function) {
+  return function () {
+    let text: string;
+
+    if (arguments.length === 4) {
+      text = arguments[1];
+    } else {
+      text = new TextDecoder("utf-8").decode(arguments[1]);
+    }
+
+    switch (arguments[0]) {
+      case 1:
+        console.log(text);
+        break;
+      case 2:
+        console.warn(text);
+        break;
+    }
+
+    return originalWriter.call(arguments);
+  }
+}
+
+export default async function createRuby() {
+  // First, create a new file system that we can use internally within the Ruby
+  // WASM VM.
+  const wasmFs = new WasmFs();
+  wasmFs.fs.mkdirSync("/tmp", 0o777);
+  wasmFs.fs.writeSync = createWriter(wasmFs.fs.writeSync.bind(wasmFs.fs));
+
+  // Next, create a new WASI instance with the correct options overridden from
+  // the defaults.
+  const wasi = new WASI({
+    bindings: { ...WASI.defaultBindings, fs: wasmFs.fs, path: path },
+    preopens: { "/": "/tmp" }
+  });
+
+  // Then, create a new Ruby VM instance that we can use to store the memory for
+  // our application.
+  const ruby = new RubyVM();
+  const imports = { wasi_snapshot_preview1: wasi.wasiImport };
+  ruby.addToImports(imports);
+
+  // Set the WASI memory to use the memory for our application.
+  const instance = await load(imports);
+  wasi.setMemory(instance.exports.memory);
+
+  // Load our application into the virtual machine.
+  instance.exports._initialize();
+  await ruby.setInstance(instance);
+
+  // Initial our virtual machine and return it. It should now be able to
+  // evaluate and execute Ruby code.
+  ruby.initialize();
+
+  // Once our virtual machine is booted, we're going to require the necessary
+  // files to make it work. I'm not sure why I need to explicitly require
+  // did_you_mean here, but it doesn't work without it.
+  ruby.eval(`require "did_you_mean"; require "json"; require_relative "/lib/app"`);
+
+  return {
+    // A function that calls through to PP to get the pretty-printed version of
+    // the syntax tree.
+    prettyPrint(source: string) {
+      const rubySource = `
+        PP.format([], 80) do |q|
+          source = JSON.parse(${JSON.stringify(JSON.stringify(source))})
+          SyntaxTree.parse(source).pretty_print(q)
+        end.join
+      `;
+    
+      return ruby.eval(rubySource).toString();
+    }
+  };
+};
+
+export type Ruby = Awaited<ReturnType<typeof createRuby>>;