smarter_json 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca54f0d032730a5606b5a5d0fe4091c62c2d1ef70ebce6dd9283c91bb288a6b2
-  data.tar.gz: b4d859ef69ca0fa1935271ba99027f9d132ad8e558579da2b37d6bb542fc5076
+  metadata.gz: 480227c64ed99ba271fe95c6e7c79be6871f6bbf5c7f8f03d9bf118bb6bd7051
+  data.tar.gz: 966190c8f2e316e3664e381bf738831259b0e469a783f2fa3a25edf5f198d41b
 SHA512:
-  metadata.gz: c4c474e948779c8541fe7d6bc7a572cf1a131aea53dff2436ac0068228c777d020dd3c6e946b014e80bedbca03aec93fa35f8189294fb070935fb12db06fee24
-  data.tar.gz: 77082d230f4cccd2f913bb4a5508f8b15551230fde2c78b341ad71b08700b8a67bd1030a242ab3bd6f70252c66300d2fce7099964b5cf883229bbc73303305a7
+  metadata.gz: d53d1a84aa5ce83a2243a9adcdcddc284933dc8c357e08c8aaaec8e5e005164dfdec37d70c41bce0b2a3abf22dc7902e062adbbe3ffaa947b2232836bd01a86c
+  data.tar.gz: ae44f83437fe6c75227822a234658abb2157caf0378c8b998bab25aa40b4f1286da9a85a482be04b1be4ab17b142779140d0892ada81ae7d4342a0b7f706e9b7

data/CHANGELOG.md

@@ -3,8 +3,8 @@
 
 > ⚠️ SmarterJSON **always returns an `Array`** of documents.
 > 
-> `SmarterJSON.process` / `SmarterJSON.process_file` return:
->
+> `SmarterJSON.process` / `SmarterJSON.process_file`
+> both return:
 >   — `[]` for no doc
 >   - `[doc]` for one doc
 >   - `[d1, d2, …]` for several docs (NDJSON / JSONL / concatenated docs)
@@ -12,6 +12,12 @@
 > ⚠️ We discourage the use of `process(input).first` / `process(input)[0]` because it silently drops potential additional documents
 >    Please use `process_one` if you are expecting only one JSON doc, e.g. in API payloads.
 
+## 1.1.1 (2026-06-11)
+
+RSpec tests: 1,070 → 1,097
+
+- The C extension now emits the same `on_warning` warnings as the pure-Ruby parser. `empty_value` and `duplicate_key` warnings name the offending key (and `duplicate_key` names the resolution strategy), and the warning text, line, and column are now identical whether or not the C extension is loaded.
+
 ## 1.1.0 (2026-06-09)
 
 RSpec tests: 1,038 → 1,070

data/README.md

@@ -19,6 +19,8 @@ A lenient, fast JSON processor for Ruby. It extracts strict JSON, NDJSON, JSONL,
 
 ## Why SmarterJSON?
 
+> 📖 **The thinking behind it:** [*Strict by Accident: Your JSON parser isn't broken, it's answering the wrong question*](https://dev.to/tilo_sloboda/strict-by-accident-your-json-parser-isnt-broken-its-answering-the-wrong-question-54f0) — why a data pipeline wants a lenient, recovery-first parser rather than a spec-policing one.
+
 **Are you tired of seeing errors like these?**
 
 ```

data/ext/smarter_json/smarter_json.c

@@ -81,9 +81,9 @@ typedef struct {
  * an error) by scanning from the start of the buffer. CR, LF, and CRLF each
  * count as one newline; col is bytes since the last line start (1-based).
  * Keeping this off the hot path is the point — fj_advance never touches it. */
-static void fj_line_col(fj_state *st, long *line, long *col) {
+static void fj_line_col_to(fj_state *st, long stop, long *line, long *col) {
   long l = 1, c = 1, i;
-  long limit = (st->pos < st->len) ? st->pos : st->len;
+  long limit = (stop < st->len) ? stop : st->len;
   for (i = 0; i < limit; i++) {
     unsigned char b = (unsigned char)st->buf[i];
     if (b == 0x0A) { l++; c = 1; }
@@ -93,6 +93,9 @@ static void fj_line_col(fj_state *st, long *line, long *col) {
   *line = l;
   *col = c;
 }
+static void fj_line_col(fj_state *st, long *line, long *col) {
+  fj_line_col_to(st, st->pos, line, col);
+}
 
 /* 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
@@ -106,6 +109,25 @@ static void fj_warn(fj_state *st, VALUE type_sym, const char *msg) {
                         rb_utf8_str_new_cstr(msg), LONG2NUM(line), LONG2NUM(col)));
 }
 
+/* Like fj_warn but the message is a prebuilt Ruby String (rb_enc_sprintf, for messages
+ * that interpolate the offending key). Same Qnil guard and st->pos line/col. */
+static void fj_warn_str(fj_state *st, VALUE type_sym, VALUE msg) {
+  long line, col;
+  if (st->on_warning == Qnil) return;
+  fj_line_col(st, &line, &col);
+  rb_funcall(st->on_warning, fj_call_id, 1,
+             rb_funcall(cWarning, fj_new_id, 4, type_sym, msg, LONG2NUM(line), LONG2NUM(col)));
+}
+
+/* Like fj_warn_str but at an explicit (line,col) — for a warning detected away from the
+ * cursor. Duplicate keys are found while building the closed object, but attributed to
+ * the object's closing position so the column matches the pure-Ruby parser. */
+static void fj_warn_str_at(fj_state *st, VALUE type_sym, VALUE msg, long line, long col) {
+  if (st->on_warning == Qnil) return;
+  rb_funcall(st->on_warning, fj_call_id, 1,
+             rb_funcall(cWarning, fj_new_id, 4, type_sym, msg, LONG2NUM(line), LONG2NUM(col)));
+}
+
 /* 1-based column of the current byte position (bytes since the last line start).
  * Used for triple-quoted indentation stripping (smarter_json.md §2.3). */
 static long fj_column(fj_state *st) {
@@ -1290,7 +1312,7 @@ void rb_hash_bulk_insert(long, const VALUE *, VALUE);
 /* Build a Hash from `count` interleaved key,value slots. Fast path (String keys,
  * default :last_wins): pre-size + bulk insert. symbolize_keys / :first_wins use a
  * per-member loop into the same pre-sized hash. */
-static VALUE fj_build_object(fj_state *st, const VALUE *pairs, long count) {
+static VALUE fj_build_object(fj_state *st, const VALUE *pairs, const long *positions, long count) {
   long  entries = count / 2, i;
   VALUE hash    = rb_hash_new_capa(entries);
 
@@ -1305,7 +1327,16 @@ static VALUE fj_build_object(fj_state *st, const VALUE *pairs, long count) {
     VALUE k = st->symbolize_keys ? rb_funcall(pairs[i], fj_to_sym_id, 0) : pairs[i];
     if (st->dup_first_wins || st->on_warning != Qnil) {
       if (RTEST(rb_funcall(hash, fj_key_p_id, 1, k))) {
-        fj_warn(st, fj_sym_duplicate_key, "duplicate key");
+        if (st->on_warning != Qnil) {
+          long wl, wc;
+          fj_line_col_to(st, positions[i + 1], &wl, &wc); /* the duplicate member's value position — matches the Ruby parser */
+          fj_warn_str_at(st, fj_sym_duplicate_key,
+                         rb_enc_sprintf(rb_utf8_encoding(),
+                                        "duplicate key %"PRIsVALUE" \xe2\x80\x94 %s",
+                                        rb_inspect(k),
+                                        st->dup_first_wins ? "first_wins" : "last_wins"),
+                         wl, wc);
+        }
         if (st->dup_first_wins) continue;
       }
     }
@@ -1323,6 +1354,7 @@ typedef struct { long mark; int is_obj; } fj_frame;
 
 typedef struct {
   VALUE    *vptr;  long vhead;  long vcapa;  /* pending values (GC-marked) */
+  long     *pptr;                            /* byte offset just past each pushed value (mirrors vptr/vcapa); used only to attribute a duplicate-key warning to the duplicate member's position */
   fj_frame *fptr;  long fhead;  long fcapa;  /* open-container frames (no VALUEs) */
 } fj_pstack;
 
@@ -1334,12 +1366,15 @@ static void fj_pstack_mark(void *p) {
 static void fj_pstack_free(void *p) {
   fj_pstack *ps = (fj_pstack *)p;
   if (ps->vptr != NULL) xfree(ps->vptr);
+  if (ps->pptr != NULL) xfree(ps->pptr);
   if (ps->fptr != NULL) xfree(ps->fptr);
   xfree(ps);
 }
 static size_t fj_pstack_memsize(const void *p) {
   const fj_pstack *ps = (const fj_pstack *)p;
-  return sizeof(fj_pstack) + (size_t)ps->vcapa * sizeof(VALUE) + (size_t)ps->fcapa * sizeof(fj_frame);
+  return sizeof(fj_pstack) + (size_t)ps->vcapa * sizeof(VALUE)
+         + (ps->pptr ? (size_t)ps->vcapa * sizeof(long) : 0)
+         + (size_t)ps->fcapa * sizeof(fj_frame);
 }
 static const rb_data_type_t fj_pstack_type = {
   "smarter_json/pstack",
@@ -1347,8 +1382,15 @@ static const rb_data_type_t fj_pstack_type = {
   0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-static inline void fj_vpush(fj_pstack *ps, VALUE v) {
-  if (ps->vhead >= ps->vcapa) { ps->vcapa *= 2; REALLOC_N(ps->vptr, VALUE, ps->vcapa); }
+static inline void fj_vpush(fj_state *st, fj_pstack *ps, VALUE v) {
+  if (ps->vhead >= ps->vcapa) {
+    ps->vcapa *= 2;
+    REALLOC_N(ps->vptr, VALUE, ps->vcapa);
+    if (ps->pptr) REALLOC_N(ps->pptr, long, ps->vcapa);
+  }
+  /* pptr is allocated only when on_warning is set; the fast path (no handler) does no
+   * extra store. The offset is just past this value — the duplicate-key warning position. */
+  if (ps->pptr) ps->pptr[ps->vhead] = st->pos;
   ps->vptr[ps->vhead++] = v;
 }
 static inline void fj_fpush(fj_pstack *ps, long mark, int is_obj) {
@@ -1368,6 +1410,7 @@ static VALUE fj_parse_iter(fj_state *st, int implicit_root) {
   int        vss = 0; /* warnings: has a value landed in the current container since the last separator? */
 
   ps->vptr = ALLOC_N(VALUE, 64);    ps->vhead = 0; ps->vcapa = 64;
+  ps->pptr = (st->on_warning != Qnil) ? ALLOC_N(long, 64) : NULL; /* only the warning path needs per-value positions */
   ps->fptr = ALLOC_N(fj_frame, 16); ps->fhead = 0; ps->fcapa = 16;
 
   if (implicit_root) fj_fpush(ps, 0, 1);
@@ -1398,7 +1441,7 @@ static VALUE fj_parse_iter(fj_state *st, int implicit_root) {
       b = fj_byte(st);
       if (FJ_UNLIKELY(fj_needs_ws_skip(b))) { fj_skip_ws_comments(st); b = fj_byte(st); }
       if (b == ',') { /* collapsing separator: skip empty member */
-        if (st->on_warning != Qnil && !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 \xe2\x80\x94 collapsed an empty slot");
         vss = 0;
         fj_advance(st, 1);
         continue;
@@ -1406,17 +1449,17 @@ static VALUE fj_parse_iter(fj_state *st, int implicit_root) {
       if (b == '}') {
         VALUE hash;
         fj_advance(st, 1);
-        hash = fj_build_object(st, &ps->vptr[mark], ps->vhead - mark);
+        hash = fj_build_object(st, &ps->vptr[mark], ps->pptr ? &ps->pptr[mark] : NULL, ps->vhead - mark);
         ps->vhead = mark;
         ps->fhead--;
         if (ps->fhead == 0) { result = hash; break; }
-        fj_vpush(ps, hash);
+        fj_vpush(st, ps, hash);
         vss = 1;
         continue;
       }
       if (b == -1) {
         if (implicit_root && ps->fhead == 1) {
-          result = fj_build_object(st, &ps->vptr[mark], ps->vhead - mark);
+          result = fj_build_object(st, &ps->vptr[mark], ps->pptr ? &ps->pptr[mark] : NULL, ps->vhead - mark);
           break;
         }
         fj_error(st, "unterminated object");
@@ -1430,28 +1473,32 @@ static VALUE fj_parse_iter(fj_state *st, int implicit_root) {
       b = fj_byte(st);
       if (FJ_UNLIKELY(fj_needs_ws_skip(b))) { fj_skip_ws_comments(st); b = fj_byte(st); }
       if (b == '{' || b == '[') {
-        fj_vpush(ps, key);
+        fj_vpush(st, ps, key);
         fj_advance(st, 1);
         fj_fpush(ps, ps->vhead, (b == '{'));
         vss = 0;
         continue;
       }
       if (b == '}' || b == ',') { /* key with a colon but no value -> null */
-        fj_vpush(ps, key);
-        fj_vpush(ps, Qnil);
-        fj_warn(st, fj_sym_empty_value, "empty value, used null");
+        fj_vpush(st, ps, key);
+        fj_vpush(st, ps, Qnil);
+        if (st->on_warning != Qnil)
+          fj_warn_str(st, fj_sym_empty_value,
+                      rb_enc_sprintf(rb_utf8_encoding(),
+                                     "key %"PRIsVALUE" had no value \xe2\x80\x94 used null",
+                                     rb_inspect(key)));
         vss = 1;
         continue;
       }
       if (b == -1) fj_error(st, "unexpected end of input");
-      fj_vpush(ps, key);
-      fj_vpush(ps, fj_parse_member_value(st));
+      fj_vpush(st, ps, key);
+      fj_vpush(st, ps, fj_parse_member_value(st));
       vss = 1;
     } else { /* array */
       b = fj_byte(st);
       if (FJ_UNLIKELY(fj_needs_ws_skip(b))) { fj_skip_ws_comments(st); b = fj_byte(st); }
       if (b == ',') { /* collapsing separator: skip empty slot */
-        if (st->on_warning != Qnil && !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 \xe2\x80\x94 collapsed an empty slot");
         vss = 0;
         fj_advance(st, 1);
         continue;
@@ -1463,7 +1510,7 @@ static VALUE fj_parse_iter(fj_state *st, int implicit_root) {
         ps->vhead = mark;
         ps->fhead--;
         if (ps->fhead == 0) { result = ary; break; }
-        fj_vpush(ps, ary);
+        fj_vpush(st, ps, ary);
         vss = 1;
         continue;
       }
@@ -1481,10 +1528,10 @@ static VALUE fj_parse_iter(fj_state *st, int implicit_root) {
          smart-quote, literals) falls through to the full dispatch below. */
       if (b == '-' || b == '+' || b == '.' || (b >= '0' && b <= '9')) {
         VALUE num;
-        if (fj_try_member_number(st, &num)) { fj_vpush(ps, num); vss = 1; continue; }
+        if (fj_try_member_number(st, &num)) { fj_vpush(st, ps, num); vss = 1; continue; }
       }
-      if (b == '"') { fj_vpush(ps, fj_parse_string(st, '"')); vss = 1; continue; }
-      fj_vpush(ps, fj_parse_member_value(st));
+      if (b == '"') { fj_vpush(st, ps, fj_parse_string(st, '"')); vss = 1; continue; }
+      fj_vpush(st, ps, fj_parse_member_value(st));
       vss = 1;
     }
   }

data/lib/smarter_json/version.rb

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

metadata

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