rusty_racer 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6e242a3632078fa63367b6e4d81ee7d720b6cfaef8355067137444b6fd48441
-  data.tar.gz: 1996ff995ae82ca4dba4de4e17c2e577d820b606bed710813e27e32d7c7a178e
+  metadata.gz: af5578c6ac8ba4eb6d367097be2faef786fdc0cb077ac5c76c14f1ec50106d41
+  data.tar.gz: 5cc05af64db35a3202c3fd72d2b0809e621ee7fa59c3db4e913ea537d835c438
 SHA512:
-  metadata.gz: 7bca218e9cb0384d7c4e61b8bb5d1c748eb38393163b5d104803698c8f51fe6fae9b4600d4a815be5b98b70a3dbce7ea60b2219d596a652e2f3b9c8144f50a55
-  data.tar.gz: 05b6aa55215bb555000fb9b99b698ac974f74d73a4c9687d04f6fa84039d4890d92be58e7edf68a78befb98919e329e34d8c95e938cd886cf05d469219d2039a
+  metadata.gz: ab88c79367db640e4144c0844a2ffcc0168f353de01ad7c225902c756d350f7a48188d9a3c0890ec6da2a61dc83e6a2484e519ccb082bb171d4fa795f89a4e7f
+  data.tar.gz: da6ca243ceb13b6d353ce15c6b59e725d617c0712e146a13017f2bbb2d7715dad0705849c4ce36b1b941b0dcb1a2a1750390d557b80c3e7a196809a66a5d4efa

data/README.md

@@ -15,7 +15,10 @@ Embed [V8](https://v8.dev/) in Ruby, built on [rusty_v8](https://crates.io/crate
   not just classic scripts.
 - **Faithful value marshalling**: `BigInt`, `Date`, `Map`, `Set`, typed binary
   (`Uint8Array`/`ArrayBuffer` ↔ binary `String`), and shared/cyclic object
-  graphs all round-trip — no lossy JSON hop.
+  graphs all round-trip — no lossy JSON hop. A JS `Map` surfaces in Ruby as a
+  `RustyRacer::JSMap` (a `Hash` subclass — it reads like a `Hash` but keeps its
+  non-string keys) and marshals back to a JS `Map`; a plain `Hash` still maps to a
+  JS object.
 - **In-thread execution** — V8 runs on the calling Ruby thread, with no dedicated
   V8 thread and no per-op thread hop; fast when you run many small ops.
 - **Drop-in [ExecJS](#execjs) runtime** — any ExecJS consumer switches with no
@@ -58,7 +61,7 @@ ctx.eval("1 + 1")                        # => 2
 ctx.eval("({a: 1, b: [true, 'x']})")     # => {"a"=>1, "b"=>[true, "x"]}
 
 # Call a JS function with marshalled args (BigInt/Date/Map/Set/shared refs
-# all round-trip faithfully).
+# all round-trip faithfully; a JS Map surfaces as a RustyRacer::JSMap).
 ctx.eval("function add(a, b) { return a + b }")
 ctx.call("add", 20, 22)                  # => 42
 ctx.call_void("doSideEffect")            # runs it; never marshals the return

data/ext/rusty_racer/Cargo.toml

@@ -4,7 +4,7 @@
 # libv8-rusty needed under the cibuildgem native-per-platform model).
 [package]
 name = "rusty_racer"
-version = "0.1.7"
+version = "0.1.8"
 edition = "2021"
 publish = false
 

data/ext/rusty_racer/src/lib.rs

@@ -3019,6 +3019,13 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     jsmodule.define_method("dispose", method!(JsModule::dispose, 0))?;
     jsmodule.define_method("disposed?", method!(JsModule::disposed, 0))?;
 
+    // A JS Map marshals to this Hash subclass (not a plain Hash) so the reverse
+    // direction can tell it apart from a JS Object — also a Hash — and rebuild a
+    // JS Map instead of a plain object. It behaves exactly like a Hash (so
+    // `assert_kind_of Hash` / `h[k]` still work); users may also construct one to
+    // hand a JS Map to JS. See marshal.rs.
+    module.define_class("JSMap", ruby.class_object().const_get::<_, magnus::RClass>("Hash")?)?;
+
     let platform = module.define_module("Platform")?;
     platform.define_singleton_method("set_flags!", function!(platform_set_flags, -1))?;
 

data/ext/rusty_racer/src/marshal.rs

@@ -48,8 +48,11 @@ pub(crate) enum JsVal {
     Array { id: u32, items: Vec<JsVal> },
     // JS object / Ruby Hash with string keys. Insertion order preserved.
     Obj { id: u32, entries: Vec<(String, JsVal)> },
-    // JS Map <-> Ruby Hash. Keys are arbitrary values (not just strings), so
-    // this is distinct from Obj. Insertion order preserved.
+    // JS Map <-> Ruby RustyRacer::JSMap (a Hash subclass). Keys are arbitrary
+    // values (not just strings), so this is distinct from Obj. Insertion order
+    // preserved. The JSMap subclass is what lets a Map round-trip: a plain Ruby
+    // Hash marshals to Obj (a JS Object), a JSMap to Map — the return leg tells
+    // them apart by class (Ruby has no native Map type).
     Map { id: u32, pairs: Vec<(JsVal, JsVal)> },
     // JS Set <-> Ruby Set (stdlib).
     Set { id: u32, items: Vec<JsVal> },
@@ -431,6 +434,15 @@ pub(crate) fn jsval_to_ruby(ruby: &Ruby, val: &JsVal) -> Result<Value, Error> {
 // reference. This invariant is load-bearing: do NOT refactor an arm to stash a
 // value in `built` without keeping it rooted by a live local until it's grafted.
 
+// The RustyRacer::JSMap class (a Hash subclass), defined in init. A JS Map
+// marshals to an instance of it so the reverse direction can distinguish it from
+// a plain Hash (a JS Object) and rebuild a JS Map. Errors only if init didn't run.
+fn js_map_class(ruby: &Ruby) -> Result<magnus::RClass, Error> {
+    ruby.class_object()
+        .const_get::<_, magnus::RModule>("RustyRacer")?
+        .const_get::<_, magnus::RClass>("JSMap")
+}
+
 fn jsval_to_ruby_d(
     ruby: &Ruby,
     val: &JsVal,
@@ -494,16 +506,27 @@ fn jsval_to_ruby_d(
             }
             h.as_value()
         }
-        // JS Map -> Ruby Hash (arbitrary marshalled keys, not just strings).
+        // JS Map -> RustyRacer::JSMap, a Hash subclass: arbitrary marshalled keys
+        // (not just strings) AND distinguishable from a JS Object (a plain Hash),
+        // so ruby_to_jsval can rebuild a JS Map rather than a plain object. Build
+        // empty then aset so a cyclic Map (a value referring back to the Map)
+        // resolves through the Ref table.
+        //
+        // LIMITATION: keys collapse by Ruby Hash equality (eql?/hash), but a JS
+        // Map keys by identity (SameValueZero). Primitive keys (string/number/
+        // bool/bigint) round-trip exactly; two distinct-but-structurally-equal
+        // OBJECT keys (e.g. `{}` and `{}`) become ONE entry — inherent to a Hash
+        // representation, and object identity can't survive copy-marshalling anyway.
         JsVal::Map { id, pairs } => {
-            let h = ruby.hash_new();
-            built.insert(*id, h.as_value());
+            let map_obj: Value = js_map_class(ruby)?.funcall("new", ())?;
+            built.insert(*id, map_obj);
+            let h = RHash::from_value(map_obj).expect("JSMap is a Hash");
             for (k, v) in pairs {
                 let kk = jsval_to_ruby_d(ruby, k, built)?;
                 let vv = jsval_to_ruby_d(ruby, v, built)?;
                 let _ = h.aset(kk, vv);
             }
-            h.as_value()
+            map_obj
         }
         // JS Set -> Ruby Set (stdlib); build empty then add so a cyclic Set
         // (a Set containing itself) resolves through the Ref table.
@@ -726,6 +749,31 @@ fn ruby_to_jsval_d(val: Value, seen: &mut RbSeen, depth: u32) -> Result<JsVal, E
         }
         return Ok(JsVal::Array { id, items });
     }
+    // RustyRacer::JSMap (a Hash subclass) -> JS Map, preserving arbitrary keys as
+    // real JS values (NOT string-coerced like a plain Hash -> JS Object). Must come
+    // BEFORE the Hash branch, since a JSMap IS-A Hash. This is what makes a JS Map
+    // round-trip (JS Map -> JSMap -> JS Map) instead of degrading to an object.
+    if let Ok(js_map) = js_map_class(&ruby) {
+        if val.is_kind_of(js_map) {
+            let id = match rb_container_id(seen, val, depth)? {
+                RbId::New(id) => id,
+                RbId::Reuse(jv) => return Ok(jv),
+            };
+            let hash = RHash::from_value(val).expect("JSMap is a Hash");
+            let pairs = RefCell::new(Vec::new());
+            hash.foreach(|k: Value, v: Value| {
+                pairs.borrow_mut().push((
+                    ruby_to_jsval_d(k, seen, depth + 1)?,
+                    ruby_to_jsval_d(v, seen, depth + 1)?,
+                ));
+                Ok(magnus::r_hash::ForEach::Continue)
+            })?;
+            return Ok(JsVal::Map {
+                id,
+                pairs: pairs.into_inner(),
+            });
+        }
+    }
     if let Ok(hash) = RHash::try_convert(val) {
         let id = match rb_container_id(seen, val, depth)? {
             RbId::New(id) => id,

data/lib/rusty_racer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RustyRacer
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rusty_racer
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Keita Urashima
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-14 00:00:00.000000000 Z
+date: 2026-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -54,7 +54,7 @@ metadata:
   source_code_uri: https://github.com/ursm/rusty_racer
   bug_tracker_uri: https://github.com/ursm/rusty_racer/issues
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -70,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.22
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Embed V8 in Ruby via rusty_v8 + Magnus (rb-sys)
 test_files: []