wasmify-rails 0.1.0

data/lib/generators/wasmify/pwa/templates/pwa/index.html

@@ -0,0 +1,2 @@
+<meta http-equiv="Refresh" content="0; url=/boot.html" />
+<p>Please follow <a href="/boot.html">this link</a>.</p>

data/lib/generators/wasmify/pwa/templates/pwa/package.json.tt

@@ -0,0 +1,20 @@
+{
+  "name": "wasmify-rails-starter",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "packageManager": "yarn@1.22.22",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "vite": "^5.4.7",
+    "vite-plugin-pwa": "^0.20.5"
+  },
+  "dependencies": {
+    "wasmify-rails": "^<%= wasmify_rails_version %>",
+    "@sqlite.org/sqlite-wasm": "3.46.1-build3"
+  }
+}

data/lib/generators/wasmify/pwa/templates/pwa/rails.sw.js

@@ -0,0 +1,115 @@
+import {
+  initRailsVM,
+  Progress,
+  registerSQLiteWasmInterface,
+  RackHandler,
+} from "wasmify-rails";
+
+import { setupSQLiteDatabase } from "./database.js";
+
+let db = null;
+
+const initDB = async (progress) => {
+  if (db) return db;
+
+  progress.updateStep("Initializing SQLite database...");
+  db = await setupSQLiteDatabase();
+  progress.updateStep("SQLite database created.");
+};
+
+let vm = null;
+
+const initVM = async (progress, opts = {}) => {
+  if (vm) return vm;
+
+  if (!db) {
+    await initDB(progress);
+  }
+
+  registerSQLiteWasmInterface(self, db);
+
+  let redirectConsole = true;
+
+  vm = await initRailsVM("/app.wasm", {
+    database: { adapter: "sqlite3_wasm" },
+    progressCallback: (step) => {
+      progress?.updateStep(step);
+    },
+    outputCallback: (output) => {
+      if (!redirectConsole) return;
+      progress?.notify(output);
+    },
+    ...opts,
+  });
+
+  // Ensure schema is loaded
+  progress?.updateStep("Preparing database...");
+  vm.eval("ActiveRecord::Tasks::DatabaseTasks.prepare_all");
+
+  redirectConsole = false;
+};
+
+const resetVM = () => {
+  vm = null;
+};
+
+const installApp = async () => {
+  const progress = new Progress();
+  await progress.attach(self);
+
+  await initDB(progress);
+  await initVM(progress);
+};
+
+self.addEventListener("activate", (event) => {
+  console.log("[rails-web] Activate Service Worker");
+});
+
+self.addEventListener("install", (event) => {
+  console.log("[rails-web] Install Service Worker");
+  event.waitUntil(installApp());
+});
+
+const rackHandler = new RackHandler(initVM, { assumeSSL: true });
+
+self.addEventListener("fetch", (event) => {
+  const bootResources = ["/boot", "/boot.js", "/boot.html", "/rails.sw.js"];
+
+  if (
+    bootResources.find((r) => new URL(event.request.url).pathname.endsWith(r))
+  ) {
+    console.log(
+      "[rails-web] Fetching boot files from network:",
+      event.request.url,
+    );
+    event.respondWith(fetch(event.request.url));
+    return;
+  }
+
+  const viteResources = ["node_modules", "@vite"];
+
+  if (viteResources.find((r) => event.request.url.includes(r))) {
+    console.log(
+      "[rails-web] Fetching Vite files from network:",
+      event.request.url,
+    );
+    event.respondWith(fetch(event.request.url));
+    return;
+  }
+
+  return event.respondWith(rackHandler.handle(event.request));
+});
+
+self.addEventListener("message", async (event) => {
+  console.log("[rails-web] Received worker message:", event.data);
+
+  if (event.data.type === "reload-rails") {
+    const progress = new Progress();
+    await progress.attach(self);
+
+    progress.updateStep("Reloading Rails application...");
+
+    resetVM();
+    await initVM(progress, { debug: event.data.debug });
+  }
+});

data/lib/generators/wasmify/pwa/templates/pwa/vite.config.js

@@ -0,0 +1,29 @@
+import { defineConfig } from "vite";
+import { VitePWA } from "vite-plugin-pwa";
+
+export default defineConfig({
+  server: {
+    headers: {
+      "Cross-Origin-Opener-Policy": "same-origin",
+      "Cross-Origin-Embedder-Policy": "require-corp",
+    },
+  },
+  optimizeDeps: {
+    exclude: ["@sqlite.org/sqlite-wasm"],
+  },
+  plugins: [
+    VitePWA({
+      srcDir: ".",
+      filename: "rails.sw.js",
+      strategies: "injectManifest",
+      injectRegister: false,
+      manifest: false,
+      injectManifest: {
+        injectionPoint: null,
+      },
+      devOptions: {
+        enabled: true,
+      },
+    }),
+  ],
+});

data/lib/image_processing/null.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ImageProcessing
+  # Null processor for image_processing that keeps source files untouched
+  # and copy them to the destination if provided.
+  module Null
+    extend Chainable
+
+    def self.valid_image?(file) = true
+
+    class Processor < ImageProcessing::Processor
+      def self.call(source:, loader:, operations:, saver:, destination: nil)
+        fail ArgumentError, "A string path is expected, got #{source.class}" unless source.is_a?(String)
+        fail ArgumentError, "File not found: #{source}" unless File.file?(source)
+
+        if destination
+          FileUtils.cp(source, destination)
+        end
+      end
+    end
+  end
+end

data/lib/wasmify/rails/builder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "wasmify-rails"
+
+require "ruby_wasm"
+require "ruby_wasm/cli"
+
+module Wasmify
+  module Rails
+    # A wrapper for rbwasm build command
+    class Builder
+      ORIGINAL_EXCLUDED_GEMS = RubyWasm::Packager::EXCLUDED_GEMS.dup.freeze
+
+      attr_reader :output_dir
+
+      def initialize(output_dir: Wasmify::Rails.config.tmp_dir)
+        @output_dir = output_dir
+      end
+
+      def run(name:, exclude_gems: [])
+        # Reset excluded gems
+        RubyWasm::Packager::EXCLUDED_GEMS.replace(ORIGINAL_EXCLUDED_GEMS)
+
+        # Add configured excluded gems
+        Wasmify::Rails.config.exclude_gems.each do |gem_name|
+          RubyWasm::Packager::EXCLUDED_GEMS << gem_name
+        end
+
+        # Add additional excluded gems
+        exclude_gems.each do |gem_name|
+          RubyWasm::Packager::EXCLUDED_GEMS << gem_name
+        end
+
+        args = %W(
+          build
+          --ruby-version #{Wasmify::Rails.config.short_ruby_version}
+          -o #{File.join(output_dir, name)}
+        )
+
+        FileUtils.mkdir_p(output_dir)
+        RubyWasm::CLI.new(stdout: $stdout, stderr: $stderr).run(args)
+      end
+    end
+  end
+end

data/lib/wasmify/rails/configuration.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Wasmify
+  module Rails
+    class Configuration
+      attr_reader :pack_directories, :exclude_gems, :ruby_version,
+                  :tmp_dir, :output_dir,
+                  :skip_assets_precompile
+
+      def initialize
+        config_path = ::Rails.root.join("config", "wasmify.yml")
+        raise "config/wasmify.yml not found" unless File.exist?(config_path)
+
+        config = YAML.load_file(config_path)
+
+        @pack_directories = config["pack_directories"]
+        @exclude_gems = config["exclude_gems"]
+        @ruby_version = config["ruby_version"] || ruby_version_from_file || "3.3"
+        @tmp_dir = config["tmp_dir"] || ::Rails.root.join("tmp", "wasmify")
+        @output_dir = config["output_dir"] || ::Rails.root.join("dist")
+        @skip_assets_precompile = config["skip_assets_precompile"] || false
+      end
+
+      def short_ruby_version
+        if (matches = ruby_version.match(/^(\d+\.\d+)/))
+          matches[1]
+        else
+          ruby_version
+        end
+      end
+
+      private
+
+      def ruby_version_from_file
+        return unless File.file?(::Rails.root.join(".ruby-version"))
+
+        File.read(::Rails.root.join(".ruby-version")).strip
+      end
+    end
+  end
+end

data/lib/wasmify/rails/packer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "wasmify-rails"
+require "tmpdir"
+
+module Wasmify
+  module Rails
+    # A wrapper for wasi-vfs to add application source code to the
+    # ruby.wasm module
+    class Packer
+      ROOT_FILES = %w[Gemfile config.ru .ruby-version Rakefile]
+
+      attr_reader :output_dir
+
+      include ActionView::Helpers::NumberHelper
+
+      def initialize(output_dir: Wasmify::Rails.config.output_dir)
+        @output_dir = output_dir
+      end
+
+      def run(ruby_wasm_path:, name:, directories: Wasmify::Rails.config.pack_directories, storage_dir: nil)
+        unless system("which wasi-vfs > /dev/null 2>&1")
+          raise "wasi-vfs is required to pack the application.\n"
+               "Please see installations instructions at: https://github.com/kateinoigakukun/wasi-vfs"
+        end
+
+        args = %W[
+          pack #{ruby_wasm_path}
+        ]
+
+        directories.each do |dir|
+          args << "--dir #{::Rails.root.join(dir)}::/rails/#{dir}"
+        end
+
+        output_path = File.join(output_dir, name)
+
+        FileUtils.mkdir_p(output_dir)
+
+        # Generate a temporary directory with the require root files
+        Dir.mktmpdir do |tdir|
+          ROOT_FILES.each do |file|
+            FileUtils.cp(::Rails.root.join(file), tdir) if File.exist?(::Rails.root.join(file))
+          end
+
+          # Create a storage/ directory for Active Storage attachments
+          FileUtils.mkdir_p(File.join(tdir, storage_dir)) if storage_dir
+
+          args << "--dir #{tdir}::/rails"
+
+          args << "-o #{output_path}"
+
+          spawn("wasi-vfs #{args.join(" ")}").then { Process.wait(_1) }
+        end
+
+        $stdout.puts "Packed the application to #{output_path}\n" \
+                     "Size: #{number_to_human_size(File.size(output_path))}"
+      end
+    end
+  end
+end

data/lib/wasmify/rails/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Wasmify
+  module Rails
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load "wasmify/rails/tasks.rake"
+      end
+    end
+  end
+end

data/lib/wasmify/rails/shim.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# First, expose the global #on_wasm? helper
+module Kernel
+  if RUBY_PLATFORM.include?("wasm")
+    def on_wasm? = true
+  else
+    def on_wasm? = false
+  end
+end
+
+# Only load shims when running within a Wasm runtime
+return unless on_wasm?
+
+# Setup Bundler
+require "/bundle/setup"
+require "bundler"
+
+# Load core classes and deps patches
+$LOAD_PATH.unshift File.expand_path("shims", __dir__)
+
+# Misc patches
+
+# Make gem no-op
+define_singleton_method(:gem) { |*| nil }
+
+# Patch Bundler.require to simply require files without looking at specs
+def Bundler.require(*groups)
+  Bundler.definition.dependencies_for([:wasm]).each do |dep|
+    required_file = nil
+    # Based on https://github.com/rubygems/rubygems/blob/8a079e9061ad4aaf2bc0b9007da8f362b7a2e1f2/bundler/lib/bundler/runtime.rb#L57
+    begin
+      Array(dep.autorequire || dep.name).each do |file|
+        file = dep.name if file == true
+        required_file = file
+        begin
+          Kernel.require file
+        rescue RuntimeError => e
+          raise e if e.is_a?(LoadError) # we handle this a little later
+          raise Bundler::GemRequireError.new e,
+            "There was an error while trying to load the gem '#{file}'."
+        end
+      end
+    rescue LoadError => e
+      raise if dep.autorequire || e.path != required_file
+
+      if dep.autorequire.nil? && dep.name.include?("-")
+        begin
+          namespaced_file = dep.name.tr("-", "/")
+          Kernel.require namespaced_file
+        rescue LoadError => e
+          raise if e.path != namespaced_file
+        end
+      end
+    end
+  end
+end
+
+class Thread
+  def self.new(...)
+    f = Fiber.new(...)
+    def f.value = resume
+    f
+  end
+end

data/lib/wasmify/rails/shims/io/console.rb

@@ -0,0 +1,11 @@
+class IO
+  def winsize
+    [80, 24]
+  end
+  def wait_readable(timeout = nil)
+    false
+  end
+  def raw(**kwargs)
+    yield
+  end
+end

data/lib/wasmify/rails/shims/ipaddr.rb

@@ -0,0 +1,7 @@
+class IPAddr
+  def initialize(addr)
+    @addr = addr
+  end
+
+  def to_s = @addr
+end

data/lib/wasmify/rails/shims/rails-html-sanitizer.rb

@@ -0,0 +1,163 @@
+module Rails
+  module HTML
+    class Scrubber
+      CONTINUE = Object.new.freeze
+
+      attr_accessor :tags, :attributes
+      attr_reader :prune
+
+      def initialize(**)
+      end
+
+      def scrub(node) = CONTINUE
+    end
+
+    PermitScrubber = Scrubber
+    TargetScrubber = Scrubber
+    TextOnlyScrubber = Scrubber
+
+    class Sanitizer
+      class << self
+        def html5_support? = true
+        def best_supported_vendor = NullSanitizer
+      end
+    end
+
+    module Concern
+      module SafeList
+        # The default safe list for tags
+        DEFAULT_ALLOWED_TAGS = Set.new([
+                                          "a",
+                                          "abbr",
+                                          "acronym",
+                                          "address",
+                                          "b",
+                                          "big",
+                                          "blockquote",
+                                          "br",
+                                          "cite",
+                                          "code",
+                                          "dd",
+                                          "del",
+                                          "dfn",
+                                          "div",
+                                          "dl",
+                                          "dt",
+                                          "em",
+                                          "h1",
+                                          "h2",
+                                          "h3",
+                                          "h4",
+                                          "h5",
+                                          "h6",
+                                          "hr",
+                                          "i",
+                                          "img",
+                                          "ins",
+                                          "kbd",
+                                          "li",
+                                          "mark",
+                                          "ol",
+                                          "p",
+                                          "pre",
+                                          "samp",
+                                          "small",
+                                          "span",
+                                          "strong",
+                                          "sub",
+                                          "sup",
+                                          "time",
+                                          "tt",
+                                          "ul",
+                                          "var",
+                                        ]).freeze
+
+        # The default safe list for attributes
+        DEFAULT_ALLOWED_ATTRIBUTES = Set.new([
+                                                "abbr",
+                                                "alt",
+                                                "cite",
+                                                "class",
+                                                "datetime",
+                                                "height",
+                                                "href",
+                                                "lang",
+                                                "name",
+                                                "src",
+                                                "title",
+                                                "width",
+                                                "xml:lang",
+                                              ]).freeze
+
+        def self.included(klass)
+          class << klass
+            attr_accessor :allowed_tags
+            attr_accessor :allowed_attributes
+          end
+
+          klass.allowed_tags = DEFAULT_ALLOWED_TAGS.dup
+          klass.allowed_attributes = DEFAULT_ALLOWED_ATTRIBUTES.dup
+        end
+
+        def initialize(prune: false)
+          @permit_scrubber = PermitScrubber.new(prune: prune)
+        end
+
+        def scrub(fragment, options = {})
+          if scrubber = options[:scrubber]
+            # No duck typing, Loofah ensures subclass of Loofah::Scrubber
+            fragment.scrub!(scrubber)
+          elsif allowed_tags(options) || allowed_attributes(options)
+            @permit_scrubber.tags = allowed_tags(options)
+            @permit_scrubber.attributes = allowed_attributes(options)
+            fragment.scrub!(@permit_scrubber)
+          else
+            fragment.scrub!(:strip)
+          end
+        end
+
+        def sanitize_css(style_string)
+          Loofah::HTML5::Scrub.scrub_css(style_string)
+        end
+
+        private
+          def allowed_tags(options)
+            options[:tags] || self.class.allowed_tags
+          end
+
+          def allowed_attributes(options)
+            options[:attributes] || self.class.allowed_attributes
+          end
+      end
+    end
+
+    # TODO: That should be a real sanitizer (backed by JS or another external interface)
+    class NullSanitizer
+      class << self
+        def safe_list_sanitizer = self
+      end
+
+      def sanitize(html, ...) = html
+      def sanitize_css(style) = style
+    end
+  end
+
+  module HTML4
+    Sanitizer = HTML::NullSanitizer
+    FullSanitizer = Sanitizer
+    LinkSanitizer = Sanitizer
+
+    class SafeListSanitizer < Sanitizer
+      include HTML::Concern::SafeList
+    end
+  end
+
+  Html = HTML
+
+  module HTML
+    FullSanitizer = HTML4::FullSanitizer
+    LinkSanitizer = HTML4::LinkSanitizer
+    SafeListSanitizer = HTML4::SafeListSanitizer
+    WhiteListSanitizer = SafeListSanitizer
+  end
+end

data/lib/wasmify/rails/shims/socket.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class BasicSocket
+  def initialize(...)
+    raise NotImplementedError, "Socket is not supported in Wasm"
+  end
+end
+
+class Socket < BasicSocket
+  AF_UNSPEC = 0
+  AF_INET = 1
+end
+
+class IPSocket < Socket
+  def self.getaddress(...)
+    raise NotImplementedError, "Socket is not supported in Wasm"
+  end
+end
+
+class TCPSocket < Socket
+end