json_scanner 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0af7c4c2fce9ca74ec96c00e8972088b34c99a005b8fc966d1a0e9ae7d75dcb
-  data.tar.gz: 70f2365add4838ef7409d3ff9568ab59d1a3771ac38d6168757bf8de1de71b1d
+  metadata.gz: 1ffddd81459c088040c2ddee0006b1c9172e8a15aa8bab987dc59743e697f49f
+  data.tar.gz: 73b69bbcddaaf6711b2563787c4cbde1d258bf1d28b1e694714fd782c42d4c2c
 SHA512:
-  metadata.gz: 96958c94108fafca33f68f091dcea150e549e1fa61c02aaf62790f0d2f77c8762abe7b702a4cf95b9d4e28929a3dd1ce77681bb7cc0f6e7e8fdd22d32f74f378
-  data.tar.gz: 3da8a8713b1f1994d50ee3032d450b5d34070c843e7c2625db1f2945c5a6c1cdc223d9b957c0386562ea1fdf68d2d03c6fc985ca2f0ddda8a7f3b83ff2c19b36
+  metadata.gz: 44a153e578da606f67399a09387cf26d63b1528ad9e6bb258083435202f094ebc95e3a2c895a83334eb2aeef4ea9bfbe0f0c38374ac76f5772beea6bc3910a0f
+  data.tar.gz: ff9bcbc934fafc4857faf926bca5f5c6c82ec357107b8d6e5f2c0a7e9e622afe3a19d4b0a3f4a987d2e965432c73615203afd1c3e1ac6a52965555b20ef2f377

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

@@ -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
@@ -86,16 +86,20 @@ typedef struct
 // FIXME: This will cause memory leak if ruby_xmalloc raises
 scan_ctx *scan_ctx_init(VALUE path_ary, VALUE 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 = RTEST(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--;
       }
@@ -226,8 +241,8 @@ typedef enum
 // noexcept
 void create_point(VALUE *point, scan_ctx *sctx, value_type type, size_t length, size_t curr_pos)
 {
-  *point = rb_ary_new_capa(3);
   VALUE values[3];
+  *point = rb_ary_new_capa(3);
   // noexcept
   values[1] = RB_ULONG2NUM(curr_pos);
   switch (type)
@@ -268,12 +283,13 @@ 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
   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)
@@ -383,7 +399,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;
 }
@@ -446,37 +462,39 @@ static yajl_callbacks scan_callbacks = {
 // TODO: make with_path optional kw: `with_path: false`
 VALUE scan(VALUE self, VALUE json_str, VALUE path_ary, VALUE with_path)
 {
-  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
+  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;
+  // TODO
+  int opt_verbose_error = 0;
+  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);
   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);
+    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);
+    yajl_free_error(handle, (unsigned char *)str);
   }
   // callback_err = ctx->rb_err;
   result = ctx->points_list;
@@ -494,7 +512,7 @@ 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_define_const(rb_mJsonScanner, "ANY_INDEX", rb_range_new(INT2FIX(0), INT2FIX(-1), false));
   rb_mJsonScannerOptions = rb_define_module_under(rb_mJsonScanner, "Options");
   rb_eJsonScannerParseError = rb_define_class_under(rb_mJsonScanner, "ParseError", rb_eRuntimeError);
   rb_define_const(rb_mJsonScannerOptions, "ALLOW_COMMENTS", INT2FIX(yajl_allow_comments));

data/lib/json_scanner/version.rb

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

data/spec/json_scanner_spec.rb

@@ -4,7 +4,7 @@ require_relative "spec_helper"
 
 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
@@ -19,6 +19,9 @@ RSpec.describe JsonScanner do
     expect(described_class.scan('{"a": 1}', [["a"], []], false)).to eq(
       [[[6, 7, :number]], [[0, 8, :object]]]
     )
+  end
+
+  it "raises on invalid json" do
     expect do
       begin
         GC.stress = true
@@ -34,4 +37,29 @@ RSpec.describe JsonScanner do
       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]], false)
+    ).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)]], false)
+    ).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)]], false)
+    end.to raise_error ArgumentError
+    expect do
+      described_class.scan("[[1,2],[3,4]]", [[(0..-2)]], false)
+    end.to raise_error ArgumentError
+    expect do
+      described_class.scan("[[1,2],[3,4]]", [[(-42..1)]], false)
+    end.to raise_error ArgumentError
+  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.1.1
 platform: ruby
 authors:
 - uvlad7
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-15 00:00:00.000000000 Z
+date: 2024-12-16 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