homura-runtime 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e37f705dbc9ddf448634efe039bcc390d577c1683ad1759db58fdb1fbceee02
-  data.tar.gz: 9dfa51f60c34241302354b5069f10ba560a61c51d4b70a1799893d785d2ae434
+  metadata.gz: aae4102ce898507966e1a993b16033cf74ede5f2543d17e56d552c6b3ecfabaf
+  data.tar.gz: 16b3be88c09f2189193da02cde5904a18749a74edf80e38927a2e47329ec06a8
 SHA512:
-  metadata.gz: 0655d2c8e8f889892df7500cfadc663df079be3c7326815523b2fad12cacdce4eb729f859e145bfdc8c26f8ad0bc12bc2d5ee2dfd3acf14e71c82ffafd4057d3
-  data.tar.gz: 93c6e9c5607b995d631060f511633bd94b3fa74f9db3c9adee3806b684a1ea7134b136bde12f9c8a3fa7d1da5f3ff76c95929c253251eb7daf3f1f9685bc5342
+  metadata.gz: 57f457bf20205a3bd68d81d5ad616b971892c513023d61dd9b56f575bc0cf70063b9753810abb1163084ebd48d7ae8439bcfd5c72a53e3dd25bdc3f98148b796
+  data.tar.gz: 6c69fb69b6c79a3309a9e5796534023ee47066027a97c809034615635b1df49e284ee0c010fce48059f062d43ec94e12f01ace5b39525b5f6e7d64940a4affa2

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.1.6 (2026-04-23)
+
+- Teach `cloudflare-workers-build --standalone --with-db` to add the packaged
+  `sequel-d1` gem `vendor/` directory to the Opal load path before the gem's
+  `lib/`, so `require 'sequel'` resolves to the bundled Opal-compatible Sequel
+  subset instead of the CRuby gem.
+
+## 0.1.5 (2026-04-23)
+
+- Make `auto-await` emit rewritten files for existing hand-written `.__await__`
+  usage when the only missing piece is `# await: true`.
+- Make `cloudflare-workers-build --standalone` restore `cf-runtime/` from the
+  packaged gem and derive standalone template/asset namespaces from the project
+  name by default, with explicit override flags when needed.
+- Reject unsupported ERB yield forms like `<% yield %>` and `yield(arg)` with
+  compile-time guidance toward the supported Sinatra-style layout forms.
+
 ## 0.1.4 (2026-04-23)
 
 - Teach the precompiled ERB runtime to support Sinatra-style layout blocks and

data/README.md

@@ -9,7 +9,7 @@ Core Ruby + Module Worker glue for [Opal](https://opalrb.com/) on [Cloudflare Wo
 - `runtime/worker_module.mjs` — fetch / scheduled / queue / DO adapters (**no Opal bundle import**).
 - `runtime/worker.mjs` — thin bootstrap (crypto shim → bundle → `worker_module`) for legacy layouts.
 - `runtime/setup-node-crypto.mjs` — `node:crypto` on `globalThis` before the Opal bundle loads.
-- `bin/cloudflare-workers-build` — single build pipeline (ERB → assets → Opal → patch → `worker.entrypoint.mjs`). Use `--standalone` in generated apps.
+- `bin/cloudflare-workers-build` — single build pipeline (ERB → assets → Opal → patch → `worker.entrypoint.mjs`). Use `--standalone` in generated apps; it now restores `cf-runtime/` automatically and derives standalone template/asset namespaces from the project name by default.
 - `docs/ARCHITECTURE.md` — wrangler `main`, codegen entrypoint, and fixed-import policy.
 
 ## Quick start (homura monorepo)

data/bin/cloudflare-workers-build

@@ -44,7 +44,9 @@ options = {
   bundle_import: nil,
   worker_module_import: nil,
   entrypoint_out: nil,
-  with_db: false
+  with_db: false,
+  templates_namespace: nil,
+  assets_namespace: nil
 }
 
 OptionParser.new do |o|
@@ -63,9 +65,13 @@ OptionParser.new do |o|
   o.on('--bundle-import PATH', 'Opal bundle import in entrypoint') { |p| options[:bundle_import] = p }
   o.on('--worker-module-import PATH', 'worker_module.mjs import in entrypoint') { |p| options[:worker_module_import] = p }
   o.on('--entrypoint-out PATH', 'Where to write worker.entrypoint.mjs') { |p| options[:entrypoint_out] = p }
+  o.on('--templates-namespace NAME', 'Standalone templates module name (default: project-derived)') { |n| options[:templates_namespace] = n }
+  o.on('--assets-namespace NAME', 'Standalone assets module name (default: project-derived)') { |n| options[:assets_namespace] = n }
 end.parse!
 
 root = Pathname(options[:root]).expand_path
+options[:templates_namespace] ||= CloudflareWorkers::BuildSupport.standalone_namespace(root, 'Templates') if options[:standalone]
+options[:assets_namespace] ||= CloudflareWorkers::BuildSupport.standalone_namespace(root, 'Assets') if options[:standalone]
 
 if options[:standalone]
   Dir.chdir(root) { require 'bundler/setup' }
@@ -115,24 +121,7 @@ def homura_vendor_from_gemfile(project_root)
 end
 
 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
-  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'
+  load_paths = CloudflareWorkers::BuildSupport.standalone_load_paths(root, with_db: with_db)
 
   argv = ['bundle', 'exec', 'opal', '-c', '-E', '--esm', '--no-source-map']
   load_paths.each { |p| argv.push('-I', p) }
@@ -199,12 +188,13 @@ unless options[:standalone]
   opal_out = root.join(opal_out) unless opal_out.absolute?
   run_opal_homura!(root, opal_in.relative_path_from(root).to_s, opal_out.relative_path_from(root).to_s)
 else
+  CloudflareWorkers::BuildSupport.ensure_standalone_runtime(root, current_file: __FILE__)
   run!(
     [
       'ruby', CloudflareWorkersBuild.exe_path('compile-erb').to_s,
       '--input', 'views',
       '--output', 'build/app_templates.rb',
-      '--namespace', 'AppTemplates'
+      '--namespace', options[:templates_namespace]
     ],
     chdir: root
   )
@@ -213,7 +203,7 @@ else
       'ruby', CloudflareWorkersBuild.exe_path('compile-assets').to_s,
       '--input', 'public',
       '--output', 'build/app_assets.rb',
-      '--namespace', 'AppAssets'
+      '--namespace', options[:assets_namespace]
     ],
     chdir: root
   )

data/exe/auto-await

@@ -72,18 +72,25 @@ paths.each do |path|
   # needed to tell Opal to wrap the file in an async function and to
   # translate #__await__ calls into real JS await keywords.
   has_magic = source.lines.first(5).any? { |l| l.match?(/#\s*await:/) }
+  has_existing_await = source.include?('.__await__')
 
   begin
     analyzer = CloudflareWorkers::AutoAwait::Analyzer.new(registry, debug: options[:debug])
     buffer, nodes = analyzer.process(source, path)
+    needs_magic_only_output = has_existing_await && !has_magic
 
-    if nodes.empty?
+    if nodes.empty? && !needs_magic_only_output
       puts "[auto-await] skip (no changes) #{rel}" if options[:debug]
       skipped += 1
       next
     end
 
-    transformed = CloudflareWorkers::AutoAwait::Transformer.transform(source, nodes, buffer)
+    transformed =
+      if nodes.empty?
+        source
+      else
+        CloudflareWorkers::AutoAwait::Transformer.transform(source, nodes, buffer)
+      end
     unless has_magic
       transformed = "# await: true\n" + transformed
     end

data/exe/compile-erb

@@ -43,13 +43,40 @@ USAGE
 module HomuraERB
   module_function
 
-  def normalize_fragment(fragment)
+  def supported_yield_fragment?(fragment)
     stripped = fragment.strip
-    return '__homura_template_yield__' if stripped == 'yield' || stripped == 'yield()'
+    stripped.match?(/\Ayield(?:\(\s*\))?\z/)
+  end
+
+  def yield_with_args_fragment?(fragment)
+    fragment.strip.match?(/\Ayield\s*\(.+\)\z/)
+  end
 
+  def normalize_fragment(fragment)
+    return '__homura_template_yield__' if supported_yield_fragment?(fragment)
     fragment
   end
 
+  def validate_code_fragment!(fragment)
+    stripped = fragment.strip
+    return unless supported_yield_fragment?(stripped) || yield_with_args_fragment?(stripped)
+
+    raise <<~MSG.strip
+      Unsupported ERB yield form `<% #{stripped} %>`.
+      Use `<%= yield %>` or `<%== yield %>` in layout templates.
+    MSG
+  end
+
+  def validate_expression_fragment!(fragment)
+    stripped = fragment.strip
+    return unless yield_with_args_fragment?(stripped)
+
+    raise <<~MSG.strip
+      Unsupported ERB yield form `<%= #{stripped} %>`.
+      `yield(arg)` is not supported; use `<%= yield %>` or `<%== yield %>`, or pass data via ivars/locals instead.
+    MSG
+  end
+
   # Compile an ERB source string to a Ruby method body that assembles
   # an HTML string in a local variable `_out`. The body references
   # `@ivars` and method calls directly, so it must be run via
@@ -85,15 +112,21 @@ module HomuraERB
       elsif inner.start_with?('==')
         # `<%== expression %>` — identical to `<%= %>` in this minimal
         # dialect (no HTML escaping yet; the author is responsible).
-        expr = normalize_fragment(inner[2..].strip)
+        expr = inner[2..].strip
+        validate_expression_fragment!(expr)
+        expr = normalize_fragment(expr)
         ruby << "_out = _out + ((#{expr})).to_s\n"
       elsif inner.start_with?('=')
         # `<%= expression %>`
-        expr = normalize_fragment(inner[1..].strip)
+        expr = inner[1..].strip
+        validate_expression_fragment!(expr)
+        expr = normalize_fragment(expr)
         ruby << "_out = _out + ((#{expr})).to_s\n"
       else
         # `<% code %>` — Ruby statement(s), emitted verbatim
-        ruby << normalize_fragment(inner.strip) << "\n"
+        code = inner.strip
+        validate_code_fragment!(code)
+        ruby << normalize_fragment(code) << "\n"
       end
 
       cursor = close_idx + 2

data/lib/cloudflare_workers/build_support.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'pathname'
 
 module CloudflareWorkers
   module BuildSupport
     RUNTIME_GEM_NAME = 'homura-runtime'
     SINATRA_GEM_NAME = 'sinatra-homura'
+    SEQUEL_D1_GEM_NAME = 'sequel-d1'
 
     class << self
       def loaded_spec(name, loaded_specs: Gem.loaded_specs)
@@ -37,6 +39,61 @@ module CloudflareWorkers
         nil
       end
 
+      def runtime_file(*names, current_file: __FILE__, loaded_specs: Gem.loaded_specs)
+        runtime_root(current_file: current_file, loaded_specs: loaded_specs).join('runtime', *names)
+      end
+
+      def ensure_standalone_runtime(project_root, current_file: __FILE__, loaded_specs: Gem.loaded_specs)
+        target_dir = Pathname(project_root).join('cf-runtime')
+        FileUtils.mkdir_p(target_dir)
+
+        %w[setup-node-crypto.mjs worker_module.mjs].each do |name|
+          FileUtils.cp(runtime_file(name, current_file: current_file, loaded_specs: loaded_specs), target_dir.join(name))
+        end
+
+        target_dir
+      end
+
+      def standalone_load_paths(project_root, with_db:, loaded_specs: Gem.loaded_specs)
+        root = Pathname(project_root)
+        load_paths = []
+
+        hv = vendor_from_gemfile(root)
+        load_paths << hv.to_s if hv
+
+        load_paths += ['build/auto_await/app', 'app']
+        [
+          gem_lib(RUNTIME_GEM_NAME, loaded_specs: loaded_specs),
+          gem_vendor(RUNTIME_GEM_NAME, loaded_specs: loaded_specs),
+          gem_lib(SINATRA_GEM_NAME, loaded_specs: loaded_specs),
+          gem_vendor(SINATRA_GEM_NAME, loaded_specs: loaded_specs)
+        ].compact.each do |path|
+          load_paths << path
+        end
+
+        if with_db
+          [
+            gem_vendor(SEQUEL_D1_GEM_NAME, loaded_specs: loaded_specs),
+            gem_lib(SEQUEL_D1_GEM_NAME, loaded_specs: loaded_specs)
+          ].compact.each do |path|
+            load_paths << path
+          end
+        end
+
+        load_paths << 'vendor' if root.join('vendor').directory?
+        load_paths << 'build'
+        load_paths.uniq
+      end
+
+      def standalone_namespace(project_root, suffix)
+        base = Pathname(project_root).basename.to_s
+        parts = base.split(/[^A-Za-z0-9]+/).reject(&:empty?)
+        module_name = parts.map { |part| part[0].upcase + part[1..].to_s }.join
+        module_name = 'App' if module_name.empty?
+        module_name = "App#{module_name}" if module_name.match?(/\A\d/)
+        "#{module_name}#{suffix}"
+      end
+
       def vendor_from_gemfile(project_root)
         gf = Pathname(project_root).join('Gemfile')
         return unless gf.file?

data/lib/cloudflare_workers/version.rb

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

data/lib/cloudflare_workers.rb

@@ -20,9 +20,10 @@
 #      style entry point and never sees a Cloudflare-specific symbol.
 #
 #   3. Cloudflare::D1Database / KVNamespace / R2Bucket — tiny Ruby wrappers
-#      around the JS bindings. They expose the binding methods as regular
-#      Ruby method calls returning native JS Promises, which the user
-#      routes can `.__await__` inside a `# await: true` block.
+#      around the JS bindings. At the raw runtime layer they still return
+#      Promises, but homura's build-time auto-await pass rewrites the
+#      common Sinatra-facing call sites (`db.execute`, `kv.get`, etc.) so
+#      app code usually stays sync-shaped.
 #
 # Note: Opal Strings are immutable (they map to JS Strings), so this file
 # uses reassignment (`@buffer = @buffer + str`) instead of `<<` mutation.
@@ -209,8 +210,10 @@ module Rack
 
           # Expose D1 / KV / R2 bindings as plain Ruby wrapper objects.
           # The user Sinatra routes reach them via
-          # `env['cloudflare.DB']` / `.KV` / `.BUCKET`, call normal-looking
-          # Ruby methods on them, and `.__await__` the resulting JS Promise.
+          # `env['cloudflare.DB']` / `.KV` / `.BUCKET` and call ordinary
+          # Ruby methods on them. Under the hood those methods are async,
+          # but homura's auto-await build step inserts `.__await__` for the
+          # common binding/helper patterns so app source usually does not.
           js_db = `#{js_env} && #{js_env}.DB`
           js_kv = `#{js_env} && #{js_env}.KV`
           js_r2 = `#{js_env} && #{js_env}.BUCKET`
@@ -603,8 +606,10 @@ module Cloudflare
 
     # ---- sqlite3-ruby compatible high-level API ----------------------
 
-    # Execute a SQL statement with optional bind parameters and return
-    # all result rows as an Array of Hashes.
+    # Execute a SQL statement with optional bind parameters.
+    # Returns a JS Promise resolving to an Array of Hashes; the build-time
+    # auto-await pass rewrites the usual Sinatra call sites so app code can
+    # stay `db.execute(...)` instead of spelling `.__await__`.
     #
     #   db.execute("SELECT * FROM users")                           → Array<Hash>
     #   db.execute("SELECT * FROM users WHERE id = ?", [1])         → Array<Hash>
@@ -616,6 +621,7 @@ module Cloudflare
     end
 
     # Execute and return only the first row (or nil).
+    # Returns a JS Promise resolving to a Hash or nil.
     #
     #   db.get_first_row("SELECT * FROM users WHERE id = ?", [1])  → Hash or nil
     def get_first_row(sql, bind_params = [])
@@ -626,6 +632,7 @@ module Cloudflare
 
     # Execute a write statement (INSERT / UPDATE / DELETE) and return
     # a metadata Hash with `changes`, `last_row_id`, `duration`, etc.
+    # Returns a JS Promise resolving to that metadata Hash.
     #
     #   meta = db.execute_insert("INSERT INTO users (name) VALUES (?)", ["alice"])
     #   meta['last_row_id']  # → 7
@@ -636,7 +643,7 @@ module Cloudflare
     end
 
     # Execute one or more raw SQL statements separated by semicolons.
-    # Useful for schema migrations. Returns the D1 exec result.
+    # Useful for schema migrations. Returns the raw async D1 exec result.
     def execute_batch(sql)
       exec(sql)
     end
@@ -697,6 +704,7 @@ module Cloudflare
     end
 
     # KV#get returns a JS Promise resolving to a String or nil.
+    # In normal Sinatra app code, auto-await usually hides that Promise.
     def get(key)
       js_kv = @js
       err_cls = Cloudflare::KVError
@@ -705,7 +713,8 @@ module Cloudflare
 
     # Put a value. `expiration_ttl:` (seconds) maps to the Workers KV
     # `expirationTtl` option so callers can set TTLs without reaching
-    # for backticks. Returns a JS Promise.
+    # for backticks. Returns a JS Promise; common route/helper call sites
+    # are auto-awaited during the build.
     def put(key, value, expiration_ttl: nil)
       js_kv = @js
       err_cls = Cloudflare::KVError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: homura-runtime
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Kazuhiro NISHIYAMA