Simplify wrap: remove root parameter, unify hash handling

Author: tobi

lib/liquid/spec/json_rpc/drop_proxy.rb

@@ -44,7 +44,7 @@ class << self
           # Drops become { "_rpc_drop": "id", "type": "ClassName" }
           # Primitives pass through unchanged
           # Hashes and arrays are recursively wrapped
-          def wrap(obj, registry, seen = {}.compare_by_identity, root: true)
+          def wrap(obj, registry, seen = {}.compare_by_identity)
             # Return placeholder for circular references to prevent JSON nesting errors
             return "[circular]" if seen.key?(obj)
 
@@ -68,40 +68,29 @@ def wrap(obj, registry, seen = {}.compare_by_identity, root: true)
               # Ensure valid UTF-8 for JSON encoding
               sanitize_string(obj)
             when Hash
-              if root
-                # Root hash = environment. Keys are variable names — convert
-                # symbols to strings (normal behavior for JSON transport).
-                wrapped = {}
-                seen[obj] = wrapped
-                obj.each do |k, v|
-                  key = k.is_a?(String) ? sanitize_string(k) : k.to_s
-                  wrapped[key] = wrap(v, registry, seen, root: false)
-                end
-                wrapped
-              elsif obj.keys.any? { |k| !k.is_a?(String) }
-                # Inner hash with non-string keys (Symbol, Integer, etc.) —
+              if obj.keys.any? { |k| !k.is_a?(String) }
+                # Hash with non-string keys (Symbol, Integer, etc.) —
                 # can't be faithfully represented in JSON. Send a _ruby_type
                 # marker with the inspect string (for {{ v }} output) and a
                 # JSON-safe version (for hash access like {{ v.foo }}).
                 json_safe = {}
                 obj.each do |k, v|
-                  json_safe[k.to_s] = wrap(v, registry, seen, root: false)
+                  json_safe[k.to_s] = wrap(v, registry, seen)
                 end
                 { RUBY_TYPE_KEY => "Hash", "inspect" => obj.inspect, "data" => json_safe }
               else
-                # Inner hash with string keys — normal JSON transport
+                # String-keyed hash — normal JSON transport
                 wrapped = {}
                 seen[obj] = wrapped
                 obj.each do |k, v|
-                  wrapped[k] = wrap(v, registry, seen, root: false)
+                  wrapped[k] = wrap(v, registry, seen)
                 end
                 wrapped
               end
             when Array
               wrapped = []
               seen[obj] = wrapped
-              obj.each { |v| wrapped << wrap(v, registry, seen, root: false) }
-              wrapped
+              obj.each { |v| wrapped << wrap(v, registry, seen) }
             when Range
               # Ranges can't be faithfully represented in JSON.
               # Send a _ruby_type marker so the server can reconstruct

test/json_rpc_test.rb

@@ -149,15 +149,18 @@ def test_wrap_hash
     assert_equal({ "a" => 1, "b" => "hello" }, result)
   end
 
-  def test_wrap_hash_with_symbol_keys_root
-    # Root hash = environment. Symbol keys are variable names → converted
-    # to strings for JSON transport.
+  def test_wrap_hash_with_symbol_keys_ruby_type
+    # Hash with symbol keys — can't be faithfully represented in JSON.
+    # Sent as _ruby_type marker with inspect and JSON-safe data.
     input = { a: 1, b: "hello" }
     result = DropProxy.wrap(input, @registry)
 
-    assert_equal({ "a" => 1, "b" => "hello" }, result)
+    assert_equal "Hash", result["_ruby_type"]
+    assert result["inspect"].include?("a")
+    assert_equal({ "a" => 1, "b" => "hello" }, result["data"])
   end
-  def test_wrap_inner_hash_with_symbol_keys_ruby_type
+
+  def test_wrap_inner_hash_with_integer_keys_ruby_type
     # Inner hash with symbol keys — sent as _ruby_type marker with inspect
     # string (for {{ v }} output) and JSON-safe data (for hash access).
     input = { "v" => { a: 1, b: "hello" } }