homura-runtime 0.2.17 → 0.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 484afdeb8e2980e08e029bf515a07530b08296357eaa6bfbf255a721104358bf
-  data.tar.gz: 77bf0079ae55ecdbbe137d6b804d8501a90f66daa3859e22d9e9114fad582830
+  metadata.gz: 94e4ec7af2878bc59ebedd0ebe8841d5852b4fb35d736d713a62ce1ef1bb1cfb
+  data.tar.gz: 6f21d253588daa097a1541ddd017b58a28b10c38ccc703f2a3ee9e6c650f490f
 SHA512:
-  metadata.gz: 89a21e0c74732fa2b2467ccff72a3ca365c706d0928c9ffb3fc4e4f2b96ecf8688fc4bdbf3beda1e806122d8abca9053d787a528c48d13a3f709aeb8c57ab027
-  data.tar.gz: 79975dd3ce599d61824919d790ec05727603043887577ece2af6231136e320514837ca54e710095e4c8a3aadfe06fc9ebf97ae791da0255cf19feea6eef83803
+  metadata.gz: dd0b2cb20babf2fe3cb57167dfdc509fef69ccd5d141cf44c0a370b9e8aca29425267433eb4fdf002b0e081583c8028deb1799d4e8c53e808a2b175f2a611c7e
+  data.tar.gz: d794586f918cef8b0cabebec3923525078c69a9b68e75e0da96096ffa8afdc02aceb6cd277b07f8b15c0396a3f6f6b6ecf77e2c0c9308cd27624acce320b45ad

data/exe/compile-erb

@@ -287,11 +287,21 @@ def emit_header(io, namespace)
           body = @templates[name.to_sym]
           raise "#{namespace}: no template registered for \#{name.inspect}" unless body
           previous_block = instance.instance_variable_get(:@__homura_template_block__)
+          previous_locals = instance.instance_variable_get(:@__homura_template_locals__)
           begin
             instance.instance_variable_set(:@__homura_template_block__, block)
+            # Stack locals so nested `erb :_partial, locals: {...}` calls
+            # restore the outer scope on the way out — Sinatra's standard
+            # `locals[:t]` -> bare `t` lookup is implemented via
+            # method_missing on the Sinatra instance (see Sinatra::Base
+            # patch installed by emit_sinatra_patch).
+            stack = previous_locals.is_a?(::Array) ? previous_locals.dup : []
+            stack.push(locals || {})
+            instance.instance_variable_set(:@__homura_template_locals__, stack)
             instance.instance_exec(locals, &body)
           ensure
             instance.instance_variable_set(:@__homura_template_block__, previous_block)
+            instance.instance_variable_set(:@__homura_template_locals__, previous_locals)
           end
         end
 
@@ -341,6 +351,61 @@ def emit_sinatra_patch(io, namespace)
           block.call
         end
 
+        # Resolve a Sinatra-style local variable reference.
+        # `erb :_partial, locals: { t: row }` causes the precompiled body
+        # to reference a bare `t`. Stock Sinatra uses Ruby's `binding`
+        # eval to install locals into the template's scope; we don't have
+        # `binding` under Opal/Workers, so we hand-roll the lookup
+        # through method_missing against the locals stack maintained by
+        # the renderer.
+        def __homura_template_local__(name)
+          stack = @__homura_template_locals__
+          return nil unless stack.is_a?(::Array)
+          key = name.to_sym
+          stack.reverse_each do |frame|
+            next unless frame.is_a?(::Hash)
+            return frame[key] if frame.key?(key)
+            sk = name.to_s
+            return frame[sk] if frame.key?(sk)
+          end
+          nil
+        end
+
+        def __homura_template_local_defined?(name)
+          stack = @__homura_template_locals__
+          return false unless stack.is_a?(::Array)
+          key = name.to_sym
+          sk = name.to_s
+          stack.reverse_each do |frame|
+            next unless frame.is_a?(::Hash)
+            return true if frame.key?(key) || frame.key?(sk)
+          end
+          false
+        end
+      end
+    end
+
+    # Method-missing fallback that surfaces template locals as bare names.
+    # Installed on Sinatra::Base so `<%= t['title'] %>` inside a
+    # precompiled partial Just Works without the user having to write
+    # `<%= locals[:t]['title'] %>`.
+    class ::Sinatra::Base
+      def method_missing(name, *args, &block)
+        if args.empty? && block.nil? && __homura_template_local_defined?(name)
+          return __homura_template_local__(name)
+        end
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        return true if __homura_template_local_defined?(name)
+        super
+      end
+    end
+
+    module ::Sinatra
+      module Templates
+
         def __homura_default_template_block_for__(template)
           case template.to_sym
           when :layout
@@ -350,6 +415,16 @@ def emit_sinatra_patch(io, namespace)
           end
         end
 
+        # A template is "layout-like" if its name is `:layout` or starts
+        # with `layout_` (e.g. `:layout_docs`). The auto-layout pass in
+        # `erb` skips wrapping such templates in `:layout` so that
+        # rendering `:layout_docs` doesn't end up nested inside `:layout`,
+        # which would otherwise produce a duplicate header / nav.
+        def __homura_layout_template?(template)
+          name = template.to_sym
+          name == :layout || name.to_s.start_with?('layout_')
+        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
@@ -367,7 +442,7 @@ def emit_sinatra_patch(io, namespace)
 
             layout = options[:layout]
             layout = false if layout.nil? && options.include?(:layout)
-            if layout.nil? && template.to_sym != :layout && ::#{namespace}.registered?(:layout)
+            if layout.nil? && !__homura_layout_template?(template) && ::#{namespace}.registered?(:layout)
               layout = :layout
             end
             if layout

data/lib/cloudflare_workers/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: homura-runtime
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.19
 platform: ruby
 authors:
 - Kazuhiro Homma