json_scanner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d0af7c4c2fce9ca74ec96c00e8972088b34c99a005b8fc966d1a0e9ae7d75dcb
+  data.tar.gz: 70f2365add4838ef7409d3ff9568ab59d1a3771ac38d6168757bf8de1de71b1d
+SHA512:
+  metadata.gz: 96958c94108fafca33f68f091dcea150e549e1fa61c02aaf62790f0d2f77c8762abe7b702a4cf95b9d4e28929a3dd1ce77681bb7cc0f6e7e8fdd22d32f74f378
+  data.tar.gz: 3da8a8713b1f1994d50ee3032d450b5d34070c843e7c2625db1f2945c5a6c1cdc223d9b957c0386562ea1fdf68d2d03c6fc985ca2f0ddda8a7f3b83ff2c19b36

data/README.md

@@ -0,0 +1,51 @@
+[![Tests](https://github.com/uvlad7/json_scanner/actions/workflows/main.yml/badge.svg)](https://github.com/uvlad7/json_scanner/actions/workflows/main.yml)
+
+# JsonScanner
+
+Extract values from JSON without full parsing. This gem uses yajl lib to scan a json string and allows you to parse pieces of it.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add json_scanner
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install json_scanner
+
+## Usage
+
+```ruby
+require "json"
+require "json_scanner"
+
+large_json = "[#{"4," * 100_000}42#{",2" * 100_000}]"
+where_is_42 = JsonScanner.scan(large_json, [[100_000]], false).first
+# => [[200001, 200003, :number]]
+where_is_42.map do |begin_pos, end_pos, _type|
+  JSON.parse(large_json.byteslice(begin_pos...end_pos), quirks_mode: true)
+end
+# => [42]
+
+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)
+# => "\"😍\""
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [github](https://github.com/uvlad7/json_scanner).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/ext/json_scanner/extconf.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+# Makes all symbols private by default to avoid unintended conflict
+# with other gems. To explicitly export symbols you can use RUBY_FUNC_EXPORTED
+# selectively, or entirely remove this flag.
+append_cflags("-fvisibility=hidden")
+
+dir_config("yajl", "", "")
+
+unless have_library("yajl") && have_header("yajl/yajl_parse.h") && have_header("yajl/yajl_gen.h")
+  abort "yajl library not found"
+end
+
+create_makefile("json_scanner/json_scanner")

data/ext/json_scanner/json_scanner.c

@@ -0,0 +1,512 @@
+#include "json_scanner.h"
+
+VALUE rb_mJsonScanner;
+VALUE rb_mJsonScannerOptions;
+VALUE rb_eJsonScannerParseError;
+
+VALUE null_sym;
+VALUE boolean_sym;
+VALUE number_sym;
+VALUE string_sym;
+VALUE object_sym;
+VALUE array_sym;
+
+enum matcher_type
+{
+  MATCHER_KEY,
+  MATCHER_INDEX,
+  // MATCHER_ANY_KEY,
+  // MATCHER_ANY_INDEX,
+  MATCHER_INDEX_RANGE,
+  // MATCHER_KEYS_LIST,
+};
+
+enum path_type
+{
+  PATH_KEY,
+  PATH_INDEX,
+};
+
+typedef struct
+{
+  const char *val;
+  size_t len;
+} hashkey_t;
+
+typedef struct
+{
+  long start;
+  long end;
+} range_t;
+
+typedef struct
+{
+  enum matcher_type type;
+  union
+  {
+    hashkey_t key;
+    long index;
+    range_t range;
+  } value;
+} path_matcher_elem_t;
+
+typedef struct
+{
+  enum path_type type;
+  union
+  {
+    hashkey_t key;
+    long index;
+  } value;
+} path_elem_t;
+
+typedef struct
+{
+  path_matcher_elem_t *elems;
+  int len;
+  int matched_depth;
+} paths_t;
+
+typedef struct
+{
+  int with_path;
+  paths_t *paths;
+  int paths_len;
+  path_elem_t *current_path;
+  int current_path_len;
+  int max_path_len;
+  // Easier to use a Ruby array for result than convert later
+  VALUE points_list;
+  // by depth
+  size_t *starts;
+  // VALUE rb_err;
+  yajl_handle handle;
+} scan_ctx;
+
+// FIXME: This will cause memory leak if ruby_xmalloc raises
+scan_ctx *scan_ctx_init(VALUE path_ary, VALUE with_path)
+{
+  // 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));
+  // 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++)
+  {
+    VALUE path = rb_ary_entry(path_ary, i);
+    rb_check_type(path, T_ARRAY);
+    int path_len = rb_long2int(rb_array_len(path));
+    for (int j = 0; j < path_len; j++)
+    {
+      VALUE entry = rb_ary_entry(path, j);
+      int type = TYPE(entry);
+      if (type == T_STRING)
+      {
+#if LONG_MAX > SIZE_MAX
+        RSTRING_LENINT(entry);
+#endif
+      }
+      else if (type == T_FIXNUM || type == T_BIGNUM)
+      {
+        RB_NUM2LONG(entry);
+      }
+      else
+      {
+        VALUE range_beg, range_end;
+        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);
+      }
+    }
+  }
+
+  scan_ctx *ctx = ruby_xmalloc(sizeof(scan_ctx));
+
+  ctx->with_path = RB_TEST(with_path);
+  ctx->max_path_len = 0;
+
+  paths_t *paths = ruby_xmalloc(sizeof(paths_t) * path_ary_len);
+  for (int i = 0; i < path_ary_len; i++)
+  {
+    VALUE path = rb_ary_entry(path_ary, i);
+    int 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);
+    for (int j = 0; j < path_len; j++)
+    {
+      VALUE entry = rb_ary_entry(path, j);
+      int type = TYPE(entry);
+      if (type == T_STRING)
+      {
+        paths[i].elems[j].type = MATCHER_KEY;
+        paths[i].elems[j].value.key.val = RSTRING_PTR(entry);
+#if LONG_MAX > SIZE_MAX
+        paths[i].elems[j].value.key.len = RSTRING_LENINT(entry);
+#else
+        paths[i].elems[j].value.key.len = RSTRING_LEN(entry);
+#endif
+      }
+      else if (type == T_FIXNUM || type == T_BIGNUM)
+      {
+        paths[i].elems[j].type = MATCHER_INDEX;
+        paths[i].elems[j].value.index = FIX2LONG(entry);
+      }
+      else
+      {
+        paths[i].elems[j].type = MATCHER_INDEX_RANGE;
+        VALUE range_beg, range_end;
+        int open_ended;
+        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);
+        if (open_ended)
+          paths[i].elems[j].value.range.end--;
+      }
+    }
+    paths[i].len = path_len;
+    paths[i].matched_depth = 0;
+  }
+
+  ctx->paths = paths;
+  ctx->paths_len = path_ary_len;
+  ctx->current_path = ruby_xmalloc2(sizeof(path_elem_t), ctx->max_path_len);
+
+  ctx->current_path_len = 0;
+  ctx->points_list = rb_ary_new_capa(path_ary_len);
+  for (int i = 0; i < path_ary_len; i++)
+  {
+    rb_ary_push(ctx->points_list, rb_ary_new());
+  }
+
+  ctx->starts = ruby_xmalloc2(sizeof(size_t), ctx->max_path_len);
+  // ctx->rb_err = Qnil;
+  ctx->handle = NULL;
+
+  return ctx;
+}
+
+void scan_ctx_free(scan_ctx *ctx)
+{
+  if (!ctx)
+    return;
+  ruby_xfree(ctx->starts);
+  ruby_xfree(ctx->current_path);
+  for (int i = 0; i < ctx->paths_len; i++)
+  {
+    ruby_xfree(ctx->paths[i].elems);
+  }
+  ruby_xfree(ctx->paths);
+  ruby_xfree(ctx);
+}
+
+// noexcept
+inline void increment_arr_index(scan_ctx *sctx)
+{
+  // remember - any value can be root
+  // TODO: Maybe make current_path_len 1 shorter and get rid of -1; need to change all compares
+  if (sctx->current_path_len && sctx->current_path[sctx->current_path_len - 1].type == PATH_INDEX)
+  {
+    sctx->current_path[sctx->current_path_len - 1].value.index++;
+  }
+}
+
+typedef enum
+{
+  null_value,
+  boolean_value,
+  number_value,
+  string_value,
+  object_value,
+  array_value,
+} value_type;
+
+// 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];
+  // noexcept
+  values[1] = RB_ULONG2NUM(curr_pos);
+  switch (type)
+  {
+    // FIXME: size_t can be longer than ulong
+  case null_value:
+    values[0] = RB_ULONG2NUM(curr_pos - length);
+    values[2] = null_sym;
+    break;
+  case boolean_value:
+    values[0] = RB_ULONG2NUM(curr_pos - length);
+    values[2] = boolean_sym;
+    break;
+  case number_value:
+    values[0] = RB_ULONG2NUM(curr_pos - length);
+    values[2] = number_sym;
+    break;
+  case string_value:
+    values[0] = RB_ULONG2NUM(curr_pos - length);
+    values[2] = string_sym;
+    break;
+  case object_value:
+    values[0] = RB_ULONG2NUM(sctx->starts[sctx->current_path_len]);
+    values[2] = object_sym;
+    break;
+  case array_value:
+    values[0] = RB_ULONG2NUM(sctx->starts[sctx->current_path_len]);
+    values[2] = array_sym;
+    break;
+  }
+  // rb_ary_cat raise only in case of a frozen array or if len is too long
+  rb_ary_cat(*point, values, 3);
+}
+
+// noexcept
+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;
+  for (int i = 0; i < sctx->paths_len; i++)
+  {
+    if (sctx->paths[i].len != sctx->current_path_len)
+      continue;
+
+    int match = true;
+    for (int j = 0; j < sctx->current_path_len; j++)
+    {
+      switch (sctx->paths[i].elems[j].type)
+      {
+      case MATCHER_KEY:
+        if (sctx->current_path[j].type != PATH_KEY ||
+            sctx->current_path[j].value.key.len != sctx->paths[i].elems[j].value.key.len ||
+            strncmp(sctx->current_path[j].value.key.val, sctx->paths[i].elems[j].value.key.val, sctx->current_path[j].value.key.len))
+          match = false;
+        break;
+      case MATCHER_INDEX:
+        if (sctx->current_path[j].type != PATH_INDEX ||
+            sctx->current_path[j].value.index != sctx->paths[i].elems[j].value.index)
+          match = false;
+        break;
+      case MATCHER_INDEX_RANGE:
+        if (sctx->current_path[j].type != PATH_INDEX ||
+            sctx->current_path[j].value.index < sctx->paths[i].elems[j].value.range.start ||
+            sctx->current_path[j].value.index > sctx->paths[i].elems[j].value.range.end)
+          match = false;
+        break;
+      }
+      if (!match)
+        break;
+    }
+    if (match)
+    {
+      if (point == Qundef)
+      {
+        create_point(&point, sctx, type, length, yajl_get_bytes_consumed(sctx->handle));
+      }
+      // rb_ary_push raises only in case of a frozen array, which is not the case
+      // rb_ary_entry is safe
+      rb_ary_push(rb_ary_entry(sctx->points_list, i), point);
+    }
+  }
+}
+
+// noexcept
+int scan_on_null(void *ctx)
+{
+  scan_ctx *sctx = (scan_ctx *)ctx;
+  if (sctx->current_path_len > sctx->max_path_len)
+    return true;
+  increment_arr_index(sctx);
+  save_point(sctx, null_value, 4);
+  return true;
+}
+
+// noexcept
+int scan_on_boolean(void *ctx, int bool_val)
+{
+  scan_ctx *sctx = (scan_ctx *)ctx;
+  if (sctx->current_path_len > sctx->max_path_len)
+    return true;
+  increment_arr_index(sctx);
+  save_point(sctx, boolean_value, bool_val ? 4 : 5);
+  return true;
+}
+
+// noexcept
+int scan_on_number(void *ctx, const char *val, size_t len)
+{
+  scan_ctx *sctx = (scan_ctx *)ctx;
+  if (sctx->current_path_len > sctx->max_path_len)
+    return true;
+  increment_arr_index(sctx);
+  save_point(sctx, number_value, len);
+  return true;
+}
+
+// noexcept
+int scan_on_string(void *ctx, const unsigned char *val, size_t len)
+{
+  scan_ctx *sctx = (scan_ctx *)ctx;
+  if (sctx->current_path_len > sctx->max_path_len)
+    return true;
+  increment_arr_index(sctx);
+  save_point(sctx, string_value, len + 2);
+  return true;
+}
+
+// noexcept
+int scan_on_start_object(void *ctx)
+{
+  scan_ctx *sctx = (scan_ctx *)ctx;
+  if (sctx->current_path_len > sctx->max_path_len)
+  {
+    sctx->current_path_len++;
+    return true;
+  }
+  increment_arr_index(sctx);
+  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;
+}
+
+// noexcept
+int scan_on_key(void *ctx, const unsigned char *key, size_t len)
+{
+  scan_ctx *sctx = (scan_ctx *)ctx;
+  if (sctx->current_path_len > sctx->max_path_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.len = len;
+  return true;
+}
+
+// noexcept
+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);
+  return true;
+}
+
+// noexcept
+int scan_on_start_array(void *ctx)
+{
+  scan_ctx *sctx = (scan_ctx *)ctx;
+  if (sctx->current_path_len > sctx->max_path_len)
+  {
+    sctx->current_path_len++;
+    return true;
+  }
+  increment_arr_index(sctx);
+  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;
+  }
+  sctx->current_path_len++;
+  return true;
+}
+
+// noexcept
+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);
+  return true;
+}
+
+static yajl_callbacks scan_callbacks = {
+    scan_on_null,
+    scan_on_boolean,
+    NULL,
+    NULL,
+    scan_on_number,
+    scan_on_string,
+    scan_on_start_object,
+    scan_on_key,
+    scan_on_end_object,
+    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)
+{
+  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
+  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;
+  // Turned out callbacks can't raise exceptions
+  // VALUE callback_err;
+
+  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);
+  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);
+  }
+  // callback_err = ctx->rb_err;
+  result = ctx->points_list;
+  scan_ctx_free(ctx);
+  yajl_free(handle);
+  if (err != Qnil)
+    rb_exc_raise(rb_exc_new_str(rb_eJsonScannerParseError, err));
+  // if (callback_err != Qnil)
+  //   rb_exc_raise(callback_err);
+  // TODO: report yajl_get_bytes_consumed(handle)
+  return result;
+}
+
+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_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);
+  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"));
+}

data/ext/json_scanner/json_scanner.h

@@ -0,0 +1,12 @@
+#ifndef JSON_SCANNER_H
+#define JSON_SCANNER_H 1
+
+#include "ruby.h"
+#include "ruby/intern.h"
+#include <yajl/yajl_parse.h>
+#include <yajl/yajl_gen.h>
+
+#define true 1
+#define false 0
+
+#endif /* JSON_SCANNER_H */

data/lib/json_scanner/version.rb

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

data/lib/json_scanner.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "json_scanner/version"
+require_relative "json_scanner/json_scanner"
+
+module JsonScanner
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/json_scanner.rbs

@@ -0,0 +1,4 @@
+module JsonScanner
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/spec/json_scanner_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe JsonScanner do
+  it "has a version number" do
+    expect(described_class::VERSION).not_to be nil
+  end
+
+  it "scans json" do
+    result = described_class.scan('["1", {"a": 2}]', [[0], [1, "a"], []], false)
+    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("[0,1,2,3,4,5,6,7]", [[(0..2)], [(4...6)]], false)
+    ).to eq(
+      [[[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 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
+        # `JsonScanner.scan` returns
+        described_class.scan "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]", [[0, 0, 0, 0, 0, 0, 0]], false
+      ensure
+        GC.stress = false
+      end
+    end.to raise_error described_class::ParseError
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "json_scanner"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: json_scanner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- uvlad7
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-12-15 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
+email:
+- uvlad7@gmail.com
+executables: []
+extensions:
+- ext/json_scanner/extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- ext/json_scanner/extconf.rb
+- ext/json_scanner/json_scanner.c
+- ext/json_scanner/json_scanner.h
+- lib/json_scanner.rb
+- lib/json_scanner/version.rb
+- sig/json_scanner.rbs
+- spec/json_scanner_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/uvlad7/json_scanner
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/uvlad7/json_scanner
+  source_code_uri: https://github.com/uvlad7/json_scanner
+  changelog_uri: https://github.com/uvlad7/json_scanner/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- libyajl2, v2.1
+- libyajl-dev, v2.1
+rubygems_version: 3.5.7
+signing_key: 
+specification_version: 4
+summary: Extract values from JSON without full parsing
+test_files: []