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(*args) ⇒ Object
• .safe(*args) ⇒ Object
• .saj ⇒ Object
• .usual ⇒ Object
• .validate ⇒ Object

Instance Method Summary

• #file(filename) ⇒ Object
• #just_one ⇒ Object
• #just_one=(v) ⇒ Object
• #load(reader) ⇒ Object
• #method_missing(*args) ⇒ Object
• #parse(json) ⇒ Object

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(*args) ⇒ Object

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

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(*args) ⇒ Object

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

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 1457

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

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

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

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

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

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

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

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

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

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

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=(v) ⇒ Object

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

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

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

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

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

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