homura-runtime 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 328d7e98210fb60bb229a46166aa605b2c9e2a85baca8418cac31a0ac3688311
-  data.tar.gz: 3e3c0562902a031343eddf788a078d1556649c286ec79e44295626a0be2058a3
+  metadata.gz: b3d8286719ce164088136af4d1caf0476c026d4ec2e42b98b08db8c84df6766d
+  data.tar.gz: 849f3bb4ae14131b950de3a89efff6032a4204e9878a19c84cfe9dcdfa618e8b
 SHA512:
-  metadata.gz: 971c5697869ed0ecc0ba57d6aa5263c6f3b36f5e2bfa0c5e6efc67efe5bb5aade01dd0b522aaa685c4226074924b5a6e8269135fd6a12bdf1f8a6592d3b120cb
-  data.tar.gz: 0ef026fa796bfedb3960b42c1f2ea6a09a1d382d9883d16fd744767d3967a3649f0ee9cb322e80f1ddff6db752f05f12da94c62b04c238fe8f43aa4143b667d8
+  metadata.gz: c692cab5b2375646806e28b72b2e3c82da48563dcfc6a9074b8a8f3d9a756a92caee4ce100eee22bfaf81d00a459b3b85541176565fc1c3de5545f5c08b5216b
+  data.tar.gz: 0eda9cfebebb75b1efd6764d6be2b27710769e30a215e9c9cb5b9d635534afbf685cc8aeac632ad09378ecf106768d9b395093f4055c2293179b81817484f8a6

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 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
+  `<%= yield %>` in layout templates.
+- Keep legacy `@content` / `@docs_inner` layouts working as compatibility
+  fallbacks while apps migrate to the least-surprise Sinatra style.
+
 ## 0.1.3 (2026-04-23)
 
 - Fix binary static asset embedding so image responses preserve exact bytes on

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' }
@@ -199,12 +205,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 +220,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,11 +43,48 @@ USAGE
 module HomuraERB
   module_function
 
+  def supported_yield_fragment?(fragment)
+    stripped = fragment.strip
+    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
   # `instance_exec` on the Sinatra instance the route was dispatched
-  # on. That gives `<%= @name %>` the usual Sinatra semantics.
+  # on. That gives `<%= @name %>` the usual Sinatra semantics. Layout
+  # templates can also write `<%= yield %>` — we rewrite that specific
+  # form to an instance helper because Ruby's `yield` keyword is not
+  # valid inside the Proc body we generate here.
   def compile(source)
     ruby = +"_out = ''\n"
     cursor = 0
@@ -76,14 +113,20 @@ module HomuraERB
         # `<%== expression %>` — identical to `<%= %>` in this minimal
         # dialect (no HTML escaping yet; the author is responsible).
         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 = 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 << inner.strip << "\n"
+        code = inner.strip
+        validate_code_fragment!(code)
+        ruby << normalize_fragment(code) << "\n"
       end
 
       cursor = close_idx + 2
@@ -142,10 +185,16 @@ def emit_header(io, namespace)
           @templates[name.to_sym] = body
         end
 
-        def render(name, instance, locals = {})
+        def render(name, instance, locals = {}, &block)
           body = @templates[name.to_sym]
           raise "#{namespace}: no template registered for \#{name.inspect}" unless body
-          instance.instance_exec(locals, &body)
+          previous_block = instance.instance_variable_get(:@__homura_template_block__)
+          begin
+            instance.instance_variable_set(:@__homura_template_block__, block)
+            instance.instance_exec(locals, &body)
+          ensure
+            instance.instance_variable_set(:@__homura_template_block__, previous_block)
+          end
         end
 
         def registered?(name)
@@ -187,6 +236,22 @@ def emit_sinatra_patch(io, namespace)
 
     module ::Sinatra
       module Templates
+        def __homura_template_yield__
+          block = @__homura_template_block__
+          raise LocalJumpError, 'no block given' unless block
+
+          block.call
+        end
+
+        def __homura_default_template_block_for__(template)
+          case template.to_sym
+          when :layout
+            proc { @content } if defined?(@content)
+          when :layout_docs
+            proc { @docs_inner } if defined?(@docs_inner)
+          end
+        end
+
         # homura patch: dispatch to precompiled templates when we
         # have one. Unknown symbols raise a clear message instead of
         # wandering into upstream Tilt, which would blow up on
@@ -194,7 +259,20 @@ def emit_sinatra_patch(io, namespace)
         def erb(template, options = {}, locals = {}, &block)
           if template.is_a?(::Symbol) && ::#{namespace}.registered?(template)
             locals ||= {}
-            ::#{namespace}.render(template, self, locals)
+            block ||= __homura_default_template_block_for__(template)
+            output = ::#{namespace}.render(template, self, locals, &block)
+
+            layout = options[:layout]
+            layout = false if layout.nil? && options.include?(:layout)
+            if layout
+              layout = :layout if layout == true
+              layout = layout.to_sym
+              raise "homura: layout \#{layout.inspect} not precompiled; run bin/compile-erb" unless ::#{namespace}.registered?(layout)
+
+              return ::#{namespace}.render(layout, self, locals) { output }
+            end
+
+            output
           else
             raise "homura: erb \#{template.inspect} not precompiled; run bin/compile-erb"
           end

data/lib/cloudflare_workers/build_support.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'pathname'
 
 module CloudflareWorkers
@@ -37,6 +38,30 @@ 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_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.3'
+  VERSION = '0.1.5'
 end

metadata

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