Class: Oj::Parser

Inherits:

Object

• Object
• Oj::Parser

Defined in:

ext/oj/parser.c,
ext/oj/parser.c

Overview

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.

Class Method Summary

• .new(mode = nil) ⇒ Object

  Creates a new Parser with the specified mode.

• .saj ⇒ Object

  Returns the default SAJ parser.

• .usual ⇒ Object

  Returns the default usual parser.

• .validate ⇒ Object

  Returns the default validate parser.

Instance Method Summary

• #file(filename) ⇒ Object

  Parse a JSON file.

• #just_one ⇒ Object

  Returns the current state of the just_one [Boolean] option.

• #just_one=(value) ⇒ Object

  Sets the just_one option which limits the parsing of a string or or stream to a single JSON element.

• #load(reader) ⇒ Object

  Parse a JSON stream.

• #method_missing(value) ⇒ Object

  Methods not handled by the parser are passed to the delegate.

• #parse(json) ⇒ Object

  Parse a JSON string.

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(value) ⇒ Object

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.

# File 'ext/oj/parser.c', line 1090

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 = rb_string_value_ptr(&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);
}

Class Method Details

.new(mode = nil) ⇒ Object

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).

# File 'ext/oj/parser.c', line 959

static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
    ojParser p = 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);
}

.saj ⇒ Object

Returns the default SAJ parser. Note the default SAJ parser can not be used concurrently in more than one thread.

# File 'ext/oj/parser.c', line 1275

static VALUE parser_saj(VALUE self) {
    if (Qundef == saj_parser) {
        ojParser p = 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;
}

.usual ⇒ Object

Returns the default usual parser. Note the default usual parser can not be used concurrently in more than one thread.

# File 'ext/oj/parser.c', line 1252

static VALUE parser_usual(VALUE self) {
    if (Qundef == usual_parser) {
        ojParser p = 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;
}

.validate ⇒ Object

Returns the default validate parser.

# File 'ext/oj/parser.c', line 1297

static VALUE parser_validate(VALUE self) {
    if (Qundef == validate_parser) {
        ojParser p = 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;
}

Instance Method Details

#file(filename) ⇒ Object

Parse a JSON file.

Returns the result according to the delegate of the parser.

# File 'ext/oj/parser.c', line 1174

static VALUE parser_file(VALUE self, VALUE filename) {
    ojParser    p = (ojParser)DATA_PTR(self);
    const char *path;
    int         fd;

    Check_Type(filename, T_STRING);
    path = rb_string_value_ptr(&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);
}

#just_one ⇒ Object

Returns the current state of the just_one [Boolean] option.

# File 'ext/oj/parser.c', line 1222

static VALUE parser_just_one(VALUE self) {
    ojParser p = (ojParser)DATA_PTR(self);

    return p->just_one ? Qtrue : Qfalse;
}

#just_one=(value) ⇒ Object

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.

# File 'ext/oj/parser.c', line 1236

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;
}

#load(reader) ⇒ Object

Parse a JSON stream.

Returns the result according to the delegate of the parser.

# File 'ext/oj/parser.c', line 1157

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);
}

#parse(json) ⇒ Object

Parse a JSON string.

Returns the result according to the delegate of the parser.

# File 'ext/oj/parser.c', line 1120

static VALUE parser_parse(VALUE self, VALUE json) {
    ojParser p = (ojParser)DATA_PTR(self);

    Check_Type(json, T_STRING);
    parser_reset(p);
    p->start(p);
    parse(p, (const byte *)rb_string_value_ptr(&json));

    return p->result(p);
}