homura-runtime 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6be075dbd944ef333e509df1dce30614231a25eb96e8384fcce5ed5e6e3e58c
-  data.tar.gz: 908dd2b9cc441b2b45946446a7e011deffb94bf2f5f16f649fc0a5c0ee352584
+  metadata.gz: 99d546ac1db58f957cf5bd81723cfc0e15019f11c27c8b0bcd78fc2ee833b751
+  data.tar.gz: 02b08e0580b05b710cfba5d5bc6255ba463a4675a297476583dcacece6b158b6
 SHA512:
-  metadata.gz: 32bb2576d6a2b1cde36f0cc4cac86fac4e797e3628714564d9c337b0c18ebb36166f53f6008e708f36ce250423f6da01dbbae1ed3b6d5c2dc1dcc5acd0643386
-  data.tar.gz: 02166fe7dcb152895f9af50163a7a80bf2c9e3cabdb5d16de7fbd0712bcbf26731264b17b4d7819444ee71034dfce7db5bcb51211d0ae5b7983098b008e7fed8
+  metadata.gz: 864e05461b1321d1094bdf27ae5bd971472194df29a440ff24f946449db7b98ec93c14ea53a25956ec1e9254b6e1e9015ac2d25978d8f1aadab02f91c69f287a
+  data.tar.gz: 20c08fdaad6cef869cb4256ffed49be996a3bd6a0e3dd9038bb05f4240a27e75791fefe9bdae1c8dc3f73622413ea95ed90c166dd4810c19cfdf709db6a185f2

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.2 (2026-04-23)
+
+- Package the runtime's Opal compile-time vendor shims (`digest`, `zlib`,
+  `tempfile`, `tilt`, `rubygems/version`) inside the gem.
+- Teach `cloudflare-workers-build --standalone` to add packaged gem `vendor/`
+  directories to the Opal load path, so published gems no longer depend on the
+  monorepo root `vendor/`.
+
 ## 0.1.1 (2026-04-23)
 
 - Fix `cloudflare-workers-build --standalone` and `exe/auto-await` to resolve only

data/bin/cloudflare-workers-build

@@ -27,6 +27,10 @@ module CloudflareWorkersBuild
     def gem_lib(*names)
       CloudflareWorkers::BuildSupport.gem_lib(*names)
     end
+
+    def gem_vendor(*names)
+      CloudflareWorkers::BuildSupport.gem_vendor(*names)
+    end
   end
 end
 
@@ -114,11 +118,18 @@ def run_opal_standalone!(root, opal_input, opal_output, with_db:)
   load_paths = []
   hv = homura_vendor_from_gemfile(root)
   load_paths << hv.to_s if hv
-  load_paths += [
-    'build/auto_await/app', 'app',
-    CloudflareWorkersBuild.gem_lib(CloudflareWorkers::BuildSupport::RUNTIME_GEM_NAME),
-    CloudflareWorkersBuild.gem_lib(CloudflareWorkers::BuildSupport::SINATRA_GEM_NAME)
-  ]
+  runtime_name = CloudflareWorkers::BuildSupport::RUNTIME_GEM_NAME
+  sinatra_name = CloudflareWorkers::BuildSupport::SINATRA_GEM_NAME
+
+  load_paths += ['build/auto_await/app', 'app']
+  [
+    CloudflareWorkersBuild.gem_lib(runtime_name),
+    CloudflareWorkersBuild.gem_vendor(runtime_name),
+    CloudflareWorkersBuild.gem_lib(sinatra_name),
+    CloudflareWorkersBuild.gem_vendor(sinatra_name)
+  ].compact.each do |path|
+    load_paths << path
+  end
   load_paths << CloudflareWorkersBuild.gem_lib('sequel-d1') if with_db
   load_paths << 'vendor' if root.join('vendor').directory?
   load_paths << 'build'

data/lib/cloudflare_workers/build_support.rb

@@ -12,6 +12,13 @@ module CloudflareWorkers
         loaded_specs[name]
       end
 
+      def gem_root(name, loaded_specs: Gem.loaded_specs)
+        spec = loaded_spec(name, loaded_specs: loaded_specs)
+        return spec.full_gem_path if spec
+
+        raise("cloudflare-workers-build: gem #{name} not loaded; use bundle exec from app root")
+      end
+
       def runtime_root(current_file:, loaded_specs: Gem.loaded_specs)
         spec = loaded_spec(RUNTIME_GEM_NAME, loaded_specs: loaded_specs)
         return Pathname(spec.full_gem_path) if spec
@@ -20,10 +27,14 @@ module CloudflareWorkers
       end
 
       def gem_lib(name, loaded_specs: Gem.loaded_specs)
-        spec = loaded_spec(name, loaded_specs: loaded_specs)
-        return File.join(spec.full_gem_path, 'lib') if spec
+        File.join(gem_root(name, loaded_specs: loaded_specs), 'lib')
+      end
 
-        raise("cloudflare-workers-build: gem #{name} not loaded; use bundle exec from app root")
+      def gem_vendor(name, loaded_specs: Gem.loaded_specs)
+        vendor = File.join(gem_root(name, loaded_specs: loaded_specs), 'vendor')
+        return vendor if Dir.exist?(vendor)
+
+        nil
       end
 
       def vendor_from_gemfile(project_root)

data/lib/cloudflare_workers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CloudflareWorkers
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/vendor/cgi/escape.rb

@@ -0,0 +1,4 @@
+# Stub for require 'cgi/escape'.
+# Opal stdlib provides `cgi` as a single file containing CGI.escape /
+# CGI.unescape; the upstream `cgi/escape` subfile does not exist.
+require 'cgi'

data/vendor/digest/sha2.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# Compatibility shim — `digest/sha2` traditionally pulls in
+# Digest::SHA256/SHA384/SHA512. Phase 7 defines them in vendor/digest.rb,
+# so we just re-require digest and rely on the existing constants.
+require 'digest'

data/vendor/digest.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# backtick_javascript: true
+
+require 'corelib/array/pack'
+require 'corelib/string/unpack'
+#
+# Phase 7 — Real Digest implementation backed by node:crypto.
+#
+# Replaces the Phase 2 NotImplementedError stub. All hash algos are
+# synchronous (no Promise glue), enabled by importing node:crypto via
+# src/setup-node-crypto.mjs and exposing it on globalThis.
+#
+# Available on:
+#   - Cloudflare Workers (with `compatibility_flags = ["nodejs_compat"]`)
+#   - Node.js (with `node --import ./src/setup-node-crypto.mjs`)
+#
+# Surface mirrors CRuby's `digest/sha1`, `digest/sha2`, `digest/md5`:
+#
+#   Digest::SHA256.hexdigest(str)            # one-shot hex
+#   Digest::SHA256.digest(str)               # one-shot binary
+#   Digest::SHA256.new.update(s).hexdigest   # streaming
+
+module Digest
+  # Common base class shared by SHA1 / SHA256 / SHA384 / SHA512 / MD5.
+  # Subclasses define ALGO (the node:crypto algorithm name).
+  class Base
+    def initialize
+      reset
+    end
+
+    def reset
+      @hasher = `globalThis.__nodeCrypto__.createHash(#{self.class::ALGO})`
+      self
+    end
+
+    def update(data)
+      str = data.to_s
+      `#{@hasher}.update(#{str}, 'utf8')`
+      self
+    end
+    alias_method :<<, :update
+
+    def hexdigest
+      hasher = @hasher
+      `#{hasher}.copy().digest('hex')`
+    end
+
+    def digest
+      hex = hexdigest
+      [hex].pack('H*')
+    end
+
+    def base64digest
+      hasher = @hasher
+      `#{hasher}.copy().digest('base64')`
+    end
+
+    def to_s
+      hexdigest
+    end
+
+    def self.hexdigest(data)
+      algo = self::ALGO
+      str  = data.to_s
+      `globalThis.__nodeCrypto__.createHash(#{algo}).update(#{str}, 'utf8').digest('hex')`
+    end
+
+    def self.digest(data)
+      hex = hexdigest(data)
+      [hex].pack('H*')
+    end
+
+    def self.base64digest(data)
+      algo = self::ALGO
+      str  = data.to_s
+      `globalThis.__nodeCrypto__.createHash(#{algo}).update(#{str}, 'utf8').digest('base64')`
+    end
+
+    # Disk-backed digest is impossible on Workers (no FS).
+    def self.file(*)
+      raise NotImplementedError, 'Digest.file is unavailable on Cloudflare Workers (no filesystem)'
+    end
+  end
+
+  # Backwards-compat alias for code that does `class Foo < Digest::Class`.
+  Class = Base unless const_defined?(:Class)
+
+  class SHA1   < Base; ALGO = 'sha1'.freeze;   end
+  class SHA256 < Base; ALGO = 'sha256'.freeze; end
+  class SHA384 < Base; ALGO = 'sha384'.freeze; end
+  class SHA512 < Base; ALGO = 'sha512'.freeze; end
+  class MD5    < Base; ALGO = 'md5'.freeze;    end
+end

data/vendor/rubygems/version.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+#
+# homura Opal stub for Gem::Version.
+#
+# Upstream Sinatra 4.x uses `Gem::Version.new(RUBY_VERSION) >=
+# Gem::Version.new("3.0")` to conditionally activate the `except`
+# override on IndifferentHash. Opal does not bundle RubyGems, so we
+# provide a tiny comparator that parses dotted versions as Integer
+# arrays (sufficient for the Sinatra use-case).
+
+module Gem
+  class Version
+    include Comparable
+
+    attr_reader :parts
+
+    def initialize(str)
+      @parts = str.to_s.split('.').map { |s| s.to_i rescue 0 }
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Version)
+      i = 0
+      max = [parts.size, other.parts.size].max
+      while i < max
+        a = parts[i] || 0
+        b = other.parts[i] || 0
+        cmp = a <=> b
+        return cmp unless cmp == 0
+        i += 1
+      end
+      0
+    end
+  end
+end

data/vendor/tempfile.rb

@@ -0,0 +1,34 @@
+# Minimal Tempfile stub for homura Phase 2.
+# Cloudflare Workers do not have a writable filesystem so a real Tempfile
+# implementation is impossible. Rack only references Tempfile for
+# multipart upload buffering, which is not exercised by the hello-world
+# handler. This stub allows `require 'tempfile'` to succeed; calling the
+# class will raise an explicit error.
+
+require 'stringio'
+
+class Tempfile < StringIO
+  def initialize(*)
+    super('')
+  end
+
+  def self.open(*)
+    raise NotImplementedError, 'Tempfile is stubbed in homura Phase 2 (Workers have no writable FS)'
+  end
+
+  def path
+    raise NotImplementedError, 'Tempfile#path stubbed (no FS)'
+  end
+
+  def unlink
+    self
+  end
+
+  def delete
+    self
+  end
+
+  def close!
+    close
+  end
+end

data/vendor/tilt.rb

@@ -0,0 +1,75 @@
+# Minimal Tilt stub for the homura Phase 2 hello-world handler.
+#
+# Real Sinatra requires the actual `tilt` gem for template rendering
+# (ERB, Haml, etc.). janbiedermann does not maintain a tilt fork because
+# Tilt's internals (binding manipulation, file IO) are difficult to run
+# under Opal as-is.
+#
+# For Phase 2 we do not render any templates — `get '/' do; "hello"; end`
+# returns a String directly and never reaches Tilt. So we provide just
+# enough of the Tilt surface area for `require 'tilt'` to succeed and
+# for Sinatra::Base to load. If a request actually tries to render a
+# template, it will raise an explicit NotImplementedError so the gap is
+# obvious and we can grow this stub deliberately in a later phase.
+
+module Tilt
+  class TemplateNotFound < StandardError; end
+
+  class Cache
+    def initialize
+      @cache = {}
+    end
+
+    def fetch(*key)
+      @cache[key] ||= yield
+    end
+
+    def clear
+      @cache.clear
+    end
+  end
+
+  class Mapping
+    def initialize
+      @extensions = {}
+    end
+
+    def register(template_class, *extensions)
+      extensions.each { |ext| @extensions[ext.to_s] = template_class }
+    end
+
+    def [](name)
+      @extensions[name.to_s]
+    end
+
+    def extensions_for(engine_or_class)
+      @extensions.each_with_object([]) do |(ext, klass), out|
+        out << ext if klass == engine_or_class
+      end
+    end
+
+    def template_for(name)
+      @extensions[name.to_s]
+    end
+  end
+
+  class << self
+    def default_mapping
+      @default_mapping ||= Mapping.new
+    end
+
+    def [](name)
+      default_mapping[name]
+    end
+
+    def register(template_class, *extensions)
+      default_mapping.register(template_class, *extensions)
+    end
+
+    def new(file = nil, line = nil, options = {}, &block)
+      raise NotImplementedError,
+            'Tilt template rendering is not available in homura Phase 2 ' \
+            '(stubbed). Return Strings or arrays from your Sinatra handlers.'
+    end
+  end
+end

data/vendor/zlib.rb

@@ -0,0 +1,41 @@
+# Minimal Zlib stub for the homura Phase 2 hello-world handler.
+# Opal stdlib does not ship a zlib module. Real homura apps that need
+# response compression should rely on the Cloudflare edge to gzip
+# responses on the way out. This stub only exists so that
+# `require 'zlib'` (transitively pulled in by rack/deflater) does not
+# fail at compile time. None of the methods below are reachable from
+# the Phase 2 hello-world path.
+
+module Zlib
+  class Error < StandardError; end
+  class GzipFile
+    class Error < Zlib::Error; end
+    class CRCError < Error; end
+    class LengthError < Error; end
+    class NoFooter < Error; end
+  end
+
+  class GzipReader < GzipFile
+    def self.wrap(*); raise NotImplementedError, 'Zlib stubbed'; end
+  end
+
+  class GzipWriter < GzipFile
+    def self.wrap(*); raise NotImplementedError, 'Zlib stubbed'; end
+  end
+
+  class Deflate
+    def self.deflate(*); raise NotImplementedError, 'Zlib stubbed'; end
+    def initialize(*); end
+    def deflate(*); raise NotImplementedError, 'Zlib stubbed'; end
+    def finish; raise NotImplementedError, 'Zlib stubbed'; end
+    def close; end
+  end
+
+  class Inflate
+    def self.inflate(*); raise NotImplementedError, 'Zlib stubbed'; end
+  end
+
+  DEFAULT_COMPRESSION = -1
+  BEST_SPEED = 1
+  BEST_COMPRESSION = 9
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: homura-runtime
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Kazuhiro NISHIYAMA
@@ -76,6 +76,13 @@ files:
 - runtime/worker_module.mjs
 - runtime/wrangler.toml.example
 - templates/wrangler.toml.example
+- vendor/cgi/escape.rb
+- vendor/digest.rb
+- vendor/digest/sha2.rb
+- vendor/rubygems/version.rb
+- vendor/tempfile.rb
+- vendor/tilt.rb
+- vendor/zlib.rb
 homepage: https://github.com/kazuph/homura
 licenses:
 - MIT