homura-runtime 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99d546ac1db58f957cf5bd81723cfc0e15019f11c27c8b0bcd78fc2ee833b751
-  data.tar.gz: 02b08e0580b05b710cfba5d5bc6255ba463a4675a297476583dcacece6b158b6
+  metadata.gz: 6e37f705dbc9ddf448634efe039bcc390d577c1683ad1759db58fdb1fbceee02
+  data.tar.gz: 9dfa51f60c34241302354b5069f10ba560a61c51d4b70a1799893d785d2ae434
 SHA512:
-  metadata.gz: 864e05461b1321d1094bdf27ae5bd971472194df29a440ff24f946449db7b98ec93c14ea53a25956ec1e9254b6e1e9015ac2d25978d8f1aadab02f91c69f287a
-  data.tar.gz: 20c08fdaad6cef869cb4256ffed49be996a3bd6a0e3dd9038bb05f4240a27e75791fefe9bdae1c8dc3f73622413ea95ed90c166dd4810c19cfdf709db6a185f2
+  metadata.gz: 0655d2c8e8f889892df7500cfadc663df079be3c7326815523b2fad12cacdce4eb729f859e145bfdc8c26f8ad0bc12bc2d5ee2dfd3acf14e71c82ffafd4057d3
+  data.tar.gz: 93c6e9c5607b995d631060f511633bd94b3fa74f9db3c9adee3806b684a1ea7134b136bde12f9c8a3fa7d1da5f3ff76c95929c253251eb7daf3f1f9685bc5342

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 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
+  Workers instead of being mangled through text encoding.
+- Add regression coverage for binary-vs-text compile-assets output.
+- Convert shipped mascot/icon assets to real PNG payloads so their bytes match
+  their `.png` filenames and `image/png` content type.
+
 ## 0.1.2 (2026-04-23)
 
 - Package the runtime's Opal compile-time vendor shims (`digest`, `zlib`,
@@ -7,7 +22,6 @@
 - 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/exe/compile-assets

@@ -12,6 +12,7 @@
 # Usage:
 #   ruby bin/compile-assets --input public --output build/homura_assets.rb --namespace HomuraAssets
 
+require 'base64'
 require 'fileutils'
 require 'optparse'
 
@@ -39,6 +40,13 @@ def mime_for(path)
   MIME_TYPES[ext] || 'application/octet-stream'
 end
 
+def binary_content_type?(content_type)
+  !(content_type.start_with?('text/') ||
+    content_type.include?('javascript') ||
+    content_type.include?('json') ||
+    content_type.include?('xml'))
+end
+
 HELP = <<~USAGE
   Usage:
     ruby bin/compile-assets [--input DIR] [--output FILE] [--namespace NAME]
@@ -105,10 +113,19 @@ File.open(out_path, 'w') do |io|
           if (asset = #{ns}::ASSETS[path])
             headers = {
               'content-type'   => asset[:content_type],
-              'content-length' => asset[:body].bytesize.to_s,
               'cache-control'  => 'public, max-age=3600',
             }
-            [200, headers, [asset[:body]]]
+            if asset[:binary]
+              body = ::Cloudflare::EmbeddedBinaryBody.new(
+                asset[:body_base64],
+                asset[:content_type],
+                headers['cache-control']
+              )
+              [200, headers, [body.raw_response(200, headers)]]
+            else
+              headers['content-length'] = asset[:body].bytesize.to_s
+              [200, headers, [asset[:body]]]
+            end
           else
             @app.call(env)
           end
@@ -119,14 +136,20 @@ File.open(out_path, 'w') do |io|
 
   files.each do |full_path|
     rel = full_path.sub(public_dir, '')        # e.g. "/style.css"
-    content = File.read(full_path)
+    content = File.binread(full_path)
     ct = mime_for(full_path)
+    binary = binary_content_type?(ct)
 
     io.puts
     io.puts "# #{rel} (#{content.bytesize} bytes)"
     io.puts "#{ns}::ASSETS[#{rel.inspect}] = {"
     io.puts "  content_type: #{ct.inspect},"
-    io.puts "  body: #{content.inspect}"
+    io.puts "  binary: #{binary},"
+    if binary
+      io.puts "  body_base64: #{Base64.strict_encode64(content).inspect}"
+    else
+      io.puts "  body: #{content.inspect}"
+    end
     io.puts "}"
   end
 

data/exe/compile-erb

@@ -43,11 +43,21 @@ USAGE
 module HomuraERB
   module_function
 
+  def normalize_fragment(fragment)
+    stripped = fragment.strip
+    return '__homura_template_yield__' if stripped == 'yield' || stripped == 'yield()'
+
+    fragment
+  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
@@ -75,15 +85,15 @@ module HomuraERB
       elsif inner.start_with?('==')
         # `<%== expression %>` — identical to `<%= %>` in this minimal
         # dialect (no HTML escaping yet; the author is responsible).
-        expr = inner[2..].strip
+        expr = normalize_fragment(inner[2..].strip)
         ruby << "_out = _out + ((#{expr})).to_s\n"
       elsif inner.start_with?('=')
         # `<%= expression %>`
-        expr = inner[1..].strip
+        expr = normalize_fragment(inner[1..].strip)
         ruby << "_out = _out + ((#{expr})).to_s\n"
       else
         # `<% code %>` — Ruby statement(s), emitted verbatim
-        ruby << inner.strip << "\n"
+        ruby << normalize_fragment(inner.strip) << "\n"
       end
 
       cursor = close_idx + 2
@@ -142,10 +152,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 +203,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 +226,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/version.rb

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

data/lib/cloudflare_workers.rb

@@ -313,6 +313,18 @@ module Rack
             return `new Response(#{js_stream}, { status: #{status.to_i}, headers: #{js_headers} })`
           end
 
+          if body.is_a?(::Cloudflare::EmbeddedBinaryBody) || (body.respond_to?(:first) && body.first.is_a?(::Cloudflare::EmbeddedBinaryBody))
+            bin = body.is_a?(::Cloudflare::EmbeddedBinaryBody) ? body : body.first
+            js_stream = bin.stream
+            ct = bin.content_type
+            cc = bin.cache_control
+            js_headers = `({})`
+            headers.each { |k, v| ks = k.to_s; vs = v.to_s; `#{js_headers}[#{ks}] = #{vs}` }
+            `#{js_headers}['content-type'] = #{ct}` if ct
+            `#{js_headers}['cache-control'] = #{cc}` if cc
+            return `new Response(#{js_stream}, { status: #{status.to_i}, headers: #{js_headers} })`
+          end
+
           # Phase 10 — Workers AI streaming: a Cloudflare::AI::Stream wraps
           # a JS ReadableStream<Uint8Array> emitting SSE-formatted bytes
           # ("data: {json}\n\n"). Pass it straight through so the client
@@ -530,6 +542,35 @@ module Cloudflare
     def close; end
   end
 
+  # EmbeddedBinaryBody carries a base64-encoded asset payload produced at
+  # build time by `compile-assets`, then reconstructs a Uint8Array in the
+  # Worker before building the Response stream.
+  class EmbeddedBinaryBody
+    attr_reader :body_base64, :content_type, :cache_control
+
+    def initialize(body_base64, content_type = 'application/octet-stream', cache_control = nil)
+      @body_base64 = body_base64 || ''
+      @content_type = content_type
+      @cache_control = cache_control
+    end
+
+    def each; end
+
+    def close; end
+
+    def raw_response(status, headers = {})
+      js_headers = `({})`
+      headers.each { |k, v| ks = k.to_s; vs = v.to_s; `#{js_headers}[#{ks}] = #{vs}` }
+      `#{js_headers}['content-type'] = #{@content_type}` if @content_type
+      `#{js_headers}['cache-control'] = #{@cache_control}` if @cache_control
+      RawResponse.new(`new Response(#{stream}, { status: #{status.to_i}, headers: #{js_headers} })`)
+    end
+
+    def stream
+      `(function(b64) { return new ReadableStream({ start(controller) { var bin = globalThis.atob(b64); var len = bin.length; var out = new Uint8Array(len); for (var i = 0; i < len; i++) { out[i] = bin.charCodeAt(i) & 0xff; } controller.enqueue(out); controller.close(); } }); })(#{@body_base64})`
+    end
+  end
+
   # NOTE: the single-line backtick `...` form is used below instead of the
   # multi-line `%x{ ... }` or multi-line backtick form. Opal's compiler
   # treats a *multi-line* x-string as a raw statement and refuses to use

metadata

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