json_scanner 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca9d160b389a5b605a37baeebd8e9d704a9b42712b9c8de9d0667ffa7e6b3d35
-  data.tar.gz: f2c0362e6bb4484e47fd5dbdda4afd7332ce42d266b4d0ebe681f24e18c31b0a
+  metadata.gz: 59b0c3b3bbb9680bf3cb26983b6d3185a3af14ce45e538e953857a2a453d9391
+  data.tar.gz: d86a61eead87fb858fbc8bf997d6a71d578229426ba4cf36a04ecbfdbd6cf3b1
 SHA512:
-  metadata.gz: 91d190291d0e2c16db38c523a58fbbff23cde136481b2c4a19446d25169a77390eee4792979cd3a22724bdf2c89132b5dc3ccc78c1553c17fe21227a70e1bf3c
-  data.tar.gz: dc704ac0ba609f209883d5af50f3f9cabcde04a0eb2c3f5ac04f964010bf866fd727c5c175dd40917526b693f13bc4b532f7a4fabce9859c0b44238cf3fa421b
+  metadata.gz: 638696fd097025ce8aa23eef8095b231d7e9c51905800a6f476dcf2e13d314620302b2cc6988e32f012d08cb7986e150c5bb7369b6ba0e407f933bba0a42489a
+  data.tar.gz: 4a54c918f1dc4136e3b5cc93cbc94a98bc225fdb1611f8ab666f926a3834e0b45d6b12c584b762d6a3fc207af4f459df97c0614af910e3b58215b57c3ba4df86

data/ext/json_scanner/extconf.rb

@@ -7,7 +7,13 @@ require "mkmf"
 # selectively, or entirely remove this flag.
 append_cflags("-fvisibility=hidden")
 
-dir_config("yajl", "", "")
+idefault, ldefault = if with_config("libyajl2-gem")
+                       require "libyajl2"
+                       [Libyajl2.include_path, Libyajl2.opt_path]
+                     else
+                       ["", ""]
+                     end
+dir_config("yajl", idefault, ldefault)
 
 unless have_library("yajl") && have_header("yajl/yajl_parse.h") && have_header("yajl/yajl_gen.h")
   abort "yajl library not found"

data/ext/json_scanner/json_scanner.c

@@ -1,11 +1,12 @@
 #include "json_scanner.h"
 
 VALUE rb_mJsonScanner;
-VALUE rb_cJsonScannerConfig;
+VALUE rb_cJsonScannerSelector;
+VALUE rb_cJsonScannerOptions;
 VALUE rb_eJsonScannerParseError;
 #define BYTES_CONSUMED "bytes_consumed"
 ID rb_iv_bytes_consumed;
-#define SCAN_KWARGS_SIZE 8
+#define SCAN_KWARGS_SIZE 9
 ID scan_kwargs_table[SCAN_KWARGS_SIZE];
 
 VALUE null_sym;
@@ -85,6 +86,7 @@ typedef struct
   // Easier to use a Ruby array for result than convert later
   // must be supplied by the caller and RB_GC_GUARD-ed if it isn't on the stack
   VALUE points_list;
+  VALUE roots_info_list;
   // by depth
   size_t *starts;
   // VALUE rb_err;
@@ -92,12 +94,68 @@ typedef struct
   size_t yajl_bytes_consumed;
 } scan_ctx;
 
-inline size_t scan_ctx_get_bytes_consumed(scan_ctx *ctx)
+typedef struct
+{
+  int with_path;
+  int verbose_error;
+  int allow_comments;
+  int dont_validate_strings;
+  int allow_trailing_garbage;
+  int allow_multiple_values;
+  int allow_partial_values;
+  int symbolize_path_keys;
+  int with_roots_info;
+} scan_options;
+#define SCAN_OPTION_VALUE_MASK 1
+#define SCAN_OPTION_SET_MASK (1 << 1)
+#define SCAN_OPTION(options, field) ((options)->field & SCAN_OPTION_VALUE_MASK)
+#define SCAN_OPTION_IS_SET(options, field) ((options)->field & SCAN_OPTION_SET_MASK)
+#define SCAN_OPTION_SET(options, field, value) ((options)->field = ((value) & SCAN_OPTION_VALUE_MASK) | SCAN_OPTION_SET_MASK)
+#define SCAN_OPTION_FALSE(options, field) \
+  (!SCAN_OPTION(options, field) && ((options)->field & SCAN_OPTION_SET_MASK))
+
+static void scan_options_init(scan_options *options, VALUE kwargs)
+{
+  options->with_path = 0;
+  options->verbose_error = 0;
+  options->allow_comments = 0;
+  options->dont_validate_strings = 0;
+  options->allow_trailing_garbage = 0;
+  options->allow_multiple_values = 0;
+  options->allow_partial_values = 0;
+  options->symbolize_path_keys = 0;
+  options->with_roots_info = 0;
+  if (kwargs != Qnil)
+  {
+    VALUE kwargs_values[SCAN_KWARGS_SIZE];
+    rb_get_kwargs(kwargs, scan_kwargs_table, 0, SCAN_KWARGS_SIZE, kwargs_values);
+    if (kwargs_values[0] != Qundef)
+      SCAN_OPTION_SET(options, with_path, RTEST(kwargs_values[0]));
+    if (kwargs_values[1] != Qundef)
+      SCAN_OPTION_SET(options, verbose_error, RTEST(kwargs_values[1]));
+    if (kwargs_values[2] != Qundef)
+      SCAN_OPTION_SET(options, allow_comments, RTEST(kwargs_values[2]));
+    if (kwargs_values[3] != Qundef)
+      SCAN_OPTION_SET(options, dont_validate_strings, RTEST(kwargs_values[3]));
+    if (kwargs_values[4] != Qundef)
+      SCAN_OPTION_SET(options, allow_trailing_garbage, RTEST(kwargs_values[4]));
+    if (kwargs_values[5] != Qundef)
+      SCAN_OPTION_SET(options, allow_multiple_values, RTEST(kwargs_values[5]));
+    if (kwargs_values[6] != Qundef)
+      SCAN_OPTION_SET(options, allow_partial_values, RTEST(kwargs_values[6]));
+    if (kwargs_values[7] != Qundef)
+      SCAN_OPTION_SET(options, symbolize_path_keys, RTEST(kwargs_values[8]));
+    if (kwargs_values[8] != Qundef)
+      SCAN_OPTION_SET(options, with_roots_info, RTEST(kwargs_values[8]));
+  }
+}
+
+static inline size_t scan_ctx_get_bytes_consumed(scan_ctx *ctx)
 {
   return ctx->yajl_bytes_consumed + yajl_get_bytes_consumed(ctx->handle);
 }
 
-inline void scan_ctx_save_bytes_consumed(scan_ctx *ctx)
+static inline void scan_ctx_save_bytes_consumed(scan_ctx *ctx)
 {
   ctx->yajl_bytes_consumed += yajl_get_bytes_consumed(ctx->handle);
 }
@@ -175,7 +233,7 @@ void scan_ctx_debug(scan_ctx *ctx)
 
 // FIXME: This will cause memory leak if ruby_xmalloc raises
 // path_ary must be RB_GC_GUARD-ed by the caller
-VALUE scan_ctx_init(scan_ctx *ctx, VALUE path_ary, VALUE string_keys)
+static VALUE scan_ctx_init(scan_ctx *ctx, VALUE path_ary, VALUE string_keys)
 {
   int path_ary_len;
   paths_t *paths;
@@ -311,8 +369,8 @@ VALUE scan_ctx_init(scan_ctx *ctx, VALUE path_ary, VALUE string_keys)
   return Qundef; // no error
 }
 
-// resets temporary values in the config
-void scan_ctx_reset(scan_ctx *ctx, VALUE points_list, int with_path, int symbolize_path_keys)
+// resets temporary values in the selector
+static void scan_ctx_reset(scan_ctx *ctx, VALUE points_list, VALUE roots_info_list, int with_path, int symbolize_path_keys)
 {
   // TODO: reset matched_depth if implemented
   ctx->current_path_len = 0;
@@ -320,11 +378,12 @@ void scan_ctx_reset(scan_ctx *ctx, VALUE points_list, int with_path, int symboli
   ctx->handle = NULL;
   ctx->yajl_bytes_consumed = 0;
   ctx->points_list = points_list;
+  ctx->roots_info_list = roots_info_list;
   ctx->with_path = with_path;
   ctx->symbolize_path_keys = symbolize_path_keys;
 }
 
-void scan_ctx_free(scan_ctx *ctx)
+static void scan_ctx_free(scan_ctx *ctx)
 {
   // fprintf(stderr, "scan_ctx_free\n");
   if (!ctx)
@@ -341,7 +400,7 @@ void scan_ctx_free(scan_ctx *ctx)
 }
 
 // noexcept
-inline void increment_arr_index(scan_ctx *sctx)
+static 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
@@ -362,7 +421,7 @@ typedef enum
 } value_type;
 
 // noexcept
-VALUE create_point(scan_ctx *sctx, value_type type, size_t length)
+static VALUE create_point(scan_ctx *sctx, value_type type, size_t length)
 {
   VALUE values[3], point;
   size_t curr_pos = scan_ctx_get_bytes_consumed(sctx);
@@ -403,7 +462,7 @@ VALUE create_point(scan_ctx *sctx, value_type type, size_t length)
 }
 
 // noexcept
-VALUE create_path(scan_ctx *sctx)
+static 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++)
@@ -429,7 +488,16 @@ VALUE create_path(scan_ctx *sctx)
 }
 
 // noexcept
-void save_point(scan_ctx *sctx, value_type type, size_t length)
+static inline void save_root_info(scan_ctx *sctx, VALUE type, size_t len)
+{
+  if (sctx->roots_info_list != Qundef && sctx->current_path_len == 0)
+  {
+    rb_ary_push(sctx->roots_info_list, rb_ary_new_from_args(2, type, ULL2NUM(scan_ctx_get_bytes_consumed(sctx) - len)));
+  }
+}
+
+// noexcept
+static 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
@@ -490,9 +558,10 @@ void save_point(scan_ctx *sctx, value_type type, size_t length)
 }
 
 // noexcept
-int scan_on_null(void *ctx)
+static int scan_on_null(void *ctx)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
+  save_root_info(sctx, null_sym, 4);
   if (sctx->current_path_len > sctx->max_path_len)
     return true;
   increment_arr_index(sctx);
@@ -501,9 +570,10 @@ int scan_on_null(void *ctx)
 }
 
 // noexcept
-int scan_on_boolean(void *ctx, int bool_val)
+static int scan_on_boolean(void *ctx, int bool_val)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
+  save_root_info(sctx, boolean_sym, bool_val ? 4 : 5);
   if (sctx->current_path_len > sctx->max_path_len)
     return true;
   increment_arr_index(sctx);
@@ -512,9 +582,10 @@ int scan_on_boolean(void *ctx, int bool_val)
 }
 
 // noexcept
-int scan_on_number(void *ctx, const char *val, size_t len)
+static int scan_on_number(void *ctx, const char *val, size_t len)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
+  save_root_info(sctx, number_sym, len);
   if (sctx->current_path_len > sctx->max_path_len)
     return true;
   increment_arr_index(sctx);
@@ -523,9 +594,10 @@ int scan_on_number(void *ctx, const char *val, size_t len)
 }
 
 // noexcept
-int scan_on_string(void *ctx, const unsigned char *val, size_t len)
+static int scan_on_string(void *ctx, const unsigned char *val, size_t len)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
+  save_root_info(sctx, string_sym, len + 2);
   if (sctx->current_path_len > sctx->max_path_len)
     return true;
   increment_arr_index(sctx);
@@ -534,9 +606,11 @@ int scan_on_string(void *ctx, const unsigned char *val, size_t len)
 }
 
 // noexcept
-int scan_on_start_object(void *ctx)
+static int scan_on_start_object(void *ctx)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
+  // Save in the beginning in case of a partial value
+  save_root_info(sctx, object_sym, 1);
   if (sctx->current_path_len > sctx->max_path_len)
   {
     sctx->current_path_len++;
@@ -551,7 +625,7 @@ int scan_on_start_object(void *ctx)
 }
 
 // noexcept
-int scan_on_key(void *ctx, const unsigned char *key, size_t len)
+static 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)
@@ -564,7 +638,7 @@ int scan_on_key(void *ctx, const unsigned char *key, size_t len)
 }
 
 // noexcept
-int scan_on_end_object(void *ctx)
+static int scan_on_end_object(void *ctx)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
   sctx->current_path_len--;
@@ -574,9 +648,11 @@ int scan_on_end_object(void *ctx)
 }
 
 // noexcept
-int scan_on_start_array(void *ctx)
+static int scan_on_start_array(void *ctx)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
+  // Save in the beginning in case of a partial value
+  save_root_info(sctx, array_sym, 1);
   if (sctx->current_path_len > sctx->max_path_len)
   {
     sctx->current_path_len++;
@@ -594,7 +670,7 @@ int scan_on_start_array(void *ctx)
 }
 
 // noexcept
-int scan_on_end_array(void *ctx)
+static int scan_on_end_array(void *ctx)
 {
   scan_ctx *sctx = (scan_ctx *)ctx;
   sctx->current_path_len--;
@@ -603,13 +679,13 @@ int scan_on_end_array(void *ctx)
   return true;
 }
 
-void config_free(void *data)
+static void selector_free(void *data)
 {
   scan_ctx_free((scan_ctx *)data);
   ruby_xfree(data);
 }
 
-size_t config_size(const void *data)
+static size_t selector_size(const void *data)
 {
   // see ObjectSpace.memsize_of
   scan_ctx *ctx = (scan_ctx *)data;
@@ -631,16 +707,16 @@ size_t config_size(const void *data)
   return res;
 }
 
-static const rb_data_type_t config_type = {
-    .wrap_struct_name = "json_scanner_config",
+static const rb_data_type_t selector_type = {
+    .wrap_struct_name = "json_scanner_selector",
     .function = {
-        .dfree = config_free,
-        .dsize = config_size,
+        .dfree = selector_free,
+        .dsize = selector_size,
     },
     .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-VALUE config_alloc(VALUE self)
+static VALUE selector_alloc(VALUE self)
 {
   scan_ctx *ctx = ruby_xmalloc(sizeof(scan_ctx));
   ctx->paths = NULL;
@@ -648,15 +724,15 @@ VALUE config_alloc(VALUE self)
   ctx->current_path = NULL;
   ctx->max_path_len = 0;
   ctx->starts = NULL;
-  scan_ctx_reset(ctx, Qundef, false, false);
-  return TypedData_Wrap_Struct(self, &config_type, ctx);
+  scan_ctx_reset(ctx, Qundef, Qundef, false, false);
+  return TypedData_Wrap_Struct(self, &selector_type, ctx);
 }
 
-VALUE config_m_initialize(VALUE self, VALUE path_ary)
+static VALUE selector_m_initialize(VALUE self, VALUE path_ary)
 {
   scan_ctx *ctx;
   VALUE scan_ctx_init_err, string_keys;
-  TypedData_Get_Struct(self, scan_ctx, &config_type, ctx);
+  TypedData_Get_Struct(self, scan_ctx, &selector_type, ctx);
   string_keys = rb_ary_new();
   scan_ctx_init_err = scan_ctx_init(ctx, path_ary, string_keys);
   if (scan_ctx_init_err != Qundef)
@@ -667,15 +743,15 @@ VALUE config_m_initialize(VALUE self, VALUE path_ary)
   return self;
 }
 
-VALUE config_m_inspect(VALUE self)
+static VALUE selector_m_inspect(VALUE self)
 {
   scan_ctx *ctx;
   VALUE res;
-  TypedData_Get_Struct(self, scan_ctx, &config_type, ctx);
+  TypedData_Get_Struct(self, scan_ctx, &selector_type, ctx);
   res = rb_sprintf("#<%" PRIsVALUE " [", rb_class_name(CLASS_OF(self)));
   for (int i = 0; ctx->paths && i < ctx->paths_len; i++)
   {
-    rb_str_cat_cstr(res, "[");
+    rb_str_buf_cat_ascii(res, "[");
     for (int j = 0; j < ctx->paths[i].len; j++)
     {
       switch (ctx->paths[i].elems[j].type)
@@ -687,20 +763,92 @@ VALUE config_m_inspect(VALUE self)
         rb_str_catf(res, "%ld", ctx->paths[i].elems[j].value.index);
         break;
       case MATCHER_INDEX_RANGE:
-        rb_str_catf(res, "(%ld..%ld)", ctx->paths[i].elems[j].value.range.start, ctx->paths[i].elems[j].value.range.end);
+        rb_str_catf(res, "(%ld..%ld)", ctx->paths[i].elems[j].value.range.start, ctx->paths[i].elems[j].value.range.end == LONG_MAX ? -1L : ctx->paths[i].elems[j].value.range.end);
         break;
       case MATCHER_ANY_KEY:
-        rb_str_cat_cstr(res, "('*'..'*')");
+        rb_str_buf_cat_ascii(res, "('*'..'*')");
         break;
       }
       if (j < ctx->paths[i].len - 1)
-        rb_str_cat_cstr(res, ", ");
+        rb_str_buf_cat_ascii(res, ", ");
     }
-    rb_str_cat_cstr(res, "]");
+    rb_str_buf_cat_ascii(res, "]");
     if (i < ctx->paths_len - 1)
-      rb_str_cat_cstr(res, ", ");
+      rb_str_buf_cat_ascii(res, ", ");
   }
-  rb_str_cat_cstr(res, "]>");
+  rb_str_buf_cat_ascii(res, "]>");
+  return res;
+}
+
+static VALUE selector_m_length(VALUE self)
+{
+  scan_ctx *ctx;
+  TypedData_Get_Struct(self, scan_ctx, &selector_type, ctx);
+  return INT2FIX(ctx->paths_len);
+}
+
+static size_t options_size(const void *data)
+{
+  return sizeof(scan_options);
+}
+
+static const rb_data_type_t options_type = {
+    .wrap_struct_name = "json_scanner_options",
+    .function = {
+        .dfree = RUBY_DEFAULT_FREE,
+        .dsize = options_size,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE options_alloc(VALUE self)
+{
+  // NOT INITIALIZED
+  scan_options *options;
+  return TypedData_Make_Struct(self, scan_options, &options_type, options);
+}
+
+static VALUE options_m_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  scan_options *options;
+  TypedData_Get_Struct(self, scan_options, &options_type, options);
+#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, "0:", &kwargs);
+#else
+  rb_scan_args(argc, argv, "0:", &kwargs);
+#endif
+  scan_options_init(options, kwargs);
+  return self;
+}
+
+static VALUE options_m_inspect(VALUE self)
+{
+  VALUE res;
+  scan_options *options;
+  TypedData_Get_Struct(self, scan_options, &options_type, options);
+  res = rb_sprintf("#<%" PRIsVALUE " {", rb_class_name(CLASS_OF(self)));
+  if (SCAN_OPTION_IS_SET(options, with_path))
+    rb_str_catf(res, "with_path: %s, ", SCAN_OPTION(options, with_path) ? "true" : "false");
+  if (SCAN_OPTION_IS_SET(options, verbose_error))
+    rb_str_catf(res, "verbose_error: %s, ", SCAN_OPTION(options, verbose_error) ? "true" : "false");
+  if (SCAN_OPTION_IS_SET(options, allow_comments))
+    rb_str_catf(res, "allow_comments: %s, ", SCAN_OPTION(options, allow_comments) ? "true" : "false");
+  if (SCAN_OPTION_IS_SET(options, dont_validate_strings))
+    rb_str_catf(res, "dont_validate_strings: %s, ", SCAN_OPTION(options, dont_validate_strings) ? "true" : "false");
+  if (SCAN_OPTION_IS_SET(options, allow_trailing_garbage))
+    rb_str_catf(res, "allow_trailing_garbage: %s, ", SCAN_OPTION(options, allow_trailing_garbage) ? "true" : "false");
+  if (SCAN_OPTION_IS_SET(options, allow_multiple_values))
+    rb_str_catf(res, "allow_multiple_values: %s, ", SCAN_OPTION(options, allow_multiple_values) ? "true" : "false");
+  if (SCAN_OPTION_IS_SET(options, allow_partial_values))
+    rb_str_catf(res, "allow_partial_values: %s, ", SCAN_OPTION(options, allow_partial_values) ? "true" : "false");
+  if (SCAN_OPTION_IS_SET(options, symbolize_path_keys))
+    rb_str_catf(res, "symbolize_path_keys: %s, ", SCAN_OPTION(options, symbolize_path_keys) ? "true" : "false");
+  if (SCAN_OPTION_IS_SET(options, with_roots_info))
+    rb_str_catf(res, "with_roots_info: %s, ", SCAN_OPTION(options, with_roots_info) ? "true" : "false");
+  if (RSTRING_END(res)[-1] == ' ')
+    rb_str_resize(res, RSTRING_LEN(res) - 2);
+  rb_str_buf_cat_ascii(res, "}>");
   return res;
 }
 
@@ -719,52 +867,60 @@ static yajl_callbacks scan_callbacks = {
 
 // def scan(json_str, path_arr, opts)
 // opts
-// with_path: false, verbose_error: false,
+// with_path: false, verbose_error: false, symbolize_path_keys: false, with_roots_info: 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)
+static VALUE scan(int argc, VALUE *argv, VALUE self)
 {
-  VALUE json_str, path_ary, with_path_flag, kwargs;
-  VALUE kwargs_values[SCAN_KWARGS_SIZE];
+  VALUE json_str, path_ary, rb_options;
+  scan_options options;
 
-  int with_path = false, verbose_error = false, symbolize_path_keys = false;
   char *json_text;
   size_t json_text_len;
   yajl_handle handle;
   yajl_status stat;
   scan_ctx *ctx;
   int free_ctx = true;
-  VALUE err_msg = Qnil, bytes_consumed, result;
+  VALUE err_msg = Qnil, bytes_consumed = Qnil, result, roots_info_result = Qundef;
   // 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_scan_args(argc, argv, "21", &json_str, &path_ary, &rb_options);
+  rb_check_type(json_str, T_STRING);
   // rb_io_write(rb_stderr, rb_sprintf("with_path_flag: %" PRIsVALUE " \n", with_path_flag));
-  with_path = RTEST(with_path_flag);
-  if (kwargs != Qnil)
+  switch (TYPE(rb_options))
   {
-    rb_get_kwargs(kwargs, scan_kwargs_table, 0, SCAN_KWARGS_SIZE, kwargs_values);
-    if (kwargs_values[0] != Qundef)
-      with_path = RTEST(kwargs_values[0]);
-    if (kwargs_values[1] != Qundef)
-      verbose_error = RTEST(kwargs_values[1]);
-    if (kwargs_values[7] != Qundef)
-      symbolize_path_keys = RTEST(kwargs_values[7]);
+  case T_HASH:
+  case T_NIL:
+    scan_options_init(&options, rb_options);
+    break;
+  case T_DATA:
+    if (rb_obj_is_kind_of(rb_options, rb_cJsonScannerOptions))
+    {
+      scan_options *ptr;
+      TypedData_Get_Struct(rb_options, scan_options, &options_type, ptr);
+      options = *ptr;
+    }
+    else
+    {
+      rb_raise(rb_eTypeError, "Expected a Hash or %" PRIsVALUE ", got %" PRIsVALUE, rb_cJsonScannerOptions, rb_obj_class(rb_options));
+    }
+    break;
+  default:
+    rb_raise(rb_eTypeError, "Expected a Hash or %" PRIsVALUE ", got %" PRIsVALUE, rb_cJsonScannerOptions, rb_obj_class(rb_options));
+    break;
   }
-  rb_check_type(json_str, T_STRING);
+  if (SCAN_OPTION(&options, with_roots_info))
+    roots_info_result = rb_ary_new();
   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
-  if (rb_obj_is_kind_of(path_ary, rb_cJsonScannerConfig))
+  if (rb_obj_is_kind_of(path_ary, rb_cJsonScannerSelector))
   {
     free_ctx = false;
-    TypedData_Get_Struct(path_ary, scan_ctx, &config_type, ctx);
+    TypedData_Get_Struct(path_ary, scan_ctx, &selector_type, ctx);
   }
   else
   {
@@ -783,23 +939,20 @@ VALUE scan(int argc, VALUE *argv, VALUE self)
   {
     rb_ary_push(result, rb_ary_new());
   }
-  scan_ctx_reset(ctx, result, with_path, symbolize_path_keys);
+  scan_ctx_reset(ctx, result, roots_info_result, SCAN_OPTION(&options, with_path), SCAN_OPTION(&options, symbolize_path_keys));
   // scan_ctx_debug(ctx);
 
   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]));
-  }
+  if (SCAN_OPTION_IS_SET(&options, allow_comments))
+    yajl_config(handle, yajl_allow_comments, SCAN_OPTION(&options, allow_comments));
+  if (SCAN_OPTION_IS_SET(&options, dont_validate_strings))
+    yajl_config(handle, yajl_dont_validate_strings, SCAN_OPTION(&options, dont_validate_strings));
+  if (SCAN_OPTION_IS_SET(&options, allow_trailing_garbage))
+    yajl_config(handle, yajl_allow_trailing_garbage, SCAN_OPTION(&options, allow_trailing_garbage));
+  if (SCAN_OPTION_IS_SET(&options, allow_multiple_values))
+    yajl_config(handle, yajl_allow_multiple_values, SCAN_OPTION(&options, allow_multiple_values));
+  if (SCAN_OPTION_IS_SET(&options, allow_partial_values))
+    yajl_config(handle, yajl_allow_partial_values, SCAN_OPTION(&options, allow_partial_values));
   ctx->handle = handle;
   stat = yajl_parse(handle, (unsigned char *)json_text, json_text_len);
   if (stat == yajl_status_ok)
@@ -810,7 +963,7 @@ VALUE scan(int argc, VALUE *argv, VALUE self)
 
   if (stat != yajl_status_ok)
   {
-    char *str = (char *)yajl_get_error(handle, verbose_error, (unsigned char *)json_text, json_text_len);
+    char *str = (char *)yajl_get_error(handle, SCAN_OPTION(&options, verbose_error), (unsigned char *)json_text, json_text_len);
     err_msg = rb_utf8_str_new_cstr(str);
     bytes_consumed = ULL2NUM(scan_ctx_get_bytes_consumed(ctx));
     yajl_free_error(handle, (unsigned char *)str);
@@ -849,6 +1002,10 @@ VALUE scan(int argc, VALUE *argv, VALUE self)
   }
   // if (callback_err != Qnil)
   //   rb_exc_raise(callback_err);
+  if (roots_info_result != Qundef)
+  {
+    result = rb_ary_new_from_args(2, result, roots_info_result);
+  }
   return result;
 }
 
@@ -856,10 +1013,16 @@ RUBY_FUNC_EXPORTED void
 Init_json_scanner(void)
 {
   rb_mJsonScanner = rb_define_module("JsonScanner");
-  rb_cJsonScannerConfig = rb_define_class_under(rb_mJsonScanner, "Config", rb_cObject);
-  rb_define_alloc_func(rb_cJsonScannerConfig, config_alloc);
-  rb_define_method(rb_cJsonScannerConfig, "initialize", config_m_initialize, 1);
-  rb_define_method(rb_cJsonScannerConfig, "inspect", config_m_inspect, 0);
+  rb_cJsonScannerSelector = rb_define_class_under(rb_mJsonScanner, "Selector", rb_cObject);
+  rb_define_alloc_func(rb_cJsonScannerSelector, selector_alloc);
+  rb_define_method(rb_cJsonScannerSelector, "initialize", selector_m_initialize, 1);
+  rb_define_method(rb_cJsonScannerSelector, "inspect", selector_m_inspect, 0);
+  rb_define_method(rb_cJsonScannerSelector, "length", selector_m_length, 0);
+  rb_define_alias(rb_cJsonScannerSelector, "size", "length");
+  rb_cJsonScannerOptions = rb_define_class_under(rb_mJsonScanner, "Options", rb_cObject);
+  rb_define_alloc_func(rb_cJsonScannerOptions, options_alloc);
+  rb_define_method(rb_cJsonScannerOptions, "initialize", options_m_initialize, -1);
+  rb_define_method(rb_cJsonScannerOptions, "inspect", options_m_inspect, 0);
   rb_define_const(rb_mJsonScanner, "ANY_INDEX", rb_range_new(INT2FIX(0), INT2FIX(-1), false));
   any_key_sym = rb_id2sym(rb_intern("*"));
   rb_define_const(rb_mJsonScanner, "ANY_KEY", rb_range_new(any_key_sym, any_key_sym, false));
@@ -881,4 +1044,5 @@ Init_json_scanner(void)
   scan_kwargs_table[5] = rb_intern("allow_multiple_values");
   scan_kwargs_table[6] = rb_intern("allow_partial_values");
   scan_kwargs_table[7] = rb_intern("symbolize_path_keys");
+  scan_kwargs_table[8] = rb_intern("with_roots_info");
 }

data/lib/json_scanner/version.rb

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