homura-runtime 0.2.16 → 0.2.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 411bf1884ba07170427e2f1a905b2848c81e8de9d53caea247006c7d41377f3e
-  data.tar.gz: 83b2fc17572d59b4c93625553d2e46477e9df01161feaa76be41a8cb8e7acf5d
+  metadata.gz: 1bd6f3a366405aeb0ba2673c4827c7d34d8bef757d9194c64e71ca881bfe821f
+  data.tar.gz: 1ccc18ce83b42969bac914ecda37c21cdbfe79fd86971a1de1df1b25c3014302
 SHA512:
-  metadata.gz: 1d8fb86ad2a4aee75cc5c1864b954d04ac8bbda9fd4c10a1151076eeb0996db4eca85f59fcd25ae6721e060f409097a8a83856c30b57bc063e9145156973380e
-  data.tar.gz: 0a451bc7da52d28fd1d253bfe7b6885caa463b2f5790d53bbd2de0bc49f9ea7efe282c690a8131a0cc4fafa4dd720bc7f3571744280631acf5e423800343f3d5
+  metadata.gz: 777ce1497af06f6a5168bef5e195576fcdbd216a7da25b5d0eda657fea4757f074fb48f873f28eb3f6c5854c5ce98bf1f01dfa870b31a067eab93ef7dd8b9dce
+  data.tar.gz: 6a9e88cbfea6b27e46dc35c1bdb24bc02cdba8899839066d9d547057e18d9d67a319fdabed88a4ad36f852af49fd97bf41ef3aad964b720333bdd29c5c1438f6

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.2.17 (2026-04-27)
+
+- Rewrite class-variable references (`@@foo`) inside precompiled ERB
+  templates into explicit `class_variable_get` / `class_variable_set`
+  calls on the instance's class. Opal evaluates compiled template
+  bodies via `instance_exec` on a Sinatra instance whose `$$cvars`
+  slot is undefined at that runtime path, so the previous build emit
+  blew up with `TypeError: Cannot read properties of undefined (reading
+  '$$cvars')` whenever a template touched `<%= @@todos %>` or
+  `<% @@todos.each ... %>` directly. Templates can now use the
+  natural Sinatra style (`@@cvar` reads, `@@cvar = expr` and compound
+  `@@cvar op= expr` assignments) without route-level `@todos = @@todos`
+  shims. Fixes #28.
+
 ## 0.2.11 (2026-04-25)
 
 - Normalize bare JS `undefined` / `null` values to Ruby `nil` while converting

data/exe/compile-erb

@@ -54,7 +54,94 @@ module HomuraERB
 
   def normalize_fragment(fragment)
     return '__homura_template_yield__' if supported_yield_fragment?(fragment)
-    fragment
+    rewrite_class_variables(fragment)
+  end
+
+  # Opal compiles class-variable reads/writes (`@@foo`) into accessors
+  # bound to the lexically enclosing class, but precompiled ERB bodies
+  # are evaluated through `instance_exec` on a Sinatra instance whose
+  # `$$cvars` slot is undefined at that runtime path. The result is a
+  # `TypeError: Cannot read properties of undefined (reading '$$cvars')`
+  # the moment a template touches `<%= @@todos %>` directly — exactly
+  # the natural Sinatra style we want users to be able to keep writing.
+  #
+  # Rewrite both reads (`@@foo`) and writes (`@@foo = expr`) into
+  # explicit `class_variable_get` / `class_variable_set` calls on the
+  # instance's class so the same source compiles cleanly under Opal
+  # without requiring `@foo = @@foo` shims at the route layer.
+  #
+  # The rewrite is a deliberately small regex pass: ERB fragments are
+  # short, and class-variable tokens inside Ruby string literals or
+  # comments are vanishingly rare in real templates. Anything more
+  # ambitious would need a Ruby parser, which is overkill for the
+  # `@@ivar` shape we actually have to handle here.
+  CVAR_OP_ASSIGN_RE = /(?<![@\w])@@([A-Za-z_]\w*)\s*(\|\||&&|\+|-|\*|\/|%|\*\*|<<|>>|\||&|\^)=\s*([^;\n]+)/.freeze
+  CVAR_ASSIGN_RE = /(?<![@\w])@@([A-Za-z_]\w*)\s*=(?!=)\s*([^;\n]+)/.freeze
+  # Read pattern excludes `@@name` that appears on the left-hand side
+  # of an assignment (`@@name =`, `@@name +=`, `@@name ||=`, etc.) so
+  # the assignment passes still see the raw token to rewrite. The
+  # `=(?!=)` guard keeps `==` (comparison) treated as a read.
+  CVAR_READ_RE = %r{
+    (?<![@\w])@@([A-Za-z_]\w*)\b
+    (?!
+      \s*
+      (?:\|\||&&|\+|-|\*|/|%|\*\*|<<|>>|\||&|\^)?
+      =(?!=)
+    )
+  }x.freeze
+
+  CVAR_PLACEHOLDER_PREFIX = "\x01HOMURA_CVAR\x01".freeze
+  CVAR_PLACEHOLDER_SUFFIX = "\x01".freeze
+
+  def rewrite_class_variables(fragment)
+    return fragment unless fragment.include?('@@')
+
+    placeholders = []
+    record = lambda do |replacement|
+      placeholders << replacement
+      "#{CVAR_PLACEHOLDER_PREFIX}#{placeholders.length - 1}#{CVAR_PLACEHOLDER_SUFFIX}"
+    end
+
+    # Reads first: rewrite every `@@name` that is *not* the target of
+    # an assignment, including occurrences on the right-hand side of
+    # an assignment. Each match collapses into a sentinel so the
+    # later assignment passes see the original `@@name = ...` shape
+    # (without their RHS reads being clobbered) and so the final
+    # output never re-enters this same rewrite loop.
+    work = fragment.gsub(CVAR_READ_RE) do
+      name = Regexp.last_match(1)
+      record.call("self.class.class_variable_get(:@@#{name})")
+    end
+
+    work = work.gsub(CVAR_OP_ASSIGN_RE) do
+      name = Regexp.last_match(1)
+      op = Regexp.last_match(2)
+      value = Regexp.last_match(3)
+      replacement =
+        case op
+        when '||'
+          "self.class.class_variable_set(:@@#{name}, (self.class.class_variable_defined?(:@@#{name}) ? self.class.class_variable_get(:@@#{name}) : nil) || (#{value}))"
+        when '&&'
+          "self.class.class_variable_set(:@@#{name}, (self.class.class_variable_defined?(:@@#{name}) ? self.class.class_variable_get(:@@#{name}) : nil) && (#{value}))"
+        else
+          "self.class.class_variable_set(:@@#{name}, self.class.class_variable_get(:@@#{name}) #{op} (#{value}))"
+        end
+      record.call(replacement)
+    end
+
+    work = work.gsub(CVAR_ASSIGN_RE) do
+      name = Regexp.last_match(1)
+      value = Regexp.last_match(2)
+      record.call("self.class.class_variable_set(:@@#{name}, (#{value}))")
+    end
+
+    placeholder_re = /#{Regexp.escape(CVAR_PLACEHOLDER_PREFIX)}(\d+)#{Regexp.escape(CVAR_PLACEHOLDER_SUFFIX)}/
+    loop do
+      replaced = work.gsub(placeholder_re) { placeholders[Regexp.last_match(1).to_i] }
+      break if replaced == work
+      work = replaced
+    end
+    work
   end
 
   def validate_code_fragment!(fragment)
@@ -200,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
 
@@ -254,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

data/lib/cloudflare_workers/version.rb

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

metadata

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