smarter_json 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65b2a8f15607b861034e600fd42233328803ebbcb652e8cb8b162811e24779e2
-  data.tar.gz: 191467cd1d29030d054c1cdaabb444523af54fb71486721182ddcdf9a4781d92
+  metadata.gz: 00a4ada7970ab645761573bd3b9704effda072064102ead760124716f0896289
+  data.tar.gz: a7232f3d8d06d3b7d770645b28a247774c83b8ac50603e4b7611006e852480d4
 SHA512:
-  metadata.gz: c26d4ffb0789fbe7303b80d80877f02164f79f7fe2ae9eff0e17de90df4ba8da19568c7a1fa5d10d5d324c8f4a841cd8ad0917f5ab6a5f381368404f56a1ec5c
-  data.tar.gz: 6c3fbbf21ec9f9c6300516268ad4e7741aeaab8a6732ab138497f6af5b02afbfd944fdce6d4c7095f699469b77fd2fa2cf5e65ea58712ad55da0e5c745fd6551
+  metadata.gz: a4b4b8737f10ebf09408014419a9d5cf2203b706766ea5acc358ad595c5cc34104b3f658f2ca6cf6b130124c514d89d035dea2a0ea16e619ffaec7da16da4a23
+  data.tar.gz: a317f74e3399d6b95327fb10a7b65d2ca0f07062d9097303ab32aefb6721a46a78784addd0a937c0c8f433c4acb4e7758af3986fa741bd0d5b816141ee101fd4

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 
 # SmarterJSON Change Log
 
+> 🚧 Getting ready for the 1.0.0 release - sorry for the interface changes - thank you for your patience! 🚧
+
+## 0.7.0 (2026-06-02)
+- **Breaking:** replaced the `warnings:` option (and its `[result, warnings]` tuple return) with an `on_warning:` callable. Pass `on_warning: ->(w) { ... }` to be handed each `SmarterJSON::Warning` as the parser applies a lenient fix; `process` / `process_file` now always return the bare value (nil / value / Array) on every path. Unlike the tuple, this also fires on the streaming block form. The default (no handler) records nothing and costs nothing.
+
 ## 0.6.0 (2026-06-02)
 - Lenient comma handling: empty slots around / between commas are collapsed (`[1,,2]` → `[1,2]`, `[,1,]` → `[1]`, `{a:1,,b:2}` → `{a:1,b:2}`), on both the C and Ruby paths. No null is inserted for an empty slot.
 - A key with a colon but no value reads as null: `{a:}` → `{"a"=>nil}` (both paths).
@@ -9,12 +14,12 @@
 - Fixed a pure-Ruby bug where a `\u` escape whose next bytes split a multibyte character leaked `ArgumentError`; it now raises `SmarterJSON::ParseError`.
 - Added a property/fuzz test suite that checks C/Ruby parity and round-tripping on generated, mutated, and random input.
 
-## 0.5.2 (2026-06-01)
+## 0.5.2 (2026-06-01) yanked
 - `generate` now supports pretty-printing via the `indent:` option (spaces per nesting level; default `0` = compact). Empty objects/arrays stay inline; `indent:` combined with `format: :ndjson` raises `ArgumentError`.
 - `generate` adds `sort_keys:` (emit object keys in sorted order), `ascii_only:` (escape non-ASCII as `\uXXXX`, astral chars as surrogate pairs), and `script_safe:` (escape `</` and U+2028/U+2029 for safe embedding in an HTML `<script>` tag).
 - `generate` adds opt-in `coerce:` — when `true`, a value that isn't natively supported (e.g. `Time`, `Date`, app objects) is converted via its own `as_json` (result re-emitted) or `to_json` (spliced); strict-by-default still raises `GenerateError`.
 
-## 0.5.1 (2026-06-01)
+## 0.5.1 (2026-06-01) yanked
 - Unified the error classes under a single `SmarterJSON::Error` base: `ParseError` and `EncodingError` now inherit from it, and `generate` raises a new `GenerateError`. `rescue SmarterJSON::Error` now catches everything the gem raises.
 - Added a CI test matrix (Ruby 2.6–4.0 + head, on Ubuntu and macOS).
 - Fixed the C extension build on Ruby 2.6 (declare `rb_hash_bulk_insert`, which 2.6 exports but does not declare in its headers); set the minimum Ruby to 2.6.

data/README.md

@@ -81,7 +81,20 @@ SmarterJSON.process_file("events.ndjson") { |event| EventJob.perform_async(event
 | `bigdecimal_load` | `:auto`      | `:auto` keeps high-precision decimals as `BigDecimal`; `:float` forces `Float`; `:bigdecimal` forces `BigDecimal` |
 | `acceleration`    | `true`       | `true` uses the C extension when compiled and loadable; `false` forces pure Ruby (identical results) |
 | `encoding`        | `"UTF-8"`    | labels the input's encoding (no transcoding pass; see below)            |
-| `warnings`        | `false`      | when `true`, return `[result, warnings]` — `warnings` lists the lenient fixes applied (`:empty_slot`, `:empty_value`, `:duplicate_key`) |
+| `on_warning`      | `nil`        | a callable invoked once per lenient fix applied (`:empty_slot`, `:empty_value`, `:duplicate_key`), passed a `SmarterJSON::Warning`; the return value is never changed. See below. |
+
+### Warnings (`on_warning`)
+
+When the parser quietly fixes something lenient — collapses an empty comma slot, reads a key with no value as `null`, drops a duplicate key — it can tell you, without changing what `process` returns. Pass a callable as `on_warning:`; it is invoked once per fix with a `SmarterJSON::Warning` (`type`, `message`, `line`, `col`). It fires on every path, including the streaming block form. With no handler (the default) nothing is recorded and there is zero overhead.
+
+```ruby
+# Collect them all:
+warns = []
+data  = SmarterJSON.process(input, on_warning: ->(w) { warns << w })
+
+# Or route them — log, count, raise:
+SmarterJSON.process(input, on_warning: ->(w) { Rails.logger.warn(w) })
+```
 
 ## Performance
 

data/docs/basic_read_api.md

@@ -67,18 +67,19 @@ The streaming path reads the input as newline-delimited documents (NDJSON / JSON
 
 By default (`acceleration: true`) the C extension is used when it is compiled and loadable (`SmarterJSON::HAS_ACCELERATION` is then `true`); otherwise the pure-Ruby parser runs and produces identical results. Pass `acceleration: false` to force the pure-Ruby path. See [Configuration Options](./options.md).
 
-## Seeing what was fixed: `warnings:`
+## Seeing what was fixed: `on_warning:`
 
-`process` and `process_file` are lenient — they salvage your data rather than reject a whole document over a stray comma. Pass `warnings: true` to also get back a record of what was adjusted, so the leniency is transparent instead of silent. The call then returns `[result, warnings]`:
+`process` and `process_file` are lenient — they salvage your data rather than reject a whole document over a stray comma. Pass an `on_warning:` callable to also get a record of what was adjusted, so the leniency is transparent instead of silent. It is invoked once per fix and never changes the return value:
 
 ```ruby
-result, warnings = SmarterJSON.process("[1,,2]", warnings: true)
-result               # => [1, 2]
-warnings.map(&:type) # => [:empty_slot]
-warnings.first.to_s  # => "extra comma, collapsed an empty slot at line 1, col 4"
+warns = []
+result = SmarterJSON.process("[1,,2]", on_warning: ->(w) { warns << w })
+result            # => [1, 2]
+warns.map(&:type) # => [:empty_slot]
+warns.first.to_s  # => "extra comma, collapsed an empty slot at line 1, col 4"
 ```
 
-Each warning is a `SmarterJSON::Warning` with `type`, `message`, `line`, and `col`. The types are `:empty_slot` (a collapsed empty comma slot), `:empty_value` (a key with no value, read as `null`), and `:duplicate_key` (a repeated key that was dropped). Clean input gives an empty `warnings` array. It works the same on the C and pure-Ruby paths. See [Configuration Options](./options.md).
+Each warning is a `SmarterJSON::Warning` with `type`, `message`, `line`, and `col`. The types are `:empty_slot` (a collapsed empty comma slot), `:empty_value` (a key with no value, read as `null`), and `:duplicate_key` (a repeated key that was dropped). Clean input never invokes the handler. It fires on every path — including the streaming block form — and works the same on the C and pure-Ruby paths. See [Configuration Options](./options.md).
 
 ---------------
 

data/docs/options.md

@@ -22,27 +22,28 @@ These options are passed to [`SmarterJSON.process`](./basic_read_api.md) and `Sm
 | `:bigdecimal_load`| `:auto`      | `:auto` keeps high-precision decimals as `BigDecimal` (matches Oj); `:float` forces every number to `Float`; `:bigdecimal` forces every decimal to `BigDecimal`. |
 | `:acceleration`   | `true`       | Use the C extension when it is compiled and loadable; `false` forces the pure-Ruby parser. Both produce identical results. |
 | `:encoding`       | `nil`        | Labels the input's encoding (e.g. `"UTF-8"`). It does **not** trigger a transcoding pass — see below.                  |
-| `:warnings`       | `false`      | When `true`, return `[result, warnings]` instead of just `result` — `warnings` lists the lenient fixes that were applied. See below. |
+| `:on_warning`     | `nil`        | A callable invoked once per lenient fix applied, passed a `SmarterJSON::Warning`. Never changes the return value. See below. |
 
 ```ruby
 SmarterJSON.process('{"a": 1}', symbolize_keys: true)               # => {:a=>1}
 SmarterJSON.process('{"a":1,"a":2}', duplicate_key: :raise)         # raises SmarterJSON::ParseError
 SmarterJSON.process(big_decimal_json, bigdecimal_load: :float)      # every number as Float (fastest)
-SmarterJSON.process("[1,,2]", warnings: true)                       # => [[1, 2], [#<SmarterJSON::Warning ...>]]
+SmarterJSON.process("[1,,2]", on_warning: ->(w) { puts w })         # => [1, 2], and prints the warning
 ```
 
-### A note on `:warnings`
+### A note on `:on_warning`
 
-`smarter_json` is lenient by design — it salvages your data instead of rejecting the whole document over a stray comma. `warnings: true` keeps that, but also hands back a record of what it had to fix, so leniency is transparent rather than silent. The call then returns a two-element `[result, warnings]`; `warnings` is an Array of `SmarterJSON::Warning`, each with `type` (a Symbol), `message`, `line`, and `col`:
+`smarter_json` is lenient by design — it salvages your data instead of rejecting the whole document over a stray comma. `on_warning:` keeps that, but also hands you a record of what it had to fix, so leniency is transparent rather than silent. It takes a callable that the parser invokes once per fix, passing a `SmarterJSON::Warning` (with `type` (a Symbol), `message`, `line`, and `col`). It never changes the return value — `process` still hands back the bare value — and it fires on every path, including the streaming block form. With no handler (the default), nothing is recorded and there is zero overhead.
 
 ```ruby
-result, warnings = SmarterJSON.process("[1,,2]", warnings: true)
+warns = []
+result = SmarterJSON.process("[1,,2]", on_warning: ->(w) { warns << w })
 result                         # => [1, 2]
-warnings.map(&:type)           # => [:empty_slot]
-warnings.first.to_s            # => "extra comma, collapsed an empty slot at line 1, col 4"
+warns.map(&:type)              # => [:empty_slot]
+warns.first.to_s               # => "extra comma, collapsed an empty slot at line 1, col 4"
 ```
 
-The warning types are `:empty_slot` (a collapsed empty comma slot, e.g. `[1,,2]`), `:empty_value` (a key with no value, read as `null`, e.g. `{a:}`), and `:duplicate_key` (a repeated key that was dropped). Clean input returns an empty `warnings` array. Warnings work on both the C and pure-Ruby paths, so `acceleration:` doesn't change them.
+The warning types are `:empty_slot` (a collapsed empty comma slot, e.g. `[1,,2]`), `:empty_value` (a key with no value, read as `null`, e.g. `{a:}`), and `:duplicate_key` (a repeated key that was dropped). Clean input never invokes the handler. Warnings work on both the C and pure-Ruby paths, so `acceleration:` doesn't change them.
 
 ### A note on `:encoding`
 

data/ext/smarter_json/smarter_json.c

@@ -34,6 +34,7 @@ static VALUE cParseError;
 static VALUE cEncodingError;
 static VALUE cWarning;
 static ID    fj_new_id;
+static ID    fj_call_id;    /* cached :call (invoking the on_warning handler) */
 static VALUE fj_sym_empty_slot;
 static VALUE fj_sym_empty_value;
 static VALUE fj_sym_duplicate_key;
@@ -60,8 +61,7 @@ typedef struct {
   int dup_raise;
   int bigdecimal_load;  /* 0 = float, 1 = auto, 2 = bigdecimal */
   fj_kc_slot *kcache;   /* per-parse key cache (NULL when interning unavailable) */
-  int collect_warnings; /* warnings: option — record non-fatal lenient fixes */
-  VALUE warnings;       /* rb_ary of SmarterJSON::Warning when collecting, else Qnil */
+  VALUE on_warning;     /* on_warning: callable invoked per non-fatal lenient fix, else Qnil */
 } fj_state;
 
 /* Line/column at the current byte position, computed lazily (only when raising
@@ -81,14 +81,16 @@ static void fj_line_col(fj_state *st, long *line, long *col) {
   *col = c;
 }
 
-/* Record a non-fatal lenient fix — only when the parse was given warnings: true. */
+/* Report a non-fatal lenient fix to the on_warning callable — a no-op (and builds no
+ * Warning) when no handler was given. The internal Qnil guard is the safety net; the
+ * call sites also guard so the line/col scan is skipped on the fast path. */
 static void fj_warn(fj_state *st, VALUE type_sym, const char *msg) {
   long line, col;
-  if (!st->collect_warnings) return;
+  if (st->on_warning == Qnil) return;
   fj_line_col(st, &line, &col);
-  rb_ary_push(st->warnings,
-              rb_funcall(cWarning, fj_new_id, 4, type_sym,
-                         rb_utf8_str_new_cstr(msg), LONG2NUM(line), LONG2NUM(col)));
+  rb_funcall(st->on_warning, fj_call_id, 1,
+             rb_funcall(cWarning, fj_new_id, 4, type_sym,
+                        rb_utf8_str_new_cstr(msg), LONG2NUM(line), LONG2NUM(col)));
 }
 
 /* 1-based column of the current byte position (bytes since the last line start).
@@ -1161,9 +1163,9 @@ static VALUE fj_build_object(fj_state *st, const VALUE *pairs, long count) {
   long  entries = count / 2, i;
   VALUE hash    = rb_hash_new_capa(entries);
 
-  /* Fast path: bulk insert. Skipped when collecting warnings, which needs the
-   * per-member loop below to report each dropped duplicate key. */
-  if (!st->symbolize_keys && !st->dup_first_wins && !st->collect_warnings) {
+  /* Fast path: bulk insert. Skipped when an on_warning handler is present, which needs
+   * the per-member loop below to report each dropped duplicate key. */
+  if (!st->symbolize_keys && !st->dup_first_wins && st->on_warning == Qnil) {
     rb_hash_bulk_insert(count, pairs, hash);
     if (st->dup_raise && fj_hash_len(hash) < entries) {
       VALUE seen = rb_hash_new_capa(entries);
@@ -1178,7 +1180,7 @@ static VALUE fj_build_object(fj_state *st, const VALUE *pairs, long count) {
 
   for (i = 0; i + 1 < count; i += 2) {
     VALUE k = st->symbolize_keys ? rb_funcall(pairs[i], fj_to_sym_id, 0) : pairs[i];
-    if (st->dup_first_wins || st->dup_raise || st->collect_warnings) {
+    if (st->dup_first_wins || st->dup_raise || st->on_warning != Qnil) {
       if (RTEST(rb_funcall(hash, fj_key_p_id, 1, k))) {
         if (st->dup_raise) fj_error(st, "duplicate key");
         fj_warn(st, fj_sym_duplicate_key, "duplicate key");
@@ -1271,7 +1273,7 @@ static VALUE fj_parse_iter(fj_state *st, int implicit_root) {
       fj_skip_ws_comments(st);
       b = fj_byte(st);
       if (b == ',') { /* collapsing separator: skip empty member */
-        if (st->collect_warnings && !vss) fj_warn(st, fj_sym_empty_slot, "extra comma, collapsed an empty slot");
+        if (st->on_warning != Qnil && !vss) fj_warn(st, fj_sym_empty_slot, "extra comma, collapsed an empty slot");
         vss = 0;
         fj_advance(st, 1);
         continue;
@@ -1323,7 +1325,7 @@ static VALUE fj_parse_iter(fj_state *st, int implicit_root) {
       fj_skip_ws_comments(st);
       b = fj_byte(st);
       if (b == ',') { /* collapsing separator: skip empty slot */
-        if (st->collect_warnings && !vss) fj_warn(st, fj_sym_empty_slot, "extra comma, collapsed an empty slot");
+        if (st->on_warning != Qnil && !vss) fj_warn(st, fj_sym_empty_slot, "extra comma, collapsed an empty slot");
         vss = 0;
         fj_advance(st, 1);
         continue;
@@ -1412,8 +1414,7 @@ static VALUE fj_parse_c(VALUE self, VALUE input, VALUE opts) {
     else st.bigdecimal_load = 1; /* :auto (default), including nil */
   }
 
-  st.collect_warnings = RTEST(rb_hash_aref(opts, ID2SYM(rb_intern("warnings"))));
-  st.warnings = st.collect_warnings ? rb_ary_new() : Qnil;
+  st.on_warning = rb_hash_aref(opts, ID2SYM(rb_intern("on_warning"))); /* Qnil when absent */
 
   if (st.len >= 3 && (unsigned char)st.buf[0] == 0xEF &&
       (unsigned char)st.buf[1] == 0xBB && (unsigned char)st.buf[2] == 0xBF) {
@@ -1439,10 +1440,10 @@ static VALUE fj_parse_c(VALUE self, VALUE input, VALUE opts) {
    * whitespace / newline / concatenation do), so a bracketless comma list still
    * raises in fj_parse_iter — the unsupported implicit-root array. */
   fj_skip_ws_comments(&st);
-  if (fj_eof(&st)) return st.collect_warnings ? rb_assoc_new(Qnil, st.warnings) : Qnil;
+  if (fj_eof(&st)) return Qnil;
   value = fj_parse_iter(&st, fj_implicit_root_ahead(&st));
   fj_skip_ws_comments(&st);
-  if (fj_eof(&st)) return st.collect_warnings ? rb_assoc_new(value, st.warnings) : value;
+  if (fj_eof(&st)) return value;
   {
     VALUE arr = rb_ary_new();
     rb_ary_push(arr, value);
@@ -1450,7 +1451,7 @@ static VALUE fj_parse_c(VALUE self, VALUE input, VALUE opts) {
       rb_ary_push(arr, fj_parse_iter(&st, fj_implicit_root_ahead(&st)));
       fj_skip_ws_comments(&st);
     } while (!fj_eof(&st));
-    return st.collect_warnings ? rb_assoc_new(arr, st.warnings) : arr;
+    return arr;
   }
 }
 
@@ -1463,6 +1464,7 @@ void Init_smarter_json(void) {
   fj_to_sym_id = rb_intern("to_sym");
   fj_key_p_id = rb_intern("key?");
   fj_new_id = rb_intern("new");
+  fj_call_id = rb_intern("call");
   fj_sym_empty_slot = ID2SYM(rb_intern("empty_slot"));
   fj_sym_empty_value = ID2SYM(rb_intern("empty_value"));
   fj_sym_duplicate_key = ID2SYM(rb_intern("duplicate_key"));

data/lib/smarter_json/parser.rb

@@ -57,10 +57,9 @@ module SmarterJSON
         Parser.new(input, options).each_value(&block)
       end
     elsif options.fetch(:acceleration, true) && HAS_ACCELERATION
-      parse_c(input, options) # returns [result, warnings] when options[:warnings]
+      parse_c(input, options)
     else
-      parser = Parser.new(input, options)
-      options.fetch(:warnings, false) ? [parser.parse, parser.warnings] : parser.parse
+      Parser.new(input, options).parse
     end
   end
 
@@ -143,14 +142,9 @@ module SmarterJSON
       symbolize_keys: false, # Symbol keys instead of String
       duplicate_key: :last_wins, # :last_wins | :first_wins | :raise
       bigdecimal_load: :auto, # :auto | :float | :bigdecimal (Oj-compatible)
-      warnings: false, # collect non-fatal lenient fixes; process returns [result, warnings]
+      on_warning: nil, # a callable invoked once per non-fatal lenient fix (a SmarterJSON::Warning)
     }.freeze
 
-    # Warnings collected during the parse (empty slots, empty values, dropped duplicate
-    # keys). Empty unless the parser was built with warnings: true. Public so the module
-    # functions can read it after parse / each_value.
-    attr_reader :warnings
-
     def initialize(input, options = {})
       raise ArgumentError, "input must be a String" unless input.is_a?(String)
 
@@ -158,8 +152,7 @@ module SmarterJSON
       @symbolize_keys  = opts[:symbolize_keys]
       @duplicate_key   = opts[:duplicate_key]
       @bigdecimal_load = opts[:bigdecimal_load]
-      @collect_warnings = opts[:warnings]
-      @warnings = []
+      @on_warning      = opts[:on_warning]
 
       encoding = opts[:encoding]
       @input = encoding ? input.dup.force_encoding(encoding) : input
@@ -263,7 +256,7 @@ module SmarterJSON
           # Commas are collapsing separators inside a container: an empty slot (leading,
           # interior, or trailing comma) adds nothing. Skip it; the next iteration reads
           # the following value/key or the closing bracket.
-          warn(:empty_slot, "extra comma — collapsed an empty slot") unless vss
+          warn(:empty_slot, "extra comma — collapsed an empty slot") if @on_warning && !vss
           vss = false
           advance(1)
         elsif cur_obj
@@ -300,7 +293,7 @@ module SmarterJSON
             elsif [RBRACE, COMMA].include?(b)
               # key with a colon but no value -> null (don't consume } or ,; the loop does)
               store_member(cur, key, nil)
-              warn(:empty_value, "key #{key.inspect} had no value — used null")
+              warn(:empty_value, "key #{key.inspect} had no value — used null") if @on_warning
               vss = true
             elsif b.nil?
               raise error("unexpected end of input")
@@ -573,7 +566,7 @@ module SmarterJSON
       if hash.key?(k)
         raise error("duplicate key #{k.inspect}") if @duplicate_key == :raise
 
-        warn(:duplicate_key, "duplicate key #{k.inspect} — #{@duplicate_key}")
+        warn(:duplicate_key, "duplicate key #{k.inspect} — #{@duplicate_key}") if @on_warning
         return if @duplicate_key == :first_wins
       end
       hash[k] = value
@@ -933,11 +926,14 @@ module SmarterJSON
       value
     end
 
-    # Record a non-fatal lenient fix (only when built with warnings: true).
+    # Report a non-fatal lenient fix to the on_warning callable. The call-site guards
+    # (`if @on_warning`) keep the message string from being built on the fast path; this
+    # internal guard is the safety net so a forgotten call-site guard can't crash a
+    # handler-less caller.
     def warn(type, message)
-      return unless @collect_warnings
+      return unless @on_warning
 
-      @warnings << Warning.new(type, message, @line, @col)
+      @on_warning.call(Warning.new(type, message, @line, @col))
     end
 
     def error(message)

data/lib/smarter_json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SmarterJSON
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/smarter_json/warning.rb

@@ -3,8 +3,8 @@
 module SmarterJSON
   # A non-fatal thing the parser worked around while staying lenient — e.g. an empty
   # comma slot it collapsed, a key with no value it read as null, or a duplicate key
-  # it dropped. Surfaced only when process / process_file is called with warnings: true
-  # (which then returns [result, warnings]); otherwise the parser stays silent.
+  # it dropped. Passed to the on_warning: callable (when process / process_file is given
+  # one) once per fix; otherwise the parser stays silent and builds no Warning at all.
   #
   #   type    — a Symbol you can branch on (:empty_slot, :empty_value, :duplicate_key)
   #   message — human-readable description

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: smarter_json
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Tilo Sloboda
 bindir: exe
 cert_chain: []
-date: 2026-06-02 00:00:00.000000000 Z
+date: 2026-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal