nosj 0.4.1 → 0.5.0

data/ext/nosj/src/gen/walker.rs

@@ -16,8 +16,9 @@ use super::keys::GenKeyCache;
 use super::opts::GenConfig;
 use super::ruby::{
     is_json_fragment, is_special_const, protected_as_json, protected_encode_utf8,
-    protected_to_json, protected_to_json_if_responds, protected_to_s, rstring_bytes, str_coderange,
-    str_enc_index, utf8_encindexes, CR_7BIT, CR_VALID, QFALSE, QNIL, QTRUE,
+    protected_inspect, protected_to_json, protected_to_json_if_responds, protected_to_s,
+    rstring_bytes, str_coderange, str_enc_index, utf8_encindexes, CR_7BIT, CR_VALID, QFALSE, QNIL,
+    QTRUE,
 };
 
 /// Whether keys escaped under `mode` may be cached: the cached bytes
@@ -27,6 +28,84 @@ pub(super) fn mode_cacheable(mode: EscapeMode) -> bool {
     matches!(mode, EscapeMode::Standard | EscapeMode::HtmlSafe)
 }
 
+/// A hash key's kind: how it renders (see [`key_string`]) and json 3's
+/// duplicate-key rule.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum KeyKind {
+    String,
+    Symbol,
+    Other,
+}
+
+#[inline(always)]
+fn key_kind(k: VALUE) -> KeyKind {
+    if !is_special_const(k) {
+        match unsafe { RB_BUILTIN_TYPE(k) } {
+            ruby_value_type::RUBY_T_STRING => KeyKind::String,
+            ruby_value_type::RUBY_T_SYMBOL => KeyKind::Symbol,
+            _ => KeyKind::Other,
+        }
+    } else if STATIC_SYM_P(k) {
+        KeyKind::Symbol
+    } else {
+        KeyKind::Other
+    }
+}
+
+/// The String a key renders as, the gem's key coercion: Strings as they
+/// are, Symbols by name, anything else through `to_s`.
+fn key_string(k: VALUE, kind: KeyKind) -> Result<VALUE, Error> {
+    match kind {
+        KeyKind::String => Ok(k),
+        KeyKind::Symbol => Ok(unsafe { rb_sys::rb_sym2str(k) }),
+        KeyKind::Other => protected_to_s(k),
+    }
+}
+
+/// json 3's cheap trigger for its duplicate-key check, per hash: keys of
+/// one kind cannot render alike, so only a String or Symbol key in a
+/// hash whose first key was of another kind runs the full check (once).
+/// A key of the first key's kind costs one byte compare (the Option
+/// packs into one byte), a hash's first key one more; only actual
+/// mixing goes out of line.
+struct MixedKeys {
+    first: Option<KeyKind>,
+    /// Checked already, or `allow_duplicate_key`: nothing left to do.
+    done: bool,
+}
+
+impl MixedKeys {
+    #[inline(always)]
+    fn new(allow_duplicate_key: bool) -> Self {
+        MixedKeys {
+            first: None,
+            done: allow_duplicate_key,
+        }
+    }
+
+    #[inline(always)]
+    fn needs_check(&mut self, kind: KeyKind) -> bool {
+        match self.first {
+            Some(first) if first == kind => false,
+            None => {
+                self.first = Some(kind);
+                false
+            }
+            Some(_) => self.mixed(kind),
+        }
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn mixed(&mut self, kind: KeyKind) -> bool {
+        if self.done || kind == KeyKind::Other {
+            return false;
+        }
+        self.done = true;
+        true
+    }
+}
+
 pub(super) struct Gen<'a> {
     /// The pooled per-thread output buffer, borrowed for the call.
     pub(super) out: &'a mut Vec<u8>,
@@ -164,13 +243,19 @@ impl Gen<'_> {
     /// The pre-escaped bytes for `k` when the cache may serve it:
     /// frozen string key, cacheable escape mode (see
     /// [`Gen::emit_key_cached`]). An associated fn over the split-out
-    /// fields so callers keep `self.out` free.
+    /// fields so callers keep `self.out` free. `kind` is the caller's
+    /// [`key_kind`] of `k`, computed once per pair for both this and
+    /// the duplicate-key tracking.
     #[inline(always)]
-    fn cached_key_bytes<'k>(cfg: &GenConfig, keys: &'k GenKeyCache, k: VALUE) -> Option<&'k [u8]> {
+    fn cached_key_bytes<'k>(
+        cfg: &GenConfig,
+        keys: &'k GenKeyCache,
+        k: VALUE,
+        kind: KeyKind,
+    ) -> Option<&'k [u8]> {
         const FL_FREEZE: u64 = rb_sys::ruby_fl_type::RUBY_FL_FREEZE as u64;
-        if mode_cacheable(cfg.mode)
-            && !is_special_const(k)
-            && unsafe { RB_BUILTIN_TYPE(k) } == ruby_value_type::RUBY_T_STRING
+        if kind == KeyKind::String
+            && mode_cacheable(cfg.mode)
             && unsafe { (*(k as *const rb_sys::RBasic)).flags } & FL_FREEZE != 0
         {
             keys.get(k)
@@ -187,8 +272,8 @@ impl Gen<'_> {
     /// all through the cache-hit path here. Misses take the plain path
     /// below, which also populates the cache.
     #[inline(always)]
-    fn emit_pair_prefix_compact(&mut self, k: VALUE, comma: bool) -> Result<(), ()> {
-        if let Some(bytes) = Self::cached_key_bytes(self.cfg, self.keys, k) {
+    fn emit_pair_prefix_compact(&mut self, k: VALUE, kind: KeyKind, comma: bool) -> Result<(), ()> {
+        if let Some(bytes) = Self::cached_key_bytes(self.cfg, self.keys, k, kind) {
             let n = bytes.len();
             self.out.reserve(n + 2);
             // SAFETY: `n + 2` bytes reserved above; `bytes` borrows
@@ -211,7 +296,7 @@ impl Gen<'_> {
         if comma {
             self.out.push(b',');
         }
-        self.emit_key(k)?;
+        self.emit_key(k, kind)?;
         self.out.push(b':');
         Ok(())
     }
@@ -221,8 +306,14 @@ impl Gen<'_> {
     /// separator, cached key, colon, and digits in one reservation and
     /// one raw cursor.
     #[inline(always)]
-    fn emit_pair_int_compact(&mut self, k: VALUE, comma: bool, value: i64) -> Result<(), ()> {
-        if let Some(bytes) = Self::cached_key_bytes(self.cfg, self.keys, k) {
+    fn emit_pair_int_compact(
+        &mut self,
+        k: VALUE,
+        kind: KeyKind,
+        comma: bool,
+        value: i64,
+    ) -> Result<(), ()> {
+        if let Some(bytes) = Self::cached_key_bytes(self.cfg, self.keys, k, kind) {
             let n = bytes.len();
             self.out.reserve(n + 2 + emit::I64_MAX_LEN);
             // SAFETY: the reservation covers separator + key + colon +
@@ -245,28 +336,18 @@ impl Gen<'_> {
             }
             return Ok(());
         }
-        self.emit_pair_prefix_compact(k, comma)?;
+        self.emit_pair_prefix_compact(k, kind, comma)?;
         emit::write_i64(&mut *self.out, value);
         Ok(())
     }
 
-    /// Object/hash key: String and Symbol direct, anything else via to_s
-    /// (the gem's key coercion).
-    fn emit_key(&mut self, k: VALUE) -> Result<(), ()> {
-        if !is_special_const(k) {
-            match unsafe { RB_BUILTIN_TYPE(k) } {
-                ruby_value_type::RUBY_T_STRING => return self.emit_key_cached(k),
-                ruby_value_type::RUBY_T_SYMBOL => {
-                    let s = unsafe { rb_sys::rb_sym2str(k) };
-                    return self.emit_rstring_quoted(s);
-                }
-                _ => {}
-            }
-        } else if STATIC_SYM_P(k) {
-            let s = unsafe { rb_sys::rb_sym2str(k) };
-            return self.emit_rstring_quoted(s);
+    /// Object/hash key of `kind` (the caller's [`key_kind`]), rendered
+    /// by [`key_string`]; String keys go through the pre-escaped cache.
+    fn emit_key(&mut self, k: VALUE, kind: KeyKind) -> Result<(), ()> {
+        if kind == KeyKind::String {
+            return self.emit_key_cached(k);
         }
-        let s = self.reraise(protected_to_s(k))?;
+        let s = self.reraise(key_string(k, kind))?;
         self.emit_rstring_quoted(s)
     }
 
@@ -311,6 +392,50 @@ impl Gen<'_> {
         self.emit_rstring_quoted(s)
     }
 
+    /// json 3's full duplicate check, run once for a hash whose keys
+    /// mixed kinds: every key through `to_s`, first repeat raises the
+    /// gem's exact message. Cold: only mixed-kind hashes reach it.
+    #[cold]
+    fn check_duplicate_keys(&mut self, hash: VALUE) -> Result<(), ()> {
+        use super::hash_iter::{foreach_raw, Step};
+        let mut seen = std::collections::HashSet::new();
+        let mut outcome: Result<Option<VALUE>, Error> = Ok(None);
+        // SAFETY: only reached for T_HASH values.
+        unsafe {
+            foreach_raw(hash, |k, _| {
+                let key_str = match key_string(k, key_kind(k)) {
+                    Ok(s) => s,
+                    Err(exc) => {
+                        outcome = Err(exc);
+                        return Step::Stop;
+                    }
+                };
+                if seen.insert(rstring_bytes(key_str).to_vec()) {
+                    Step::Continue
+                } else {
+                    outcome = Ok(Some(key_str));
+                    Step::Stop
+                }
+            });
+        }
+        let Some(key_str) = self.reraise(outcome)? else {
+            return Ok(());
+        };
+        let key_inspect = self.reraise(protected_inspect(key_str))?;
+        let hash_inspect = self.reraise(protected_inspect(hash))?;
+        // SAFETY: rb_inspect returns Strings; both are copied out here.
+        let (key_inspect, hash_inspect) = unsafe {
+            (
+                String::from_utf8_lossy(rstring_bytes(key_inspect)).into_owned(),
+                String::from_utf8_lossy(rstring_bytes(hash_inspect)).into_owned(),
+            )
+        };
+        self.fail = Some(GenFail::Generator(format!(
+            "detected duplicate key {key_inspect} in {hash_inspect}"
+        )));
+        Err(())
+    }
+
     /// Splice `raw`'s `to_json` result verbatim: the JSON::Fragment
     /// path (pre-rendered JSON, trusted like the gem trusts it).
     fn splice_to_json(&mut self, raw: VALUE) -> Result<(), ()> {
@@ -506,18 +631,23 @@ impl Gen<'_> {
             self.out.push(b'}');
             return Ok(());
         }
+        let mut mixed = MixedKeys::new(self.cfg.allow_duplicate_key);
         // SAFETY: emit_object is only reached for T_HASH values.
         if PRETTY {
             let mut first = true;
             unsafe {
                 foreach_raw(hash, |k, v| {
+                    let kind = key_kind(k);
+                    if mixed.needs_check(kind) && self.check_duplicate_keys(hash).is_err() {
+                        return Step::Stop;
+                    }
                     if !first {
                         self.out.push(b',');
                     }
                     first = false;
                     self.out.extend_from_slice(&self.cfg.object_nl);
                     self.push_indent(inner);
-                    if self.emit_key(k).is_err() {
+                    if self.emit_key(k, kind).is_err() {
                         return Step::Stop;
                     }
                     self.out.extend_from_slice(&self.cfg.space_before);
@@ -532,20 +662,24 @@ impl Gen<'_> {
         } else {
             unsafe {
                 foreach_raw(hash, |k, v| {
+                    let kind = key_kind(k);
+                    if mixed.needs_check(kind) && self.check_duplicate_keys(hash).is_err() {
+                        return Step::Stop;
+                    }
                     // `out` always ends with '{' (just pushed) or the
                     // previous pair.
                     let comma = *self.out.last().unwrap_unchecked() != b'{';
                     // Int values fuse with their key into one write.
                     if FIXNUM_P(v) {
                         if self
-                            .emit_pair_int_compact(k, comma, FIX2LONG(v) as i64)
+                            .emit_pair_int_compact(k, kind, comma, FIX2LONG(v) as i64)
                             .is_err()
                         {
                             return Step::Stop;
                         }
                         return Step::Continue;
                     }
-                    if self.emit_pair_prefix_compact(k, comma).is_err() {
+                    if self.emit_pair_prefix_compact(k, kind, comma).is_err() {
                         return Step::Stop;
                     }
                     // Value fast arms, mirroring emit_value's: one

data/ext/nosj/src/lib.rs

@@ -4,6 +4,8 @@
 //! - `parse.rs`: whole-document entry points (parse, valid?, the
 //!   GVL-releasing indexed parse) plus shared option decoding and
 //!   input gating.
+//! - `opt_reader.rs`: options-hash reading with json 3's unknown-key
+//!   rule, shared by the parse and generate decoders.
 //! - `pointer.rs`: partial parsing (dig, at_pointer, batch forms).
 //! - `lazy.rs`: lazy documents (NOSJ.lazy nodes resolving access on
 //!   demand over shared document bytes).
@@ -23,6 +25,8 @@ pub mod files;
 pub mod gen;
 pub mod lazy;
 pub mod lines;
+pub mod locate;
+pub mod opt_reader;
 pub mod parse;
 pub mod patch;
 pub mod pointer;

data/ext/nosj/src/locate.rs

@@ -0,0 +1,162 @@
+//! Cold-path positions for the refusals a sink detects without offsets.
+//!
+//! Sinks see events, not byte positions, so a duplicate key (found by
+//! hash size or key fingerprints) or a lone surrogate (delivered as
+//! WTF-8) aborts the drive with no location. These walks re-read the
+//! same bytes with the crate's pull `Reader`, under the same grammar
+//! options, to find where. Each is linear and iterative: one `Reader`
+//! over the whole document, an explicit stack instead of recursion, so
+//! no nesting depth is out of reach.
+
+use std::collections::HashSet;
+
+use nosj::{Buffers, Node, ParseError, ParseOptions, Reader};
+
+use crate::parse::span_of;
+
+/// What the exact check found behind a sink's duplicate-key refusal.
+pub(crate) enum Repeat {
+    /// The first object, in the order objects close (as the drive meets
+    /// them), that repeats a key: the offset of its `{` and the key.
+    Found { at: usize, key: String },
+    /// No object repeats a key: the refusal was a fingerprint collision.
+    Absent,
+    /// The walk stopped on a Reader error before deciding. Callers
+    /// treat it as a refusal.
+    Undecided,
+}
+
+pub(crate) fn duplicate_key(doc: &[u8], popts: ParseOptions) -> Repeat {
+    match scan(doc, popts, true) {
+        Ok(None) => Repeat::Absent,
+        Ok(Some((path, key))) => match container_offset(doc, &path, popts) {
+            Ok(at) => Repeat::Found { at, key },
+            Err(_) => Repeat::Undecided,
+        },
+        Err(_) => Repeat::Undecided,
+    }
+}
+
+/// The first error a full walk of `doc` meets, decoding every string
+/// and key: where a lone surrogate the sink refused sits (the Reader
+/// rejects them with a position).
+pub(crate) fn first_walk_error(doc: &[u8], popts: ParseOptions) -> Option<ParseError> {
+    scan(doc, popts, false).err()
+}
+
+/// One open container of [`scan`]'s walk.
+struct Frame {
+    object: bool,
+    /// The member or element being walked.
+    index: usize,
+    seen: HashSet<String>,
+    repeated: Option<String>,
+}
+
+impl Frame {
+    fn open(object: bool) -> Self {
+        Frame {
+            object,
+            index: 0,
+            seen: HashSet::new(),
+            repeated: None,
+        }
+    }
+
+    fn note_key(&mut self, key: &str) {
+        if self.repeated.is_none() && !self.seen.insert(key.to_owned()) {
+            self.repeated = Some(key.to_owned());
+        }
+    }
+}
+
+/// Walk all of `doc`, depth first. With `find_repeats`, stop at the
+/// first object to close with a repeated key: the member/element
+/// indices from the root down to it, and the key.
+fn scan(
+    doc: &[u8],
+    popts: ParseOptions,
+    find_repeats: bool,
+) -> Result<Option<(Vec<usize>, String)>, ParseError> {
+    let mut bufs = Buffers::new();
+    // SAFETY: `doc` is validated UTF-8.
+    let mut r = unsafe { Reader::from_utf8_unchecked_with(doc, &mut bufs, popts) };
+    let mut stack: Vec<Frame> = Vec::new();
+    loop {
+        // The cursor is at a value: open it, or step past it.
+        let opened = match r.next_node()? {
+            Node::ObjectStart => match r.object_first_key()? {
+                Some(key) => {
+                    let mut frame = Frame::open(true);
+                    if find_repeats {
+                        frame.note_key(key);
+                    }
+                    Some(frame)
+                }
+                None => None,
+            },
+            Node::ArrayStart => r.array_first()?.then(|| Frame::open(false)),
+            _ => None,
+        };
+        if let Some(frame) = opened {
+            stack.push(frame);
+            continue;
+        }
+        // The value is complete: advance its container, closing every
+        // container it completes on the way up.
+        loop {
+            let Some(top) = stack.last_mut() else {
+                return Ok(None);
+            };
+            let more = if top.object {
+                match r.object_next_key()? {
+                    Some(key) => {
+                        if find_repeats {
+                            top.note_key(key);
+                        }
+                        true
+                    }
+                    None => false,
+                }
+            } else {
+                r.array_next()?
+            };
+            if more {
+                top.index += 1;
+                break;
+            }
+            if let Some(key) = stack.pop().and_then(|closed| closed.repeated) {
+                return Ok(Some((stack.iter().map(|f| f.index).collect(), key)));
+            }
+        }
+    }
+}
+
+/// The offset of the container at `path`, member/element indices from
+/// the root: walk down skipping earlier siblings, then skip the
+/// container itself, whose slice starts at its bracket.
+fn container_offset(doc: &[u8], path: &[usize], popts: ParseOptions) -> Result<usize, ParseError> {
+    let mut bufs = Buffers::new();
+    // SAFETY: `doc` is validated UTF-8.
+    let mut r = unsafe { Reader::from_utf8_unchecked_with(doc, &mut bufs, popts) };
+    // Every index on the path was walked by `scan`, so each step lands
+    // on an existing member.
+    for &index in path {
+        let object = matches!(r.next_node()?, Node::ObjectStart);
+        if object {
+            r.object_first_key()?;
+        } else {
+            r.array_first()?;
+        }
+        for _ in 0..index {
+            r.skip_value()?;
+            if object {
+                r.object_next_key()?;
+            } else {
+                r.array_next()?;
+            }
+        }
+    }
+    let container = r.skip_value()?;
+    Ok(span_of(doc, container.as_bytes()).0)
+}

data/ext/nosj/src/opt_reader.rs

@@ -0,0 +1,170 @@
+//! Options-hash reading under json 3's unknown-key rule: every key of an
+//! options hash must be one the entry point reads, else ArgumentError
+//! in json 3's wording ("unknown keyword: foo"). A reader counts the
+//! keys it finds, so a clean hash costs one length compare; only a
+//! shortfall walks the hash to name the keys nobody read.
+
+use magnus::r_hash::ForEach;
+use magnus::value::ReprValue;
+use magnus::{Error, RHash, Ruby, Symbol, Value};
+
+macro_rules! options {
+    ($($variant:ident => $name:literal,)*) => {
+        /// Every option any entry point reads. The discriminant is the
+        /// option's bit in [`OptReader`]'s masks, so a key two decoders
+        /// read from one hash (reformat takes parse and generate
+        /// options together) counts once.
+        #[derive(Clone, Copy)]
+        pub(crate) enum Opt {
+            $($variant,)*
+        }
+
+        /// Ruby option names, indexed by [`Opt`] discriminant.
+        const NAMES: &[&str] = &[$($name,)*];
+    };
+}
+
+options! {
+    SymbolizeNames => "symbolize_names",
+    Freeze => "freeze",
+    MaxNesting => "max_nesting",
+    AllowNan => "allow_nan",
+    AllowTrailingComma => "allow_trailing_comma",
+    AllowDuplicateKey => "allow_duplicate_key",
+    ObjectClass => "object_class",
+    ArrayClass => "array_class",
+    DecimalClass => "decimal_class",
+    OnLoad => "on_load",
+    CreateAdditions => "create_additions",
+    AllowComments => "allow_comments",
+    AllowControlCharacters => "allow_control_characters",
+    AllowInvalidEscape => "allow_invalid_escape",
+    Indent => "indent",
+    Space => "space",
+    SpaceBefore => "space_before",
+    ObjectNl => "object_nl",
+    ArrayNl => "array_nl",
+    AsciiOnly => "ascii_only",
+    ScriptSafe => "script_safe",
+    Strict => "strict",
+    Depth => "depth",
+    BufferInitialLength => "buffer_initial_length",
+    SortKeys => "sort_keys",
+    AsJson => "as_json",
+}
+
+const _: () = assert!(NAMES.len() <= u64::BITS as usize);
+
+impl Opt {
+    fn bit(self) -> u64 {
+        1 << self as u32
+    }
+
+    pub(crate) fn name(self) -> &'static str {
+        NAMES[self as usize]
+    }
+}
+
+pub(crate) struct OptReader<'a> {
+    ruby: &'a Ruby,
+    hash: RHash,
+    /// The hash's key count, read once.
+    len: usize,
+    /// Options read and present in the hash.
+    found: u64,
+    /// Options accepted only while falsy (see [`OptReader::tolerate`]).
+    tolerated: u64,
+}
+
+impl<'a> OptReader<'a> {
+    pub(crate) fn new(ruby: &'a Ruby, hash: RHash) -> Self {
+        Self {
+            ruby,
+            hash,
+            len: hash.len(),
+            found: 0,
+            tolerated: 0,
+        }
+    }
+
+    pub(crate) fn ruby(&self) -> &'a Ruby {
+        self.ruby
+    }
+
+    fn all_found(&self) -> bool {
+        self.found.count_ones() as usize == self.len
+    }
+
+    /// The value under `opt`'s Symbol key; an explicit nil is present.
+    /// Once every key is found, the rest are absent without a lookup
+    /// (`{symbolize_names: true}` costs one lookup, not six). An option
+    /// read twice (reformat reads a few for both parsing and
+    /// generating) is looked up again.
+    pub(crate) fn get(&mut self, opt: Opt) -> Option<Value> {
+        if self.all_found() && self.found & opt.bit() == 0 {
+            return None;
+        }
+        // An interned StaticSymbol: no String allocation per lookup.
+        let value = self.hash.get(self.ruby.sym_new(opt.name()));
+        if value.is_some() {
+            self.found |= opt.bit();
+        }
+        value
+    }
+
+    pub(crate) fn truthy(&mut self, opt: Opt) -> bool {
+        self.get(opt).is_some_and(|v| v.to_bool())
+    }
+
+    /// Accept these json options, which NOSJ does not implement, only
+    /// while falsy: their default behavior is NOSJ's, anything else
+    /// would be silently ignored. No lookup happens here: such a key can
+    /// only be present when the reads leave keys unfound, so
+    /// [`OptReader::finish`] checks them on its cold path.
+    pub(crate) fn tolerate(&mut self, opts: &[Opt]) {
+        for opt in opts {
+            self.tolerated |= opt.bit();
+        }
+    }
+
+    /// Raise for keys no read asked for, and for tolerated options set
+    /// to something truthy.
+    pub(crate) fn finish(self) -> Result<(), Error> {
+        if self.all_found() {
+            return Ok(());
+        }
+        self.leftover_keys()
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn leftover_keys(self) -> Result<(), Error> {
+        let (found, tolerated) = (self.found, self.tolerated);
+        let option_of = |key: Value| {
+            let name = Symbol::from_value(key)?.name().ok()?;
+            NAMES.iter().position(|known| *known == name)
+        };
+        let mut unknown = Vec::new();
+        let mut unsupported = None;
+        self.hash.foreach(|key: Value, value: Value| {
+            match option_of(key).map(|index| 1u64 << index) {
+                Some(bit) if found & bit != 0 => {}
+                Some(bit) if tolerated & bit != 0 => {
+                    if value.to_bool() {
+                        unsupported = Some(key.to_string());
+                        return Ok(ForEach::Stop);
+                    }
+                }
+                _ => unknown.push(key.to_string()),
+            }
+            Ok(ForEach::Continue)
+        })?;
+        let message = match (unsupported, unknown.as_slice()) {
+            (Some(name), _) => format!("NOSJ does not support the {name} option"),
+            (None, []) => return Ok(()),
+            (None, [key]) => format!("unknown keyword: {key}"),
+            (None, keys) => format!("unknown keywords: {}", keys.join(", ")),
+        };
+        Err(Error::new(self.ruby.exception_arg_error(), message))
+    }
+}