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.

• .safe(*args) ⇒ Object
• .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 is a flag indicating hash keys should be cached.
  • cache_strings is a positive integer less than 35. Strings shorter than that length are cached.
  • handler is the SAJ handler

• :usual

  • cache_keys is a flag indicating hash keys should be cached.
  • cache_strings is a positive integer less than 35. Strings shorter than that length are cached.
  • cache_expunge dictates when the cache will be expunged where 0 never expunges, 1 expunges slowly, 2 expunges faster, and 3 or higher expunges agressively.
  • capacity is the capacity of the parser's internal stack. The parser grows automatically but can be updated directly with this call.
  • create_id if non-nil is the key that is used to specify the type of object to create when parsing. 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 is the approach to how decimals are parsed. 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.
  • ignore_json_create is a flag that when set the class json_create method is ignored on parsing in favor of creating an instance and populating directly.
  • missing_class is an indicator that determines how unknown class names are handled. 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 is a flag that if true then null values in a map or object are omitted from the resulting Hash or Object.
  • symbol_keys is a flag that indicates Hash keys should be parsed to Symbols versus Strings.

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

static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
    ojParser       p;
    const char    *key  = NULL;
    volatile VALUE rkey = *argv;
    volatile VALUE rv   = Qnil;

    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);

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

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 1058

static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
    ojParser       p = OJ_R_ALLOC(struct _ojParser);
    volatile VALUE pv;

#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;
    // Until the parser is wrapped the GC can not free it, so the mode and the
    // options, both of which raise on a value they do not take, are handled
    // after the wrap.
    pv = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);

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

.safe(*args) ⇒ Object

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

static VALUE parser_safe(int argc, VALUE *argv, VALUE self) {
    VALUE options;

    if (1 == argc) {
        options = argv[0];

        Check_Type(options, T_HASH);
    } else {
        options = rb_hash_new();
    }

    ojParser       p = OJ_R_ALLOC(struct _ojParser);
    volatile VALUE pv;

    memset(p, 0, sizeof(struct _ojParser));
    buf_init(&p->key);
    buf_init(&p->buf);
    p->map = value_map;
    // The limits raise on a value that is not an Integer, so the parser has to
    // be wrapped before they are read.
    pv = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
    oj_set_parser_safe(p, options);

    return pv;
}

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

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 = TypedData_Wrap_Struct(parser_class, &oj_parser_type, 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 1419

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 = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
        rb_gc_register_address(&usual_parser);
    }
    return usual_parser;
}

.validate ⇒ Object

Returns the default validate parser.

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

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 = TypedData_Wrap_Struct(parser_class, &oj_parser_type, 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 1346

static VALUE parser_file(VALUE self, VALUE filename) {
    struct _fileParse fp;
    ojParser          p;
    const char       *path;
    int               fd;

    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);

    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);
        close(fd);
        return p->result(p);
    }
#endif
    fp.p    = p;
    fp.path = path;
    fp.fd   = fd;

    return rb_ensure(file_parse, (VALUE)&fp, file_close, (VALUE)&fp);
}

#just_one ⇒ Object

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

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

static VALUE parser_just_one(VALUE self) {
    ojParser p;

    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);

    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 1401

static VALUE parser_just_one_set(VALUE self, VALUE v) {
    ojParser p;

    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);

    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 1294

static VALUE parser_load(VALUE self, VALUE reader) {
    ojParser p;

    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);

    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 1240

static VALUE parser_parse(VALUE self, VALUE json) {
    ojParser    p;
    int         frozen = OBJ_FROZEN(json);
    const byte *ptr;

    if (!frozen) {
        rb_str_freeze(json);
    }
    ptr = (const byte *)StringValuePtr(json);

    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);

    parser_reset(p);
    p->start(p);
    parse(p, ptr, (size_t)RSTRING_LEN(json), false);
    validate_document_end(p);

    return p->result(p);
}