json_scanner 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ffddd81459c088040c2ddee0006b1c9172e8a15aa8bab987dc59743e697f49f
-  data.tar.gz: 73b69bbcddaaf6711b2563787c4cbde1d258bf1d28b1e694714fd782c42d4c2c
+  metadata.gz: f34237d4ceab009f685b82a4e480247f23c804db96bded6d1bacea5ddd4a0946
+  data.tar.gz: 87484e4cbab84666b41ddb67553b0c985ef6dc29d8f1154a458173deade08587
 SHA512:
-  metadata.gz: 44a153e578da606f67399a09387cf26d63b1528ad9e6bb258083435202f094ebc95e3a2c895a83334eb2aeef4ea9bfbe0f0c38374ac76f5772beea6bc3910a0f
-  data.tar.gz: ff9bcbc934fafc4857faf926bca5f5c6c82ec357107b8d6e5f2c0a7e9e622afe3a19d4b0a3f4a987d2e965432c73615203afd1c3e1ac6a52965555b20ef2f377
+  metadata.gz: 5f6ae7f8d7afc88fee60e88eb8efe776b7ae0dffe25ecffa5ffc61241629eb4c3ec86a9ab1b1e76d49b4bd12498ee15625677afbc997039f9295e65e510a32df
+  data.tar.gz: b5e95df2d53c0a224f6a089a55a6a0c502adb7e4dce276f2f85c48a063182f65f1425eff1f97cf409de46c815b45bbfa0626e54d76036a5c66c13eefa4146648

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;
@@ -84,7 +84,7 @@ 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;
@@ -134,7 +134,7 @@ scan_ctx *scan_ctx_init(VALUE path_ary, VALUE with_path)
 
   ctx = ruby_xmalloc(sizeof(scan_ctx));
 
-  ctx->with_path = RTEST(with_path);
+  ctx->with_path = with_path;
   ctx->max_path_len = 0;
 
   paths = ruby_xmalloc(sizeof(paths_t) * path_ary_len);
@@ -196,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;
 
@@ -239,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)
 {
   VALUE values[3];
-  *point = rb_ary_new_capa(3);
+  VALUE point = rb_ary_new_capa(3);
   // noexcept
   values[1] = RB_ULONG2NUM(curr_pos);
   switch (type)
@@ -274,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
@@ -282,6 +306,7 @@ 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++)
@@ -319,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
@@ -382,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;
 }
@@ -409,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;
 }
 
@@ -425,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;
   }
@@ -440,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;
 }
 
@@ -459,9 +484,17 @@ 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)
 {
+  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;
@@ -470,8 +503,21 @@ VALUE scan(VALUE self, VALUE json_str, VALUE path_ary, VALUE with_path)
   VALUE err = Qnil, result;
   // Turned out callbacks can't raise exceptions
   // VALUE callback_err;
-  // TODO
-  int opt_verbose_error = 0;
+#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
@@ -482,18 +528,28 @@ VALUE scan(VALUE self, VALUE json_str, VALUE path_ary, VALUE with_path)
   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);
   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);
+    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;
@@ -513,18 +569,19 @@ Init_json_scanner(void)
 {
   rb_mJsonScanner = rb_define_module("JsonScanner");
   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));
-  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.1"
+  VERSION = "0.2.0"
 end

data/spec/json_scanner_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "spec_helper"
+require "json"
 
 RSpec.describe JsonScanner do
   it "has a version number" do
@@ -8,19 +9,35 @@ RSpec.describe JsonScanner do
   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
@@ -28,10 +45,10 @@ RSpec.describe JsonScanner do
         # 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
@@ -40,26 +57,137 @@ RSpec.describe JsonScanner do
 
   it "allows to select ranges" do
     expect(
-      described_class.scan("[[1,2],[3,4]]", [[described_class::ANY_INDEX, described_class::ANY_INDEX]], false)
+      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]]]
+      [[[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)
+      described_class.scan("[[1,2],[3,4]]", [[described_class::ANY_INDEX, (0...1)]]),
     ).to eq(
-      [[[2, 3, :number], [8, 9, :number]]]
+      [[[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)
+      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)]], false)
+      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)]], false)
+      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.1
+  version: 0.2.0
 platform: ruby
 authors:
 - uvlad7
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-16 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