@tutorialkit-rb/cli 1.5.2-rb.0.1.0

package/template/src/templates/crud-products/workspace/store/test/fixtures/products.yml

@@ -0,0 +1,7 @@
+# Read about fixtures at https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+
+one:
+  name: MyString
+
+two:
+  name: MyString

package/template/src/templates/crud-products/workspace/store/test/models/product_test.rb

@@ -0,0 +1,7 @@
+require "test_helper"
+
+class ProductTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

package/template/src/templates/default/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
+
+import initVM from "../lib/rails.js";
+import IRBRepl from "../lib/irb.js";
+
+const vm = await initVM();
+const irb = new IRBRepl(vm);
+
+irb.start();

package/template/src/templates/default/bin/rackup

@@ -0,0 +1,11 @@
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning --watch --watch-path=./
+
+import initVM from "../lib/rails.js";
+import { createRackServer } from "../lib/server.js";
+
+const vm = await initVM();
+const server = await createRackServer(vm);
+
+server.listen(3000, () => {
+  console.log("Server started on port 3000");
+});

package/template/src/templates/default/bin/rails

@@ -0,0 +1,41 @@
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
+
+import initVM from "../lib/rails.js";
+import ExternalCommands from "../lib/commands.js";
+import util from "node:util";
+
+const vm = await initVM({env: {"HOME": "/rails-vm"}});
+const args = util.inspect(process.argv.slice(2));
+const commands = new ExternalCommands();
+// Make commands accessible from Ruby via global JS object
+global.externalCommands = commands;
+
+await vm.evalAsync(`
+  args = ${args}
+  ARGV.replace(args)
+
+  begin
+    if File.file?("config/application.rb")
+      APP_PATH = File.expand_path("config/application", Dir.pwd)
+      require File.expand_path("../boot", APP_PATH)
+      require "rails/commands"
+    else
+      require "rails/command"
+      case ARGV.first
+      when Rails::Command::HELP_MAPPINGS, "help", nil
+        ARGV.shift
+        Rails::Command.invoke :gem_help, ARGV
+      when "plugin"
+        ARGV.shift
+        Rails::Command.invoke :plugin, ARGV
+      else
+        Rails::Command.invoke :application, ARGV
+      end
+    end
+    execute_at_exit_hooks unless Wasmify::ExternalCommands.any?
+  rescue SystemExit
+    # expected, do nothing
+  end
+`)
+
+commands.invoke(vm)

package/template/src/templates/default/bin/ruby

@@ -0,0 +1,37 @@
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
+
+import initVM from "../lib/rails.js";
+import ExternalCommands from "../lib/commands.js";
+import util from "node:util";
+import fs from "node:fs";
+
+const commands = new ExternalCommands();
+// Make commands accessible from Ruby via global JS object
+global.externalCommands = commands;
+
+const args = process.argv.slice(2);
+
+if (args[0] && fs.existsSync(process.cwd() + '/' + args[0])) {
+  const firstLine = fs.readFileSync(process.cwd() + '/' + args[0], 'utf8').split('\n')[0];
+  // Check if called via shebang
+  if (firstLine.includes('#!/usr/bin/env ruby')) {
+    const path = args.shift();
+    const vm = await initVM({ env: { "HOME": "/rails-vm" } });
+
+    await vm.evalAsync(`
+      args = ${util.inspect(args)}
+      ARGV.replace(args)
+
+      begin
+        load "./${path}"
+        execute_at_exit_hooks unless Wasmify::ExternalCommands.any?
+      rescue SystemExit
+      end
+    `);
+
+    commands.invoke(vm)
+  }
+} else {
+  const vm = await initVM({ env: { "HOME": "/rails-vm" }, args, skipRails: true });
+  commands.invoke(vm)
+}

package/template/src/templates/default/lib/commands.js

@@ -0,0 +1,39 @@
+import { createRackServer } from "./server.js";
+import IRBRepl from "./irb.js";
+
+export default class ExternalCommands {
+  constructor() {
+    this.command = undefined;
+  }
+
+  server(port) {
+    this.command = async function(vm) {
+      const server = await createRackServer(vm, {skipRackup: true});
+
+      server.listen(port, () => {
+        console.log(`Express.js server started on port ${port}`);
+        console.log(`Use Ctrl-C to stop`);
+      });
+
+      // FIXME: doesn't work; do WebContainers/jsh support signals at all?
+      process.on('exit', async () => {
+        console.log('Express.js server is shutting down');
+        await vm.evalAsync(`execute_at_exit_hooks`)
+      });
+    }
+  }
+
+  console() {
+    this.command = async function(vm) {
+      const irb = new IRBRepl(vm);
+      return irb.start();
+    }
+  }
+
+  // Invokes a registered command if any
+  invoke(vm) {
+    if (!this.command) return;
+
+    return this.command(vm);
+  }
+}

package/template/src/templates/default/lib/database.js

@@ -0,0 +1,46 @@
+import { PGlite } from '@electric-sql/pglite'
+import { join } from "node:path";
+
+const MULTILINE_RX = /;\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP|TRUNCATE|WITH|EXPLAIN|ANALYZE|VACUUM|GRANT|REVOKE|BEGIN|COMMIT|ROLLBACK)/i
+
+class ExternalInterface {
+  constructor(db, identifier) {
+    this.db = db;
+    this.identifier = identifier;
+  }
+
+  async query(sql, params) {
+    let res;
+
+    if (MULTILINE_RX.test(sql)) {
+      res = (await this.db.exec(sql, params))[0];
+    } else {
+      res = await this.db.query(sql, params);
+    }
+
+    return res
+  }
+}
+
+export class PGLite4Rails {
+  constructor(dataDir) {
+    // Created databases
+    this.dbs = {};
+    // Base directory for all databases
+    this.dataDir = dataDir;
+  }
+
+  async create_interface(dbname) {
+    if (this.dbs[dbname]) return this.dbs[dbname].identifier;
+
+    const dataDir = join(this.dataDir, dbname);
+
+    const db = await PGlite.create({ dataDir })
+    const ei = new ExternalInterface(db, `pglite4rails_${dbname}`)
+
+    const identifier = ei.identifier
+    global[identifier] = this.dbs[dbname] = ei
+
+    return identifier
+  }
+}

package/template/src/templates/default/lib/irb.js

@@ -0,0 +1,110 @@
+import repl from "node:repl";
+
+const isRecoverableError = (error) => {
+  if (error.message.includes('SyntaxError')) {
+    return true;
+  }
+
+  return false;
+}
+
+const rubyWriter = (output) => {
+  if (!output) return;
+
+  if (typeof output === 'string') {
+    return output;
+  }
+
+  return output.toString().replace(/\n$/, "");
+}
+
+export default class IRBRepl {
+  constructor(vm) {
+    this.vm = vm;
+    this.eval = this.eval.bind(this);
+  }
+
+  async eval (cmd, context, filename, callback) {
+    let result;
+    try {
+      result = await this.vm.evalAsync(`
+__code__ = <<~'RUBY'
+${cmd}
+RUBY
+
+$irb.eval_code(__code__)
+`);
+    } catch (e) {
+      if (e.message.includes('SystemExit')) {
+        process.exit();
+      }
+      if (isRecoverableError(e)) {
+        return callback(new repl.Recoverable(e));
+      }
+
+      return callback(null, e.message);
+    }
+    callback(null, result);
+  }
+
+  async start() {
+    // Set up IRB
+    const promptVal = await this.vm.evalAsync(`
+      require "irb"
+
+      STDOUT.sync = true
+      if IRB.conf.empty?
+        ap_path = __FILE__
+        $0 = File::basename(ap_path, ".rb") if ap_path
+        IRB.setup(ap_path)
+      end
+
+      class NonBlockingIO
+        def gets
+          raise NonImplementedError
+        end
+
+        def external_encoding
+          "UTF-8"
+        end
+
+        def wait_readable(timeout = nil)
+          true
+        end
+
+        def getc = "x"
+        def ungetc(c) = nil
+      end
+
+      class IRB::Irb
+        def eval_code(code)
+          statement = parse_input(code)
+
+          context.evaluate(statement, @line_no)
+          @line_no += code.count("\n")
+          context.inspect_last_value
+        rescue SystemExit, SignalException, SyntaxError
+          raise
+        rescue Interrupt, Exception => exc
+          handle_exception(exc)
+          context.workspace.local_variable_set(:_, exc)
+        end
+      end
+
+      $irb = IRB::Irb.new(nil, IRB::StdioInputMethod.new)
+
+      # return configured prompt
+      IRB.conf[:PROMPT][IRB.conf[:PROMPT_MODE]][:PROMPT_I]
+        .gsub(/(%\\d+)?n/, "") # no line number support
+        .then { $irb.send(:format_prompt, _1, nil, 0, 0) }
+    `)
+
+    const prompt = promptVal.toJS()
+    const local = repl.start({prompt, eval: this.eval, writer: rubyWriter});
+
+    local.on('exit', () => {
+      // TODO: save history?
+      process.exit();
+    });
+  }
+}

package/template/src/templates/default/lib/patches/app_generator.rb

@@ -0,0 +1,43 @@
+# Patch Rails app generator to use pglite as a database adapter
+Wasmify::Patcha.on_load("Rails::AppBuilder") do
+  Rails::AppBuilder.prepend(Module.new do
+    def database_yml
+      create_file "config/database.yml" do
+        <<-YAML
+default: &default
+  adapter: pglite
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  timeout: 5000
+
+development:
+  <<: *default
+  database: store_development
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: store_test
+
+production:
+  primary:
+    <<: *default
+    # database: path/to/persistent/storage/production.sqlite3
+  cache:
+    <<: *default
+    # database: path/to/persistent/storage/production_cache.sqlite3
+    migrations_paths: db/cache_migrate
+  queue:
+    <<: *default
+    # database: path/to/persistent/storage/production_queue.sqlite3
+    migrations_paths: db/queue_migrate
+  cable:
+    <<: *default
+    # database: path/to/persistent/storage/production_cable.sqlite3
+    migrations_paths: db/cable_migrate
+        YAML
+      end
+    end
+  end)
+end

package/template/src/templates/default/lib/patches/authentication.rb

@@ -0,0 +1,24 @@
+# Automatically authenticate a user of first request if the corresponding file is present.
+# This way, we can skip the authentication in the second part of the tutorial
+Wasmify::Patcha.on_load("Authentication") do
+  Authentication.prepend(Module.new do
+    def find_session_by_cookie
+      return super if $__pre_authenticated
+
+      $__pre_authenticated = true
+
+      session = super
+
+      return session if session
+
+      return unless Rails.root.join("tmp/authenticated-user.txt").exist?
+
+      $_user_email = Rails.root.join("tmp/authenticated-user.txt").read.chomp
+
+      user = User.find_by(email_address: $_user_email)
+      return unless user
+
+      start_new_session_for(user)
+    end
+  end)
+end

package/template/src/templates/default/lib/rails.js

@@ -0,0 +1,69 @@
+import { RubyVM } from "@ruby/wasm-wasi";
+import { WASI } from "wasi";
+import fs from "fs/promises";
+import { PGLite4Rails } from "./database.js";
+
+const rubyWasm = new URL("../node_modules/@ruby/wasm-wasi/dist/ruby.wasm", import.meta.url).pathname;
+
+const railsRootDir = new URL("../workspace/store", import.meta.url).pathname;
+const pgDataDir = new URL("../pgdata", import.meta.url).pathname;
+
+export default async function initVM(vmopts = {}) {
+  const { args, skipRails } = vmopts;
+  const env = vmopts.env || {};
+  const binary = await fs.readFile(rubyWasm);
+  const module = await WebAssembly.compile(binary);
+
+  const RAILS_ENV = env.RAILS_ENV || process.env.RAILS_ENV;
+  if (RAILS_ENV) env.RAILS_ENV = RAILS_ENV;
+
+  const workspaceDir = new URL("../workspace", import.meta.url).pathname;
+  const workdir = process.cwd().startsWith(workspaceDir) ?
+    `/workspace${process.cwd().slice(workspaceDir.length)}` :
+    "";
+
+  const cliArgs = args?.length ? ['ruby.wasm'].concat(args) : undefined;
+
+  const wasi = new WASI(
+    {
+      env: {"RUBYOPT": "-EUTF-8 -W0", ...env},
+      version: "preview1",
+      returnOnExit: true,
+      preopens: {
+        "/workspace": workspaceDir
+      },
+      args: cliArgs
+    }
+  );
+
+  const { vm } = await RubyVM.instantiateModule({
+    module,
+    wasip1: wasi,
+    args: cliArgs
+  });
+
+  if (!skipRails) {
+    const pglite = new PGLite4Rails(pgDataDir);
+    global.pglite = pglite;
+
+    const authenticationPatch = await fs.readFile(new URL("./patches/authentication.rb", import.meta.url).pathname, 'utf8');
+    const appGeneratorPatch = await fs.readFile(new URL("./patches/app_generator.rb", import.meta.url).pathname, 'utf8');
+
+    vm.eval(`
+      Dir.chdir("${workdir}") unless "${workdir}".empty?
+
+      ENV["RACK_HANDLER"] = "wasi"
+
+      require "/rails-vm/boot"
+
+      require "js"
+
+      Wasmify::ExternalCommands.register(:server, :console)
+
+      ${authenticationPatch}
+      ${appGeneratorPatch}
+    `)
+  }
+
+  return vm;
+}

package/template/src/templates/default/lib/server/frame_location_middleware.js

@@ -0,0 +1,77 @@
+const createFrameLocationTrackingMiddleware = (options = {}) => {
+  const {
+    injectionPoint = '</body>'
+  } = options;
+
+  const trackingScript = `
+    <script>
+      (function() {
+        // Avoid double initialization
+        if (window.__locationTrackingInitialized) return;
+        window.__locationTrackingInitialized = true;
+
+        function notifyParentLocation() {
+          if (window.parent === window) return;
+
+          try {
+            window.parent.postMessage({
+              type: '$locationChange',
+              location: {
+                href: window.location.href,
+              },
+              timestamp: Date.now()
+            }, '*');
+            console.log('notified location change', window.location.href);
+          } catch (e) {
+            console.error('Failed to notify parent:', e);
+          }
+        }
+
+        if (document.readyState === 'loading') {
+          document.addEventListener('DOMContentLoaded', notifyParentLocation);
+        } else {
+          notifyParentLocation();
+        }
+
+        window.addEventListener('popstate', notifyParentLocation);
+        window.addEventListener('hashchange', notifyParentLocation);
+
+        const originalPushState = history.pushState;
+        const originalReplaceState = history.replaceState;
+
+        history.pushState = function() {
+          const result = originalPushState.apply(history, arguments);
+          setTimeout(notifyParentLocation, 0);
+          return result;
+        };
+
+        history.replaceState = function() {
+          const result = originalReplaceState.apply(history, arguments);
+          setTimeout(notifyParentLocation, 0);
+          return result;
+        };
+      })();
+    </script>
+  `;
+
+  return (req, res, next) => {
+    // Store the original send method
+    const originalSend = res.send;
+
+    res.send = function(data) {
+      const contentType = res.get('Content-Type');
+
+      if (contentType && contentType.includes('text/html') && typeof data === 'string') {
+        if (data.includes(injectionPoint)) {
+          data = data.replace(injectionPoint, trackingScript + injectionPoint);
+        }
+      }
+
+      return originalSend.call(this, data);
+    };
+
+    next();
+  };
+};
+
+export default createFrameLocationTrackingMiddleware;