class Oj::Parser
A reusable parser that makes use of named delegates to determine the handling of parsed data. Delegates are available for validation, a callback parser (SAJ), and a usual delegate that builds Ruby objects as parsing proceeds.
This parser is considerably faster than the older Oj.parse call and isolates options to just the parser so that other parts of the code are not forced to use the same options.
Public Class Methods
Creates a new Parser
with the specified mode. If no mode is provided validation is assumed. Optional arguments can be provided that match the mode. For example with the :usual mode the call might look like Oj::Parser.new
(:usual, cache_keys: true).
static VALUE parser_new(int argc, VALUE *argv, VALUE self) { ojParser p = OJ_R_ALLOC(struct _ojParser); #if HAVE_RB_EXT_RACTOR_SAFE // This doesn't seem to do anything. rb_ext_ractor_safe(true); #endif memset(p, 0, sizeof(struct _ojParser)); buf_init(&p->key); buf_init(&p->buf); p->map = value_map; if (argc < 1) { oj_set_parser_validator(p); } else { VALUE mode = argv[0]; if (Qnil == mode) { oj_set_parser_validator(p); } else { const char *ms = NULL; switch (rb_type(mode)) { case RUBY_T_SYMBOL: mode = rb_sym2str(mode); // fall through case RUBY_T_STRING: ms = RSTRING_PTR(mode); break; default: rb_raise(rb_eArgError, "mode must be :validate, :usual, :saj, or :object"); } if (0 == strcmp("usual", ms) || 0 == strcmp("standard", ms) || 0 == strcmp("strict", ms) || 0 == strcmp("compat", ms)) { oj_set_parser_usual(p); } else if (0 == strcmp("object", ms)) { // TBD } else if (0 == strcmp("saj", ms)) { oj_set_parser_saj(p); } else if (0 == strcmp("validate", ms)) { oj_set_parser_validator(p); } else if (0 == strcmp("debug", ms)) { oj_set_parser_debug(p); } else { rb_raise(rb_eArgError, "mode must be :validate, :usual, :saj, or :object"); } } if (1 < argc) { VALUE ropts = argv[1]; Check_Type(ropts, T_HASH); rb_hash_foreach(ropts, opt_cb, (VALUE)p); } } return Data_Wrap_Struct(parser_class, parser_mark, parser_free, p); }
Returns the default SAJ parser. Note the default SAJ parser can not be used concurrently in more than one thread.
static VALUE parser_saj(VALUE self) { if (Qundef == saj_parser) { ojParser p = OJ_R_ALLOC(struct _ojParser); memset(p, 0, sizeof(struct _ojParser)); buf_init(&p->key); buf_init(&p->buf); p->map = value_map; oj_set_parser_saj(p); saj_parser = Data_Wrap_Struct(parser_class, parser_mark, parser_free, p); rb_gc_register_address(&saj_parser); } return saj_parser; }
Returns the default usual parser. Note the default usual parser can not be used concurrently in more than one thread.
static VALUE parser_usual(VALUE self) { if (Qundef == usual_parser) { ojParser p = OJ_R_ALLOC(struct _ojParser); memset(p, 0, sizeof(struct _ojParser)); buf_init(&p->key); buf_init(&p->buf); p->map = value_map; oj_set_parser_usual(p); usual_parser = Data_Wrap_Struct(parser_class, parser_mark, parser_free, p); rb_gc_register_address(&usual_parser); } return usual_parser; }
Returns the default validate parser.
static VALUE parser_validate(VALUE self) { if (Qundef == validate_parser) { ojParser p = OJ_R_ALLOC(struct _ojParser); memset(p, 0, sizeof(struct _ojParser)); buf_init(&p->key); buf_init(&p->buf); p->map = value_map; oj_set_parser_validator(p); validate_parser = Data_Wrap_Struct(parser_class, parser_mark, parser_free, p); rb_gc_register_address(&validate_parser); } return validate_parser; }
Public Instance Methods
(filename)
Parse a JSON
file.
Returns the result according to the delegate of the parser.
static VALUE parser_file(VALUE self, VALUE filename) { ojParser p = (ojParser)DATA_PTR(self); const char *path; int fd; path = StringValuePtr(filename); parser_reset(p); p->start(p); if (0 > (fd = open(path, O_RDONLY))) { rb_raise(rb_eIOError, "error opening %s", path); } #if USE_THREAD_LIMIT struct stat info; // st_size will be 0 if not a file if (0 == fstat(fd, &info) && USE_THREAD_LIMIT < info.st_size) { // Use threaded version. // TBD only if has pthreads // TBD parse_large(p, fd); return p->result(p); } #endif byte buf[16385]; size_t size = sizeof(buf) - 1; size_t rsize; while (true) { if (0 < (rsize = read(fd, buf, size))) { buf[rsize] = '\0'; parse(p, buf); } if (rsize <= 0) { if (0 != rsize) { rb_raise(rb_eIOError, "error reading from %s", path); } break; } } return p->result(p); }
Returns the current state of the just_one
[Boolean] option.
static VALUE parser_just_one(VALUE self) { ojParser p = (ojParser)DATA_PTR(self); return p->just_one ? Qtrue : Qfalse; }
Sets the just_one option which limits the parsing of a string or or stream to a single JSON
element.
Returns the current state of the just_one
[Boolean] option.
static VALUE parser_just_one_set(VALUE self, VALUE v) { ojParser p = (ojParser)DATA_PTR(self); p->just_one = (Qtrue == v); return p->just_one ? Qtrue : Qfalse; }
(reader)
Parse a JSON
stream.
Returns the result according to the delegate of the parser.
static VALUE parser_load(VALUE self, VALUE reader) { ojParser p = (ojParser)DATA_PTR(self); parser_reset(p); p->reader = reader; rb_rescue2(load, self, load_rescue, Qnil, rb_eEOFError, 0); return p->result(p); }
(value)
Methods not handled by the parser are passed to the delegate. The methods supported by delegate are:
-
:validate
-
no options
-
-
:saj
-
cache_keys= sets the value of the cache_keys flag.
-
cache_keys returns the value of the cache_keys flag.
-
cache_strings= sets the value of the cache_strings to an positive integer less than 35. Strings shorter than
-
that length are cached.
- _cache_strings_ returns the value of the _cache_strings_ integer value. - _handler=_ sets the SAJ handler - _handler_ returns the SAJ handler
-
:usual
-
cache_keys= sets the value of the cache_keys flag.
-
cache_keys returns the value of the cache_keys flag.
-
cache_strings= sets the value of the cache_strings to a positive integer less than 35. Strings shorter than
-
that length are cached.
- _cache_strings_ returns the value of the _cache_strings_ integer value. - _cache_expunge=_ sets the value of the _cache_expunge_ where 0 never expunges, 1 expunges slowly, 2 expunges
faster, and 3 or higher expunges agressively.
- _cache_expunge_ returns the value of the _cache_expunge_ integer value. - _capacity=_ sets the capacity of the parser. The parser grows automatically but can be updated directly with this
call.
- _capacity_ returns the current capacity of the parser's internal stack. - _create_id_ returns the value _create_id_ or _nil_ if there is no _create_id_. - _create_id=_ sets the value _create_id_ or if _nil_ unsets it. Parsed JSON objects that include the specified
element use the element value as the name of the class to create an object from instead of a Hash.
- _decimal=_ sets the approach to how decimals are parser. If _:auto_ then the decimals with significant digits are
16 or less are Floats and long ones are BigDecimal. :ruby uses a call to Ruby to convert a string to a Float. :float always generates a Float. :bigdecimal always results in a BigDecimal.
- _decimal_ returns the value of the decimal conversion option which can be :auto (default), :ruby, :float, or
:bigdecimal.
- _ignore_json_create_ returns the value of the _ignore_json_create_ flag. - _ignore_json_create=_ sets the value of the _ignore_json_create_ flag. When set the class json_create method is
ignored on parsing in favor of creating an instance and populating directly.
- _missing_class_ return the value of the _missing_class_ indicator. - _missing_class=_ sets the value of the _missing_class_ flag. Valid values are _:auto_ which creates any missing
classes on parse, :ignore which ignores and continues as a Hash (default), and :raise which raises an exception if the class is not found.
- _omit_null=_ sets the _omit_null_ flag. If true then null values in a map or object are omitted from the
resulting Hash or Object
.
- _omit_null_ returns the value of the _omit_null_ flag. - _symbol_keys=_ sets the flag that indicates Hash keys should be parsed to Symbols versus Strings. - _symbol_keys_ returns the value of the _symbol_keys_ flag.
static VALUE parser_missing(int argc, VALUE *argv, VALUE self) { ojParser p = (ojParser)DATA_PTR(self); const char *key = NULL; volatile VALUE rkey = *argv; volatile VALUE rv = Qnil; #if HAVE_RB_EXT_RACTOR_SAFE // This doesn't seem to do anything. rb_ext_ractor_safe(true); #endif switch (rb_type(rkey)) { case RUBY_T_SYMBOL: rkey = rb_sym2str(rkey); // fall through case RUBY_T_STRING: key = StringValuePtr(rkey); break; default: rb_raise(rb_eArgError, "option method must be a symbol or string"); } if (1 < argc) { rv = argv[1]; } return p->option(p, key, rv); }
(json)
Parse a JSON
string.
Returns the result according to the delegate of the parser.
static VALUE parser_parse(VALUE self, VALUE json) { ojParser p = (ojParser)DATA_PTR(self); const byte *ptr = (const byte *)StringValuePtr(json); parser_reset(p); p->start(p); parse(p, ptr); return p->result(p); }