wasm_rails 0.1.0

data/lib/wasm_rails.rb

@@ -0,0 +1,8 @@
+require "wasm_rails/version"
+require "wasm_rails/railtie" if defined?(Rails)
+
+module WasmRails
+  def self.wasm?
+    RUBY_PLATFORM == "wasm32-wasi"
+  end
+end

data/wasm_stubs/io/console/size.rb

@@ -0,0 +1,8 @@
+# WASM stub — io/console/size is a C extension not available in ruby+stdlib.wasm.
+# Returns a fixed terminal size since WASM has no real console.
+
+class IO
+  def self.console_size = [24, 80]
+  def self.default_console_size = [24, 80]
+  def winsize = [24, 80]
+end

data/wasm_stubs/io/wait.rb

@@ -0,0 +1,6 @@
+# WASM stub — io/wait C extension not available in ruby+stdlib.wasm.
+class IO
+  def wait_readable(timeout = nil) = self
+  def wait_writable(timeout = nil) = self
+  def ready? = false
+end

data/wasm_stubs/loofah.rb

@@ -0,0 +1,39 @@
+# WASM stub — Loofah depends on Nokogiri which is not available in WASM.
+# Provides minimal interface for rails-html-sanitizer to load.
+
+require "nokogiri"
+
+module Loofah
+  VERSION = "2.25.1"
+
+  def self.document(html, *) = Nokogiri::HTML::Document.new(html.to_s)
+  def self.fragment(html, *) = Nokogiri::HTML::DocumentFragment.new(html.to_s)
+  def self.scrub_document(html, scrubber) = document(html)
+  def self.scrub_fragment(html, scrubber) = fragment(html)
+
+  class Scrubber
+    STOP = :stop
+    CONTINUE = nil
+    attr_accessor :direction
+    def initialize(**opts); @direction = opts[:direction] || :bottom_up; end
+    def scrub(node) = nil
+  end
+
+  class StripScrubber    < Scrubber; end
+  class WhitelistScrubber < Scrubber; end
+  class SafeListScrubber  < Scrubber; end
+
+  module HTML5
+    def self.parse(html, *) = Nokogiri::HTML::Document.new(html.to_s)
+    def self.fragment(html, *) = Nokogiri::HTML::DocumentFragment.new(html.to_s)
+
+    class Document         < Nokogiri::HTML::Document; end
+    class DocumentFragment < Nokogiri::HTML::DocumentFragment; end
+    class SafeDocument         < Document; end
+    class SafeDocumentFragment < DocumentFragment; end
+  end
+
+  module XssFoliate
+    def self.included(base); end
+  end
+end

data/wasm_stubs/nokogiri.rb

@@ -0,0 +1,67 @@
+# WASM stub — Nokogiri is a C extension not available in ruby+stdlib.wasm.
+# Provides minimal classes so loofah and rails-html-sanitizer can load.
+
+module Nokogiri
+  VERSION        = "1.18.0"
+  LIBXML_VERSION = "2.9.14"
+
+  module HTML
+    def self.parse(html, url = nil, encoding = nil, options = 0)
+      Document.new(html.to_s)
+    end
+    def self.fragment(html, encoding = nil, options = 0)
+      DocumentFragment.new(html.to_s)
+    end
+
+    class Document
+      def initialize(html = ""); @html = html.to_s; end
+      def to_s = @html
+      def text = @html.gsub(/<[^>]+>/, "")
+      def inner_html = @html
+      def css(*) = NodeSet.new
+      def xpath(*) = NodeSet.new
+      def search(*) = NodeSet.new
+      def at_css(*) = nil
+      def at_xpath(*) = nil
+      def encoding = "UTF-8"
+      def errors = []
+    end
+
+    class DocumentFragment < Document; end
+  end
+
+  HTML4 = HTML
+
+  module XML
+    Node = HTML::Document
+
+    class Document < HTML::Document; end
+    class DocumentFragment < HTML::DocumentFragment; end
+
+    class NodeSet
+      include Enumerable
+      def initialize(items = []) = @items = items
+      def each(&b) = @items.each(&b)
+      def to_s = @items.map(&:to_s).join
+      def text = @items.map { |n| n.respond_to?(:text) ? n.text : n.to_s }.join
+      def size = @items.size
+      def empty? = @items.empty?
+      def [](i) = @items[i]
+      def first = @items.first
+      def css(*) = NodeSet.new
+      def xpath(*) = NodeSet.new
+    end
+
+    module SAX
+      class Document; end
+      class Parser
+        def initialize(doc = nil); end
+        def parse(data); end
+      end
+    end
+  end
+
+  module CSS
+    def self.xpath_for(*) = ""
+  end
+end

data/wasm_stubs/openssl.rb

@@ -0,0 +1,122 @@
+# WASM stub — OpenSSL C extension is not included in ruby+stdlib.wasm.
+# Provides the minimal interface ActiveSupport needs for MessageEncryptor,
+# MessageVerifier, and EncryptedConfiguration at load time.
+# Real encryption is not used in WASM (no server secrets, local-only data).
+
+module OpenSSL
+  VERSION = "3.0.0"
+  OPENSSL_VERSION = "OpenSSL 3.0.0 (wasm stub)"
+
+  # Must be a class (not module) so that SHA256 < OpenSSL::Digest returns true.
+  # ActiveSupport::KeyGenerator checks this with klass < OpenSSL::Digest.
+  class Digest
+    def self.hexdigest(data)
+      require "digest"
+      ::Digest::SHA256.hexdigest(data.to_s)
+    end
+    def self.digest(data) = [self.hexdigest(data)].pack("H*")
+    def hexdigest(data)   = self.class.hexdigest(data)
+    def digest(data)      = self.class.digest(data)
+    def initialize(*); end
+    def update(*); self; end
+    def reset; self; end
+    def finish = ""
+
+    class SHA1 < Digest
+      def self.hexdigest(data)
+        require "digest"; ::Digest::SHA1.hexdigest(data.to_s)
+      end
+    end
+
+    class SHA256 < Digest
+      def self.hexdigest(data)
+        require "digest"; ::Digest::SHA256.hexdigest(data.to_s)
+      end
+    end
+
+    class SHA384 < Digest
+      def self.hexdigest(data)
+        require "digest"; ::Digest::SHA384.hexdigest(data.to_s)
+      end
+    end
+
+    class SHA512 < Digest
+      def self.hexdigest(data)
+        require "digest"; ::Digest::SHA512.hexdigest(data.to_s)
+      end
+    end
+  end
+
+  # Real OpenSSL::Cipher is a class (not a module), so .new works directly.
+  class Cipher
+    CipherError = Class.new(StandardError)
+
+    def initialize(algo); @algo = algo.to_s; end
+    def authenticated?; @algo.upcase.include?("GCM") || @algo.upcase.include?("CCM"); end
+    def encrypt; self; end
+    def decrypt; self; end
+    def key=(k); end
+    def iv=(v); end
+    def iv_len = 12
+    def key_len = 32
+    def padding=(v); end
+    def auth_data=(d); end
+    def auth_tag(len = 16) = ("\x00" * (len || 16))
+    def auth_tag=(t); end
+    def update(data) = data
+    def final = ""
+    def random_key = ("\x00" * 32)
+    def random_iv  = ("\x00" * 12)
+    def block_size = 16
+
+    class AES < Cipher; end
+  end
+
+  module HMAC
+    def self.digest(digest, key, data) = ""
+    def self.hexdigest(digest, key, data) = ("00" * 32)
+  end
+
+  module PKCS5
+    def self.pbkdf2_hmac(secret, salt, iterations, length, digest)
+      require "digest"
+      base = ::Digest::SHA256.digest("#{secret}:#{salt}:#{iterations}")
+      (base * ((length / 32) + 2))[0, length]
+    end
+  end
+
+  module KDF
+    def self.hkdf(secret, salt:, info:, length:, hash:) = ("\x00" * length)
+  end
+
+  module Random
+    def self.random_bytes(n = 16) = SecureRandom.random_bytes(n)
+  end
+
+  module PKey
+    class PKey; end
+    class RSA < PKey
+      def initialize(*); end
+      def public_key = self
+      def private? = false
+      def sign(*) = ""
+      def verify(*) = false
+    end
+  end
+
+  module SSL
+    VERIFY_NONE = 0
+    VERIFY_PEER = 1
+  end
+
+  class BN
+    def initialize(n = 0, base = 10); @n = n.to_i; end
+    def to_i = @n
+    def to_s(base = 10) = @n.to_s(base)
+  end
+
+  class X509
+    class Certificate; end
+    class Store; end
+  end
+end

data/wasm_stubs/rails-html-sanitizer.rb

@@ -0,0 +1,89 @@
+# WASM stub — rails-html-sanitizer depends on loofah+nokogiri.
+# In WASM, all data is user-local, so sanitizers pass through without modification.
+# Defines both Rails::Html (legacy) and Rails::HTML4/HTML5 (rails-html-sanitizer 1.6+).
+
+require "loofah"
+
+module Rails
+  # Base sanitizer shared by all namespaces
+  module HtmlSanitizerBase
+    class Sanitizer
+      def sanitize(html, options = {}) = html.to_s
+      def self.full_sanitizer        = FullSanitizer.new
+      def self.link_sanitizer        = LinkSanitizer.new
+      def self.safe_list_sanitizer   = SafeListSanitizer.new
+      def self.white_list_sanitizer  = safe_list_sanitizer
+      def self.best_supported_vendor = Rails::HTML4
+    end
+
+    class FullSanitizer < Sanitizer
+      def sanitize(html, options = {})
+        return "" if html.nil?
+        html.to_s.gsub(/<[^>]+>/, "")
+      end
+    end
+
+    class LinkSanitizer     < Sanitizer; end
+    class SafeListSanitizer < Sanitizer; end
+    WhiteListSanitizer = SafeListSanitizer
+
+    module Scrubbers
+      class Strip    < ::Loofah::Scrubber; end
+      class SafeList < ::Loofah::Scrubber; end
+      WhiteList = SafeList
+    end
+  end
+
+  # Legacy namespace (rails-html-sanitizer < 1.6)
+  module Html
+    include HtmlSanitizerBase
+    Sanitizer         = HtmlSanitizerBase::Sanitizer
+    FullSanitizer     = HtmlSanitizerBase::FullSanitizer
+    LinkSanitizer     = HtmlSanitizerBase::LinkSanitizer
+    SafeListSanitizer = HtmlSanitizerBase::SafeListSanitizer
+    WhiteListSanitizer = SafeListSanitizer
+    Scrubbers         = HtmlSanitizerBase::Scrubbers
+  end
+
+  # Rails::HTML is the top-level namespace referenced by railties load_defaults
+  module HTML
+    Sanitizer         = HtmlSanitizerBase::Sanitizer
+    FullSanitizer     = HtmlSanitizerBase::FullSanitizer
+    LinkSanitizer     = HtmlSanitizerBase::LinkSanitizer
+    SafeListSanitizer = HtmlSanitizerBase::SafeListSanitizer
+    WhiteListSanitizer = SafeListSanitizer
+    Scrubbers         = HtmlSanitizerBase::Scrubbers
+
+    def self.best_supported_vendor = Rails::HTML4
+  end
+
+  # New namespaces (rails-html-sanitizer 1.6+ / Rails 8)
+  # ActionView::SanitizeHelper defaults to Rails::HTML4
+  module HTML4
+    Sanitizer         = HtmlSanitizerBase::Sanitizer
+    FullSanitizer     = HtmlSanitizerBase::FullSanitizer
+    LinkSanitizer     = HtmlSanitizerBase::LinkSanitizer
+    SafeListSanitizer = HtmlSanitizerBase::SafeListSanitizer
+    WhiteListSanitizer = SafeListSanitizer
+    Scrubbers         = HtmlSanitizerBase::Scrubbers
+
+    def self.full_sanitizer        = FullSanitizer.new
+    def self.link_sanitizer        = LinkSanitizer.new
+    def self.safe_list_sanitizer   = SafeListSanitizer.new
+    def self.best_supported_vendor = self
+  end
+
+  module HTML5
+    Sanitizer         = HtmlSanitizerBase::Sanitizer
+    FullSanitizer     = HtmlSanitizerBase::FullSanitizer
+    LinkSanitizer     = HtmlSanitizerBase::LinkSanitizer
+    SafeListSanitizer = HtmlSanitizerBase::SafeListSanitizer
+    WhiteListSanitizer = SafeListSanitizer
+    Scrubbers         = HtmlSanitizerBase::Scrubbers
+
+    def self.full_sanitizer        = FullSanitizer.new
+    def self.link_sanitizer        = LinkSanitizer.new
+    def self.safe_list_sanitizer   = SafeListSanitizer.new
+    def self.best_supported_vendor = self
+  end
+end

data/wasm_stubs/resolv.rb

@@ -0,0 +1,19 @@
+# WASM stub — DNS resolution not available in browser WASM.
+module Resolv
+  def self.getaddress(name) = "127.0.0.1"
+  def self.getaddresses(name) = ["127.0.0.1"]
+  def self.getname(addr) = "localhost"
+  def self.getnames(addr) = ["localhost"]
+
+  class DNS; end
+  class IPv4
+    def self.create(addr) = new(addr)
+    def initialize(addr); @addr = addr; end
+    def to_s = @addr
+  end
+  class IPv6
+    def self.create(addr) = new(addr)
+    def initialize(addr); @addr = addr; end
+    def to_s = @addr
+  end
+end

data/wasm_stubs/socket.rb

@@ -0,0 +1,47 @@
+# WASM stub — socket C extension is not available in ruby+stdlib.wasm.
+# Provides the constants and classes that ipaddr, activesupport, and railties need.
+
+class BasicSocket; end
+
+class Socket < BasicSocket
+  AF_UNSPEC    = 0
+  AF_UNIX      = 1
+  AF_INET      = 2
+  AF_INET6     = 10
+  AF_LOCAL     = 1
+  SOCK_STREAM  = 1
+  SOCK_DGRAM   = 2
+  SOCK_RAW     = 3
+  IPPROTO_IP   = 0
+  IPPROTO_TCP  = 6
+  IPPROTO_UDP  = 17
+  IPPROTO_IPV6 = 41
+  IPPORT_RESERVED = 1024
+
+  def self.gethostname = "localhost"
+  def self.getaddrinfo(*) = []
+  def self.gethostbyname(*) = nil
+  def self.gethostbyaddr(*) = nil
+  def self.ip_address_list = []
+  def self.pack_sockaddr_in(port, host) = ""
+  def self.unpack_sockaddr_in(addr) = [0, "127.0.0.1"]
+end
+
+class Addrinfo
+  attr_reader :afamily, :pfamily, :socktype, :protocol
+  def initialize(*); end
+  def self.getaddrinfo(*) = []
+  def self.tcp(host, port) = new
+  def self.udp(host, port) = new
+  def ip? = false
+  def ip_address = "127.0.0.1"
+  def ip_port = 0
+  def ipv4? = false
+  def ipv6? = false
+end
+
+class TCPSocket   < BasicSocket; def initialize(*); end; end
+class TCPServer   < BasicSocket; def initialize(*); end; end
+class UDPSocket   < BasicSocket; def initialize(*); end; end
+class UNIXSocket  < BasicSocket; def initialize(*); end; end
+class UNIXServer  < BasicSocket; def initialize(*); end; end

data/wasm_stubs/sqlite3.rb

@@ -0,0 +1,102 @@
+# WASM stub for the sqlite3 C extension.
+# Loaded via /stubs (prepended to $LOAD_PATH) before any gem path, so
+# `require 'sqlite3'` resolves here instead of trying to load the native .so.
+# Provides enough constants and classes for sqlite3_adapter.rb to load;
+# the actual DB operations are handled by WasmSqlite3Adapter::ExternalInterface.
+
+module SQLite3
+  VERSION = '2.5.0'
+
+  module ForkSafety
+    def self.suppress_warnings!; end
+  end
+
+  class Exception < StandardError; end
+  class BusyException < Exception; end
+  class FullException < Exception; end
+  class IOException < Exception; end
+  class AccessDeniedException < Exception; end
+  class ProtocolException < Exception; end
+  class RangeException < Exception; end
+  class NotADatabaseException < Exception; end
+  class MisuseException < Exception; end
+  class CantOpenException < Exception; end
+  class NotFoundException < Exception; end
+  class CorruptException < Exception; end
+  class ConstraintException < Exception; end
+
+  module Constants
+    module TextRep
+      UTF8    = 1
+      UTF16LE = 2
+      UTF16BE = 3
+      UTF16   = 4
+      ANY     = 5
+    end
+
+    module ColumnType
+      INTEGER = 1
+      FLOAT   = 2
+      TEXT    = 3
+      BLOB    = 4
+      NULL    = 5
+    end
+
+    module Open
+      READONLY  = 0x00000001
+      READWRITE = 0x00000002
+      CREATE    = 0x00000004
+      NOMUTEX   = 0x00008000
+      FULLMUTEX = 0x00010000
+    end
+  end
+
+  module Pragmas; end
+
+  class Statement
+    attr_reader :remainder
+
+    def initialize(db, sql); end
+    def close; end
+    def step; nil; end
+    def columns; []; end
+    def types; []; end
+    def reset!; end
+    def bind_params(*); end
+    def execute(*); []; end
+    def done?; true; end
+    def must_be_open!; end
+    def column_count; 0; end
+  end
+
+  class Database
+    def self.quote(s) = s.gsub("'", "''")
+
+    def initialize(file = '', options = {}); end
+    def close; end
+    def closed?; false; end
+    def execute(sql, *binds); []; end
+    def execute2(sql, *binds); []; end
+    def query(sql, *binds); []; end
+    def prepare(sql); Statement.new(self, sql); end
+    def transaction(mode = :deferred); yield self if block_given?; end
+    def commit; end
+    def rollback; end
+    def changes; 0; end
+    def last_insert_row_id; 0; end
+    def errmsg; ''; end
+    def errcode; 0; end
+    def complete?(sql); true; end
+    def busy_handler_timeout=(v); end
+    def busy_timeout=(v); end
+    def busy_timeout(ms); end
+    def extended_result_codes=(v); end
+    def results_as_hash=(v); end
+    def type_translation=(v); end
+    def encoding; 'UTF-8'; end
+    def authorizer=(v); end
+    def trace(&block); end
+
+    include Pragmas
+  end
+end

data/wasm_stubs/thread.rb

@@ -0,0 +1,10 @@
+# WASM is single-threaded — map Thread to Fiber so gems that spawn threads
+# don't raise. The fiber runs synchronously when .value or .join is called.
+class Thread
+  def self.new(...)
+    f = Fiber.new(...)
+    def f.value = resume
+    def f.join  = value
+    f
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: wasm_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Emerson Argueta
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: Infrastructure gem for building WASM-first Rails apps. Provides a Service
+  Worker that boots Ruby+Rails inside the browser, SQLite persistence via OPFS, build
+  tooling, and C extension stubs.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/generators/wasm_rails/install/install_generator.rb
+- lib/generators/wasm_rails/install/templates/boot.js
+- lib/generators/wasm_rails/install/templates/build_app_bundle.mjs
+- lib/generators/wasm_rails/install/templates/esbuild_wasm.mjs
+- lib/generators/wasm_rails/install/templates/serve_wasm.mjs
+- lib/generators/wasm_rails/install/templates/service_worker.js
+- lib/generators/wasm_rails/install/templates/wasm_shell.html
+- lib/generators/wasm_rails/install/templates/wasm_sqlite3_adapter.rb
+- lib/wasm_rails.rb
+- lib/wasm_rails/railtie.rb
+- lib/wasm_rails/version.rb
+- wasm_stubs/io/console/size.rb
+- wasm_stubs/io/wait.rb
+- wasm_stubs/loofah.rb
+- wasm_stubs/nokogiri.rb
+- wasm_stubs/openssl.rb
+- wasm_stubs/rails-html-sanitizer.rb
+- wasm_stubs/resolv.rb
+- wasm_stubs/socket.rb
+- wasm_stubs/sqlite3.rb
+- wasm_stubs/thread.rb
+homepage: https://github.com/emerson-argueta/wasm-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Run Rails apps in the browser via WebAssembly
+test_files: []