json_scanner 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0af7c4c2fce9ca74ec96c00e8972088b34c99a005b8fc966d1a0e9ae7d75dcb
-  data.tar.gz: 70f2365add4838ef7409d3ff9568ab59d1a3771ac38d6168757bf8de1de71b1d
+  metadata.gz: f34237d4ceab009f685b82a4e480247f23c804db96bded6d1bacea5ddd4a0946
+  data.tar.gz: 87484e4cbab84666b41ddb67553b0c985ef6dc29d8f1154a458173deade08587
 SHA512:
-  metadata.gz: 96958c94108fafca33f68f091dcea150e549e1fa61c02aaf62790f0d2f77c8762abe7b702a4cf95b9d4e28929a3dd1ce77681bb7cc0f6e7e8fdd22d32f74f378
-  data.tar.gz: 3da8a8713b1f1994d50ee3032d450b5d34070c843e7c2625db1f2945c5a6c1cdc223d9b957c0386562ea1fdf68d2d03c6fc985ca2f0ddda8a7f3b83ff2c19b36
+  metadata.gz: 5f6ae7f8d7afc88fee60e88eb8efe776b7ae0dffe25ecffa5ffc61241629eb4c3ec86a9ab1b1e76d49b4bd12498ee15625677afbc997039f9295e65e510a32df
+  data.tar.gz: b5e95df2d53c0a224f6a089a55a6a0c502adb7e4dce276f2f85c48a063182f65f1425eff1f97cf409de46c815b45bbfa0626e54d76036a5c66c13eefa4146648

data/README.md

@@ -32,7 +32,12 @@ emoji_json = '{"grin": "😁", "heart": "😍", "rofl": "🤣"}'
 begin_pos, end_pos, = JsonScanner.scan(emoji_json, [["heart"]], false).first.first
 emoji_json.byteslice(begin_pos...end_pos)
 # => "\"😍\""
-emoji_json.force_encoding(Encoding::BINARY)[begin_pos...end_pos].force_encoding(Encoding::UTF_8)
+# Note: most likely don't need `quirks_mode` option, unless you are using some old ruby
+# with stdlib version of json gem or its old version. In new versions `quirks_mode` is default
+JSON.parse(emoji_json.byteslice(begin_pos...end_pos), quirks_mode: true)
+# => "😍"
+# You can also do this
+# emoji_json.force_encoding(Encoding::BINARY)[begin_pos...end_pos].force_encoding(Encoding::UTF_8)
 # => "\"😍\""
 ```
 

data/ext/json_scanner/json_scanner.c

@@ -1,8 +1,8 @@
 #include "json_scanner.h"
 
 VALUE rb_mJsonScanner;
-VALUE rb_mJsonScannerOptions;
 VALUE rb_eJsonScannerParseError;
+ID scan_kwargs_table[7];
 
 VALUE null_sym;
 VALUE boolean_sym;
@@ -16,9 +16,9 @@ enum matcher_type
   MATCHER_KEY,
   MATCHER_INDEX,
   // MATCHER_ANY_KEY,
-  // MATCHER_ANY_INDEX,
   MATCHER_INDEX_RANGE,
   // MATCHER_KEYS_LIST,
+  // MATCHER_KEY_REGEX,
 };
 
 enum path_type
@@ -84,18 +84,22 @@ typedef struct
 } scan_ctx;
 
 // FIXME: This will cause memory leak if ruby_xmalloc raises
-scan_ctx *scan_ctx_init(VALUE path_ary, VALUE with_path)
+scan_ctx *scan_ctx_init(VALUE path_ary, int with_path)
 {
+  int path_ary_len;
+  scan_ctx *ctx;
+  paths_t *paths;
   // TODO: Allow to_ary and sized enumerables
   rb_check_type(path_ary, T_ARRAY);
-  int path_ary_len = rb_long2int(rb_array_len(path_ary));
+  path_ary_len = rb_long2int(rb_array_len(path_ary));
   // Check types early before any allocations, so exception is ok
   // TODO: Fix this, just handle errors
   for (int i = 0; i < path_ary_len; i++)
   {
+    int path_len;
     VALUE path = rb_ary_entry(path_ary, i);
     rb_check_type(path, T_ARRAY);
-    int path_len = rb_long2int(rb_array_len(path));
+    path_len = rb_long2int(rb_array_len(path));
     for (int j = 0; j < path_len; j++)
     {
       VALUE entry = rb_ary_entry(path, j);
@@ -113,25 +117,32 @@ scan_ctx *scan_ctx_init(VALUE path_ary, VALUE with_path)
       else
       {
         VALUE range_beg, range_end;
+        long end_val;
         int open_ended;
         if (rb_range_values(entry, &range_beg, &range_end, &open_ended) != Qtrue)
           rb_raise(rb_eArgError, "path elements must be strings, integers, or ranges");
-        RB_NUM2LONG(range_beg);
-        RB_NUM2LONG(range_end);
+        if (RB_NUM2LONG(range_beg) < 0L)
+          rb_raise(rb_eArgError, "range start must be positive");
+        end_val = RB_NUM2LONG(range_end);
+        if (end_val < -1L)
+          rb_raise(rb_eArgError, "range end must be positive or -1");
+        if (end_val == -1L && open_ended)
+          rb_raise(rb_eArgError, "range with -1 end must be closed");
       }
     }
   }
 
-  scan_ctx *ctx = ruby_xmalloc(sizeof(scan_ctx));
+  ctx = ruby_xmalloc(sizeof(scan_ctx));
 
-  ctx->with_path = RB_TEST(with_path);
+  ctx->with_path = with_path;
   ctx->max_path_len = 0;
 
-  paths_t *paths = ruby_xmalloc(sizeof(paths_t) * path_ary_len);
+  paths = ruby_xmalloc(sizeof(paths_t) * path_ary_len);
   for (int i = 0; i < path_ary_len; i++)
   {
+    int path_len;
     VALUE path = rb_ary_entry(path_ary, i);
-    int path_len = rb_long2int(rb_array_len(path));
+    path_len = rb_long2int(rb_array_len(path));
     if (path_len > ctx->max_path_len)
       ctx->max_path_len = path_len;
     paths[i].elems = ruby_xmalloc2(sizeof(path_matcher_elem_t), path_len);
@@ -156,12 +167,16 @@ scan_ctx *scan_ctx_init(VALUE path_ary, VALUE with_path)
       }
       else
       {
-        paths[i].elems[j].type = MATCHER_INDEX_RANGE;
         VALUE range_beg, range_end;
         int open_ended;
+        paths[i].elems[j].type = MATCHER_INDEX_RANGE;
         rb_range_values(entry, &range_beg, &range_end, &open_ended);
         paths[i].elems[j].value.range.start = RB_NUM2LONG(range_beg);
         paths[i].elems[j].value.range.end = RB_NUM2LONG(range_end);
+        // (value..-1) works as expected, (value...-1) is forbidden above
+        if (paths[i].elems[j].value.range.end == -1L)
+          paths[i].elems[j].value.range.end = LONG_MAX;
+        // -1 here is fine, so, (0...0) works just as expected - doesn't match anything
         if (open_ended)
           paths[i].elems[j].value.range.end--;
       }
@@ -181,7 +196,7 @@ scan_ctx *scan_ctx_init(VALUE path_ary, VALUE with_path)
     rb_ary_push(ctx->points_list, rb_ary_new());
   }
 
-  ctx->starts = ruby_xmalloc2(sizeof(size_t), ctx->max_path_len);
+  ctx->starts = ruby_xmalloc2(sizeof(size_t), ctx->max_path_len + 1);
   // ctx->rb_err = Qnil;
   ctx->handle = NULL;
 
@@ -224,10 +239,10 @@ typedef enum
 } value_type;
 
 // noexcept
-void create_point(VALUE *point, scan_ctx *sctx, value_type type, size_t length, size_t curr_pos)
+VALUE create_point(scan_ctx *sctx, value_type type, size_t length, size_t curr_pos)
 {
-  *point = rb_ary_new_capa(3);
   VALUE values[3];
+  VALUE point = rb_ary_new_capa(3);
   // noexcept
   values[1] = RB_ULONG2NUM(curr_pos);
   switch (type)
@@ -259,7 +274,31 @@ void create_point(VALUE *point, scan_ctx *sctx, value_type type, size_t length,
     break;
   }
   // rb_ary_cat raise only in case of a frozen array or if len is too long
-  rb_ary_cat(*point, values, 3);
+  rb_ary_cat(point, values, 3);
+  return point;
+}
+
+// noexcept
+VALUE create_path(scan_ctx *sctx)
+{
+  VALUE path = rb_ary_new_capa(sctx->current_path_len);
+  for (int i = 0; i < sctx->current_path_len; i++)
+  {
+    VALUE entry;
+    switch (sctx->current_path[i].type)
+    {
+    case PATH_KEY:
+      entry = rb_str_new(sctx->current_path[i].value.key.val, sctx->current_path[i].value.key.len);
+      break;
+    case PATH_INDEX:
+      entry = RB_ULONG2NUM(sctx->current_path[i].value.index);
+      break;
+    default:
+      entry = Qnil;
+    }
+    rb_ary_push(path, entry);
+  }
+  return path;
 }
 
 // noexcept
@@ -267,13 +306,15 @@ void save_point(scan_ctx *sctx, value_type type, size_t length)
 {
   // TODO: Abort parsing if all paths are matched and no more mathces are possible: only trivial key/index matchers at the current level
   // TODO: Don't re-compare already matched prefixes; hard to invalidate, though
+  // TODO: Might fail in case of no memory
   VALUE point = Qundef;
+  int match;
   for (int i = 0; i < sctx->paths_len; i++)
   {
     if (sctx->paths[i].len != sctx->current_path_len)
       continue;
 
-    int match = true;
+    match = true;
     for (int j = 0; j < sctx->current_path_len; j++)
     {
       switch (sctx->paths[i].elems[j].type)
@@ -303,7 +344,11 @@ void save_point(scan_ctx *sctx, value_type type, size_t length)
     {
       if (point == Qundef)
       {
-        create_point(&point, sctx, type, length, yajl_get_bytes_consumed(sctx->handle));
+        point = create_point(sctx, type, length, yajl_get_bytes_consumed(sctx->handle));
+        if (sctx->with_path)
+        {
+          point = rb_ary_new_from_args(2, create_path(sctx), point);
+        }
       }
       // rb_ary_push raises only in case of a frozen array, which is not the case
       // rb_ary_entry is safe
@@ -366,11 +411,9 @@ int scan_on_start_object(void *ctx)
     return true;
   }
   increment_arr_index(sctx);
+  sctx->starts[sctx->current_path_len] = yajl_get_bytes_consumed(sctx->handle) - 1;
   if (sctx->current_path_len < sctx->max_path_len)
-  {
-    sctx->starts[sctx->current_path_len] = yajl_get_bytes_consumed(sctx->handle) - 1;
     sctx->current_path[sctx->current_path_len].type = PATH_KEY;
-  }
   sctx->current_path_len++;
   return true;
 }
@@ -383,7 +426,7 @@ int scan_on_key(void *ctx, const unsigned char *key, size_t len)
     return true;
   // Can't be called without scan_on_start_object being called before
   // So current_path_len at least 1 and key.type is set to PATH_KEY;
-  sctx->current_path[sctx->current_path_len - 1].value.key.val = (char *) key;
+  sctx->current_path[sctx->current_path_len - 1].value.key.val = (char *)key;
   sctx->current_path[sctx->current_path_len - 1].value.key.len = len;
   return true;
 }
@@ -393,9 +436,8 @@ int scan_on_end_object(void *ctx)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
   sctx->current_path_len--;
-  if (sctx->current_path_len >= sctx->max_path_len)
-    return true;
-  save_point(sctx, object_value, 0);
+  if (sctx->current_path_len <= sctx->max_path_len)
+    save_point(sctx, object_value, 0);
   return true;
 }
 
@@ -409,9 +451,9 @@ int scan_on_start_array(void *ctx)
     return true;
   }
   increment_arr_index(sctx);
+  sctx->starts[sctx->current_path_len] = yajl_get_bytes_consumed(sctx->handle) - 1;
   if (sctx->current_path_len < sctx->max_path_len)
   {
-    sctx->starts[sctx->current_path_len] = yajl_get_bytes_consumed(sctx->handle) - 1;
     sctx->current_path[sctx->current_path_len].type = PATH_INDEX;
     sctx->current_path[sctx->current_path_len].value.index = -1;
   }
@@ -424,9 +466,8 @@ int scan_on_end_array(void *ctx)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
   sctx->current_path_len--;
-  if (sctx->current_path_len >= sctx->max_path_len)
-    return true;
-  save_point(sctx, array_value, 0);
+  if (sctx->current_path_len <= sctx->max_path_len)
+    save_point(sctx, array_value, 0);
   return true;
 }
 
@@ -443,40 +484,73 @@ static yajl_callbacks scan_callbacks = {
     scan_on_start_array,
     scan_on_end_array};
 
-// TODO: make with_path optional kw: `with_path: false`
-VALUE scan(VALUE self, VALUE json_str, VALUE path_ary, VALUE with_path)
+// def scan(json_str, path_arr, opts)
+// opts
+// with_path: false, verbose_error: false,
+// the following opts converted to bool and passed to yajl_config if provided, ignored if not provided
+// allow_comments, dont_validate_strings, allow_trailing_garbage, allow_multiple_values, allow_partial_values
+VALUE scan(int argc, VALUE *argv, VALUE self)
 {
-  rb_check_type(json_str, T_STRING);
-  char *json_text = RSTRING_PTR(json_str);
-#if LONG_MAX > SIZE_MAX
-  size_t json_text_len = RSTRING_LENINT(json_str);
-#else
-  size_t json_text_len = RSTRING_LEN(json_str);
-#endif
+  VALUE json_str, path_ary, with_path_flag, kwargs;
+  VALUE kwargs_values[7];
+
+  int with_path = false, verbose_error = false;
+  char *json_text;
+  size_t json_text_len;
   yajl_handle handle;
-  // TODO
-  int opt_verbose_error = 0;
   yajl_status stat;
-  scan_ctx *ctx = scan_ctx_init(path_ary, with_path);
-  VALUE err = Qnil;
-  VALUE result;
+  scan_ctx *ctx;
+  VALUE err = Qnil, result;
   // Turned out callbacks can't raise exceptions
   // VALUE callback_err;
+#if RUBY_API_VERSION_MAJOR > 2 || (RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR >= 7)
+  rb_scan_args_kw(RB_SCAN_ARGS_LAST_HASH_KEYWORDS, argc, argv, "21:", &json_str, &path_ary, &with_path_flag, &kwargs);
+#else
+  rb_scan_args(argc, argv, "21:", &json_str, &path_ary, &with_path_flag, &kwargs);
+#endif
+  // rb_io_write(rb_stderr, rb_sprintf("with_path_flag: %" PRIsVALUE " \n", with_path_flag));
+  with_path = RTEST(with_path_flag);
+  if (kwargs != Qnil)
+  {
+    rb_get_kwargs(kwargs, scan_kwargs_table, 0, 7, kwargs_values);
+    if (kwargs_values[0] != Qundef)
+      with_path = RTEST(kwargs_values[0]);
+    if (kwargs_values[1] != Qundef)
+      verbose_error = RTEST(kwargs_values[1]);
+  }
+  rb_check_type(json_str, T_STRING);
+  json_text = RSTRING_PTR(json_str);
+#if LONG_MAX > SIZE_MAX
+  json_text_len = RSTRING_LENINT(json_str);
+#else
+  json_text_len = RSTRING_LEN(json_str);
+#endif
+  ctx = scan_ctx_init(path_ary, with_path);
 
   handle = yajl_alloc(&scan_callbacks, NULL, (void *)ctx);
+  if (kwargs != Qnil) // it's safe to read kwargs_values only if rb_get_kwargs was called
+  {
+    if (kwargs_values[2] != Qundef)
+      yajl_config(handle, yajl_allow_comments, RTEST(kwargs_values[2]));
+    if (kwargs_values[3] != Qundef)
+      yajl_config(handle, yajl_dont_validate_strings, RTEST(kwargs_values[3]));
+    if (kwargs_values[4] != Qundef)
+      yajl_config(handle, yajl_allow_trailing_garbage, RTEST(kwargs_values[4]));
+    if (kwargs_values[5] != Qundef)
+      yajl_config(handle, yajl_allow_multiple_values, RTEST(kwargs_values[5]));
+    if (kwargs_values[6] != Qundef)
+      yajl_config(handle, yajl_allow_partial_values, RTEST(kwargs_values[6]));
+  }
   ctx->handle = handle;
-  // TODO: make it configurable
-  // yajl_config(handle, yajl_allow_comments, true);
-  // yajl_config(handle, yajl_allow_trailing_garbage, true);
-  stat = yajl_parse(handle, (unsigned char *) json_text, json_text_len);
+  stat = yajl_parse(handle, (unsigned char *)json_text, json_text_len);
   if (stat == yajl_status_ok)
     stat = yajl_complete_parse(handle);
 
   if (stat != yajl_status_ok)
   {
-    char *str = (char *) yajl_get_error(handle, opt_verbose_error, (unsigned char *) json_text, json_text_len);
-    err = rb_str_new_cstr(str);
-    yajl_free_error(handle, (unsigned char *) str);
+    char *str = (char *)yajl_get_error(handle, verbose_error, (unsigned char *)json_text, json_text_len);
+    err = rb_utf8_str_new_cstr(str);
+    yajl_free_error(handle, (unsigned char *)str);
   }
   // callback_err = ctx->rb_err;
   result = ctx->points_list;
@@ -494,19 +568,20 @@ RUBY_FUNC_EXPORTED void
 Init_json_scanner(void)
 {
   rb_mJsonScanner = rb_define_module("JsonScanner");
-  rb_define_const(rb_mJsonScanner, "ALL", rb_range_new(INT2FIX(0), INT2FIX(-1), false));
-  rb_mJsonScannerOptions = rb_define_module_under(rb_mJsonScanner, "Options");
+  rb_define_const(rb_mJsonScanner, "ANY_INDEX", rb_range_new(INT2FIX(0), INT2FIX(-1), false));
   rb_eJsonScannerParseError = rb_define_class_under(rb_mJsonScanner, "ParseError", rb_eRuntimeError);
-  rb_define_const(rb_mJsonScannerOptions, "ALLOW_COMMENTS", INT2FIX(yajl_allow_comments));
-  rb_define_const(rb_mJsonScannerOptions, "DONT_VALIDATE_STRINGS", INT2FIX(yajl_dont_validate_strings));
-  rb_define_const(rb_mJsonScannerOptions, "ALLOW_TRAILING_GARBAGE", INT2FIX(yajl_allow_trailing_garbage));
-  rb_define_const(rb_mJsonScannerOptions, "ALLOW_MULTIPLE_VALUES", INT2FIX(yajl_allow_multiple_values));
-  rb_define_const(rb_mJsonScannerOptions, "ALLOW_PARTIAL_VALUES", INT2FIX(yajl_allow_partial_values));
-  rb_define_module_function(rb_mJsonScanner, "scan", scan, 3);
+  rb_define_module_function(rb_mJsonScanner, "scan", scan, -1);
   null_sym = rb_id2sym(rb_intern("null"));
   boolean_sym = rb_id2sym(rb_intern("boolean"));
   number_sym = rb_id2sym(rb_intern("number"));
   string_sym = rb_id2sym(rb_intern("string"));
   object_sym = rb_id2sym(rb_intern("object"));
   array_sym = rb_id2sym(rb_intern("array"));
+  scan_kwargs_table[0] = rb_intern("with_path");
+  scan_kwargs_table[1] = rb_intern("verbose_error");
+  scan_kwargs_table[2] = rb_intern("allow_comments");
+  scan_kwargs_table[3] = rb_intern("dont_validate_strings");
+  scan_kwargs_table[4] = rb_intern("allow_trailing_garbage");
+  scan_kwargs_table[5] = rb_intern("allow_multiple_values");
+  scan_kwargs_table[6] = rb_intern("allow_partial_values");
 }

data/ext/json_scanner/json_scanner.h

@@ -3,6 +3,7 @@
 
 #include "ruby.h"
 #include "ruby/intern.h"
+#include "ruby/version.h"
 #include <yajl/yajl_parse.h>
 #include <yajl/yajl_gen.h>
 

data/lib/json_scanner/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JsonScanner
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/json_scanner_spec.rb

@@ -1,37 +1,193 @@
 # frozen_string_literal: true
 
 require_relative "spec_helper"
+require "json"
 
 RSpec.describe JsonScanner do
   it "has a version number" do
-    expect(described_class::VERSION).not_to be nil
+    expect(described_class::VERSION).not_to be_nil
   end
 
   it "scans json" do
-    result = described_class.scan('["1", {"a": 2}]', [[0], [1, "a"], []], false)
+    result = described_class.scan('["1", {"a": 2}]', [[0], [1, "a"], []])
     expect(result).to eq([[[1, 4, :string]], [[12, 13, :number]], [[0, 15, :array]]])
-    expect(described_class.scan('"2"', [[]], false)).to eq([[[0, 3, :string]]])
+    expect(described_class.scan('"2"', [[]])).to eq([[[0, 3, :string]]])
     expect(
-      described_class.scan("[0,1,2,3,4,5,6,7]", [[(0..2)], [(4...6)]], false)
+      described_class.scan("[0,1,2,3,4,5,6,7]", [[(0..2)], [(4...6)]]),
     ).to eq(
-      [[[1, 2, :number], [3, 4, :number], [5, 6, :number]], [[9, 10, :number], [11, 12, :number]]]
+      [[[1, 2, :number], [3, 4, :number], [5, 6, :number]], [[9, 10, :number], [11, 12, :number]]],
     )
-    expect(described_class.scan('{"a": 1}', [["a"], []], false)).to eq(
-      [[[6, 7, :number]], [[0, 8, :object]]]
+    expect(described_class.scan('{"a": 1}', [["a"], []])).to eq(
+      [[[6, 7, :number]], [[0, 8, :object]]],
     )
+  end
+
+  it "works with max path len correctly" do
+    expect(
+      described_class.scan('{"a": [1]}', [[], ["a"]]),
+    ).to eq(
+      [[[0, 10, :object]], [[6, 9, :array]]],
+    )
+    expect(
+      described_class.scan('{"a": {"b": 1}}', [[], ["a"]]),
+    ).to eq(
+      [[[0, 15, :object]], [[6, 14, :object]]],
+    )
+    expect(described_class.scan('{"a": 1}', [[]])).to eq([[[0, 8, :object]]])
+    expect(described_class.scan("[[1]]", [[]])).to eq([[[0, 5, :array]]])
+    expect(described_class.scan("[[1]]", [[0]])).to eq([[[1, 4, :array]]])
+  end
+
+  it "raises on invalid json" do
     expect do
       begin
         GC.stress = true
         # TODO: investigate
         # got "munmap_chunk(): invalid pointer" in in console once after
         # JsonScanner.scan '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]', [[0,0,0,0,0,0,0]], true + Ctrl+D
-        # (last arg wasn't handled at the time)
-        # but I don't think it's a problem of tht extension or libyajl, it happened at exit and I free everything before
+        # (last arg wasn't handled at the time and was intended for with_path kwarg)
+        # but I don't think it's a problem of the extension or libyajl, it happened at exit and I free everything before
         # `JsonScanner.scan` returns
-        described_class.scan "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]", [[0, 0, 0, 0, 0, 0, 0]], false
+        described_class.scan "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]", [[0, 0, 0, 0, 0, 0, 0]]
       ensure
         GC.stress = false
       end
     end.to raise_error described_class::ParseError
   end
+
+  it "allows to select ranges" do
+    expect(
+      described_class.scan("[[1,2],[3,4]]", [[described_class::ANY_INDEX, described_class::ANY_INDEX]]),
+    ).to eq(
+      [[[2, 3, :number], [4, 5, :number], [8, 9, :number], [10, 11, :number]]],
+    )
+    expect(
+      described_class.scan("[[1,2],[3,4]]", [[described_class::ANY_INDEX, (0...1)]]),
+    ).to eq(
+      [[[2, 3, :number], [8, 9, :number]]],
+    )
+  end
+
+  it "allows only positive or -1 values" do
+    expect do
+      described_class.scan("[[1,2],[3,4]]", [[(0...-1)]])
+    end.to raise_error ArgumentError
+    expect do
+      described_class.scan("[[1,2],[3,4]]", [[(0..-2)]])
+    end.to raise_error ArgumentError
+    expect do
+      described_class.scan("[[1,2],[3,4]]", [[(-42..1)]])
+    end.to raise_error ArgumentError
+  end
+
+  it "allows to configure error messages" do
+    expect do
+      described_class.scan "{1}", []
+    end.to raise_error described_class::ParseError, /invalid object key(?!.*\(right here\))/m
+    expect do
+      described_class.scan "{1}", [], verbose_error: false
+    end.to raise_error described_class::ParseError, /invalid object key(?!.*\(right here\))/m
+    expect do
+      described_class.scan "{1}", [], verbose_error: true
+    end.to raise_error described_class::ParseError, /invalid object key(?=.*\(right here\))/m
+  end
+
+  it "allows to return an actual path to the element" do
+    with_path_expected_res = [
+      # result for first mathcer, each element array of two items:
+      # array of path elements and 3-element array start,end,type
+      [[[0], [1, 6, :array]], [[1], [7, 12, :array]]],
+      [
+        [[0, 0], [2, 3, :number]], [[0, 1], [4, 5, :number]],
+        [[1, 0], [8, 9, :number]], [[1, 1], [10, 11, :number]],
+      ],
+    ]
+    params = [
+      "[[1,2],[3,4]]",
+      [
+        [described_class::ANY_INDEX],
+        [described_class::ANY_INDEX, described_class::ANY_INDEX],
+      ],
+    ]
+    expect(described_class.scan(*params, with_path: true)).to eq(with_path_expected_res)
+    expect(described_class.scan(*params, true)).to eq(with_path_expected_res)
+    expect(
+      described_class.scan(*params, false, with_path: true),
+    ).to eq(with_path_expected_res)
+  end
+
+  it "ignores reqular flag if kwarg is given" do
+    expect(
+      described_class.scan(
+        "[[1,2],[3,4]]",
+        [
+          [described_class::ANY_INDEX],
+          [described_class::ANY_INDEX, described_class::ANY_INDEX],
+        ],
+        true, with_path: false,
+      ),
+    ).to eq(
+      [
+        # result for first mathcer, each element 3-element array start,end,type
+        [[1, 6, :array], [7, 12, :array]],
+        [
+          [2, 3, :number], [4, 5, :number],
+          [8, 9, :number], [10, 11, :number],
+        ],
+      ],
+    )
+  end
+
+  it "allows to pass config as a hash" do
+    expect(
+      described_class.scan("[1]", [[0]], { with_path: true }),
+    ).to eq(
+      [
+        [[[0], [1, 2, :number]]],
+      ],
+    )
+  end
+
+  it "allows to configure yajl" do
+    expect(
+      described_class.scan("[1]____________", [[0]], { allow_trailing_garbage: true }),
+    ).to eq([[[1, 2, :number]]])
+    expect(
+      described_class.scan(
+        '["1", {"a": /* comment */ 2}]____________', [[1, "a"]],
+        { allow_trailing_garbage: true, allow_comments: true },
+      ),
+    ).to eq([[[26, 27, :number]]])
+    expect(
+      described_class.scan(
+        '[{"a": /* comment */ 1}]_________', [[]],
+        { allow_comments: true, allow_trailing_garbage: true },
+      ),
+    ).to eq([[[0, 24, :array]]])
+  end
+
+  it "works with utf-8" do
+    json = '{"ルビー": ["Руби"]}'.encode(Encoding::UTF_8)
+    expect(described_class.scan(json, [[]])).to eq([[[0, json.bytesize, :object]]])
+    res = described_class.scan(json, [["ルビー", 0]])
+    expect(res).to eq([[[15, 25, :string]]])
+    elem = res.first.first
+    expect(JSON.parse(json.byteslice(elem[0]...elem[1]), quirks_mode: true)).to eq("Руби")
+  end
+
+  it "raises exceptions in utf-8" do
+    bad_json = '{"ルビー": ["Руби" 1]}'.encode(Encoding::UTF_8)
+    expect do
+      described_class.scan(bad_json, [[]], verbose_error: true)
+      # Checks encoding
+    end.to raise_error(described_class::ParseError, Regexp.new(Regexp.escape(bad_json)))
+  end
+
+  it "works with different encodings" do
+    # TODO: encoding validation
+    json = '{"a": 1}'.encode(Encoding::UTF_32LE)
+    expect do
+      described_class.scan(json, [[]])
+    end.to raise_error(described_class::ParseError)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_scanner
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - uvlad7
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-15 00:00:00.000000000 Z
+date: 2024-12-27 00:00:00.000000000 Z
 dependencies: []
 description: This gem uses yajl lib to scan a json string and allows you to parse
   pieces of it
@@ -53,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - libyajl2, v2.1
 - libyajl-dev, v2.1
-rubygems_version: 3.5.7
+rubygems_version: 3.4.20
 signing_key: 
 specification_version: 4
 summary: Extract values from JSON without full parsing