module JSON

A mimic of the json gem module.

Constants

FAST_STATE_PROTOTYPE
Infinity
MinusInfinity
NaN
PRETTY_STATE_PROTOTYPE

Taken from the unit test. Note that items like check_circular? are not present.

Parser
SAFE_STATE_PROTOTYPE
State

Public Class Methods

[](obj, opts={}) click to toggle source

If the obj argument is a String then it is assumed to be a JSON String and parsed otherwise the obj is encoded as a JSON String.

  • obj [String|Hash|Array] object to convert

  • opts [Hash] same options as either generate or parse

Returns [Object]

static VALUE
mimic_dump_load(int argc, VALUE *argv, VALUE self) {
    if (1 > argc) {
        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
    } else if (T_STRING == rb_type(*argv)) {
        return mimic_load(argc, argv, self);
    } else {
        return mimic_dump(argc, argv, self);
    }
    return Qnil;
}
create_id() click to toggle source

Returns [String] the create_id.

static VALUE
mimic_create_id(VALUE self) {
    if (NULL != oj_default_options.create_id) {
        return oj_encode(rb_str_new_cstr(oj_default_options.create_id));
    }
    return rb_str_new_cstr(oj_json_class);
}
create_id=(id) click to toggle source

Sets the ::create_id tag to look for in JSON document. That key triggers the creation of a class with the same name.

Returns [String] the id.

static VALUE
mimic_set_create_id(VALUE self, VALUE id) {
    Check_Type(id, T_STRING);

    if (NULL != oj_default_options.create_id) {
        if (oj_json_class != oj_default_options.create_id) {
            xfree((char*)oj_default_options.create_id);
        }
        oj_default_options.create_id = NULL;
        oj_default_options.create_id_len = 0;
    }
    if (Qnil != id) {
        size_t len = RSTRING_LEN(id) + 1;

        oj_default_options.create_id = ALLOC_N(char, len);
        strcpy((char*)oj_default_options.create_id, StringValuePtr(id));
        oj_default_options.create_id_len = len - 1;
    }
    return id;
}
dump(obj, anIO=nil, limit=nil) click to toggle source

Encodes an object as a JSON String.

  • obj [Object] object to convert to encode as JSON

  • anIO [IO] an IO that allows writing

  • limit [Fixnum] ignored

Returns [String] a JSON string.

static VALUE
mimic_dump(int argc, VALUE *argv, VALUE self) {
    char                buf[4096];
    struct _out         out;
    struct _options     copts = oj_default_options;
    VALUE               rstr;

    copts.str_rx.head = NULL;
    copts.str_rx.tail = NULL;
    out.buf = buf;
    out.end = buf + sizeof(buf) - 10;
    out.allocated = false;
    out.caller = CALLER_DUMP;
    copts.escape_mode = JXEsc;
    copts.mode = CompatMode;

    /* seems like this is not correct
    if (No == copts.nilnil && Qnil == *argv) {
        rb_raise(rb_eTypeError, "nil not allowed.");
    }
    */
    copts.dump_opts.max_depth = MAX_DEPTH; // when using dump there is no limit
    out.omit_nil = copts.dump_opts.omit_nil;
    if (2 <= argc) {
        int    limit;

        // The json gem take a more liberal approach to optional
        // arguments. Expected are (obj, anIO=nil, limit=nil) yet the io
        // argument can be left off completely and the 2nd argument is then
        // the limit.
        if (0 <= (limit = mimic_limit_arg(argv[1]))) {
            copts.dump_opts.max_depth = limit;
        }
        if (3 <= argc && 0 <= (limit = mimic_limit_arg(argv[2]))) {
            copts.dump_opts.max_depth = limit;
        }
    }
    oj_dump_obj_to_json(*argv, &copts, &out);
    if (0 == out.buf) {
        rb_raise(rb_eNoMemError, "Not enough memory.");
    }
    rstr = rb_str_new2(out.buf);
    rstr = oj_encode(rstr);
    if (2 <= argc && Qnil != argv[1] && rb_respond_to(argv[1], oj_write_id)) {
        VALUE  io = argv[1];
        VALUE  args[1];

        *args = rstr;
        rb_funcall2(io, oj_write_id, 1, args);
        rstr = io;
    }
    if (out.allocated) {
        xfree(out.buf);
    }
    return rstr;
}
dump_default_options() click to toggle source
# File lib/oj/json.rb, line 48
def self.dump_default_options
  Oj::MimicDumpOption.new
end
dump_default_options=(h) click to toggle source
# File lib/oj/json.rb, line 52
def self.dump_default_options=(h)
  m = Oj::MimicDumpOption.new
  h.each do |k,v|
    m[k] = v
  end
end
fast_generate(obj, opts=nil) click to toggle source
VALUE
oj_mimic_generate(int argc, VALUE *argv, VALUE self) {
    struct _options     copts = oj_default_options;

    copts.str_rx.head = NULL;
    copts.str_rx.tail = NULL;

    return mimic_generate_core(argc, argv, &copts);
}
generate(obj, opts=nil) click to toggle source

Encode obj as a JSON String. The obj argument must be a Hash, Array, or respond to to_h or to_json. Options other than those listed such as :allow_nan or :max_nesting are ignored.

  • obj [Object|Hash|Array] object to convert to a JSON String

  • opts [Hash] options

    • :indent [String] String to use for indentation.

    • :space [String] String placed after a , or : delimiter

    • :space_before [String] String placed before a : delimiter

    • :object_nl [String] String placed after a JSON object

    • :array_nl [String] String placed after a JSON array

    • :ascii_only [Boolean] if not nil or false then use only ascii characters in the output. Note ::generate does support this even if it is not documented.

Returns [String] generated JSON.

VALUE
oj_mimic_generate(int argc, VALUE *argv, VALUE self) {
    struct _options     copts = oj_default_options;

    copts.str_rx.head = NULL;
    copts.str_rx.tail = NULL;

    return mimic_generate_core(argc, argv, &copts);
}
generate(obj, opts=nil) click to toggle source

Encode obj as a JSON String. The obj argument must be a Hash, Array, or respond to to_h or to_json. Options other than those listed such as :allow_nan or :max_nesting are ignored.

  • obj [Object|Hash|Array] object to convert to a JSON String

  • opts [Hash] options

    • :indent [String] String to use for indentation.

    • :space [String] String placed after a , or : delimiter

    • :space_before [String] String placed before a : delimiter

    • :object_nl [String] String placed after a JSON object

    • :array_nl [String] String placed after a JSON array

    • :ascii_only [Boolean] if not nil or false then use only ascii characters in the output. Note ::generate does support this even if it is not documented.

Returns [String] generated JSON.

VALUE
oj_mimic_generate(int argc, VALUE *argv, VALUE self) {
    struct _options     copts = oj_default_options;

    copts.str_rx.head = NULL;
    copts.str_rx.tail = NULL;

    return mimic_generate_core(argc, argv, &copts);
}
generator() click to toggle source
# File lib/oj/json.rb, line 71
def self.generator()
  @@generator
end
generator=(g) click to toggle source
# File lib/oj/json.rb, line 67
def self.generator=(g)
  @@generator = g
end
load(source, proc=nil) click to toggle source

Loads a Ruby Object from a JSON source that can be either a String or an IO. If Proc is given or a block is providedit is called with each nested element of the loaded Object.

  • source [String|IO] JSON source

  • proc [Proc] to yield to on each element or nil

Returns [Object] the decode Object.

static VALUE
mimic_load(int argc, VALUE *argv, VALUE self) {
    VALUE       obj;
    VALUE       p = Qnil;

    obj = oj_compat_load(argc, argv, self);
    if (2 <= argc) {
        if (rb_cProc == rb_obj_class(argv[1])) {
            p = argv[1];
        } else if (3 <= argc) {
            if (rb_cProc == rb_obj_class(argv[2])) {
                p = argv[2];
            }
        }
    }
    mimic_walk(Qnil, obj, p);

    return obj;
}
parse(source, opts=nil) click to toggle source

Parses a JSON String or IO into a Ruby Object. Options other than those listed such as :allow_nan or :max_nesting are ignored. :object_class and :array_object are not supported.

  • source [String|IO] source to parse

  • opts [Hash] options

    • :symbolize [Boolean] _names flag indicating JSON object keys should be Symbols instead of Strings

    • :create_additions [Boolean] flag indicating a key matching create_id in a JSON object should trigger the creation of Ruby Object

Returns [Object] @see ::create_id=

VALUE
oj_mimic_parse(int argc, VALUE *argv, VALUE self) {
    return mimic_parse_core(argc, argv, self, false);
}
parse!(source, opts=nil) click to toggle source

Same as parse(). @see parse

static VALUE
mimic_parse_bang(int argc, VALUE *argv, VALUE self) {
    return mimic_parse_core(argc, argv, self, true);
}
parser() click to toggle source
# File lib/oj/json.rb, line 63
def self.parser()
  @@parser
end
parser=(p) click to toggle source
# File lib/oj/json.rb, line 59
def self.parser=(p)
  @@parser = p
end
pretty_generate(obj, opts=nil) click to toggle source

Same as generate() but with different defaults for the spacing options. @see generate

Return [String] the generated JSON.

VALUE
oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
    struct _options     copts = oj_default_options;
    VALUE               rargs[2];
    volatile VALUE      h;

    // Some (all?) json gem to_json methods need a State instance and not just
    // a Hash. I haven't dug deep enough to find out why but using a State
    // instance and not a Hash gives the desired behavior.
    *rargs = *argv;
    if (1 == argc) {
        h = rb_hash_new();
    } else {
        h = argv[1];
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_indent_sym)) {
        rb_hash_aset(h, oj_indent_sym, rb_str_new2("  "));
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_space_before_sym)) {
        rb_hash_aset(h, oj_space_before_sym, rb_str_new2(""));
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_space_sym)) {
        rb_hash_aset(h, oj_space_sym, rb_str_new2(" "));
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_object_nl_sym)) {
        rb_hash_aset(h, oj_object_nl_sym, rb_str_new2("\n"));
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_array_nl_sym)) {
        rb_hash_aset(h, oj_array_nl_sym, rb_str_new2("\n"));
    }
    rargs[1] = rb_funcall(state_class, oj_new_id, 1, h);

    copts.str_rx.head = NULL;
    copts.str_rx.tail = NULL;
    strcpy(copts.dump_opts.indent_str, "  ");
    copts.dump_opts.indent_size = (uint8_t)strlen(copts.dump_opts.indent_str);
    strcpy(copts.dump_opts.before_sep, "");
    copts.dump_opts.before_size = (uint8_t)strlen(copts.dump_opts.before_sep);
    strcpy(copts.dump_opts.after_sep, " ");
    copts.dump_opts.after_size = (uint8_t)strlen(copts.dump_opts.after_sep);
    strcpy(copts.dump_opts.hash_nl, "\n");
    copts.dump_opts.hash_size = (uint8_t)strlen(copts.dump_opts.hash_nl);
    strcpy(copts.dump_opts.array_nl, "\n");
    copts.dump_opts.array_size = (uint8_t)strlen(copts.dump_opts.array_nl);
    copts.dump_opts.use = true;

    return mimic_generate_core(2, rargs, &copts);
}
pretty_generate(obj, opts=nil) click to toggle source

Same as generate() but with different defaults for the spacing options. @see generate

Return [String] the generated JSON.

VALUE
oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
    struct _options     copts = oj_default_options;
    VALUE               rargs[2];
    volatile VALUE      h;

    // Some (all?) json gem to_json methods need a State instance and not just
    // a Hash. I haven't dug deep enough to find out why but using a State
    // instance and not a Hash gives the desired behavior.
    *rargs = *argv;
    if (1 == argc) {
        h = rb_hash_new();
    } else {
        h = argv[1];
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_indent_sym)) {
        rb_hash_aset(h, oj_indent_sym, rb_str_new2("  "));
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_space_before_sym)) {
        rb_hash_aset(h, oj_space_before_sym, rb_str_new2(""));
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_space_sym)) {
        rb_hash_aset(h, oj_space_sym, rb_str_new2(" "));
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_object_nl_sym)) {
        rb_hash_aset(h, oj_object_nl_sym, rb_str_new2("\n"));
    }
    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_array_nl_sym)) {
        rb_hash_aset(h, oj_array_nl_sym, rb_str_new2("\n"));
    }
    rargs[1] = rb_funcall(state_class, oj_new_id, 1, h);

    copts.str_rx.head = NULL;
    copts.str_rx.tail = NULL;
    strcpy(copts.dump_opts.indent_str, "  ");
    copts.dump_opts.indent_size = (uint8_t)strlen(copts.dump_opts.indent_str);
    strcpy(copts.dump_opts.before_sep, "");
    copts.dump_opts.before_size = (uint8_t)strlen(copts.dump_opts.before_sep);
    strcpy(copts.dump_opts.after_sep, " ");
    copts.dump_opts.after_size = (uint8_t)strlen(copts.dump_opts.after_sep);
    strcpy(copts.dump_opts.hash_nl, "\n");
    copts.dump_opts.hash_size = (uint8_t)strlen(copts.dump_opts.hash_nl);
    strcpy(copts.dump_opts.array_nl, "\n");
    copts.dump_opts.array_size = (uint8_t)strlen(copts.dump_opts.array_nl);
    copts.dump_opts.use = true;

    return mimic_generate_core(2, rargs, &copts);
}
recurse_proc(obj, &proc) click to toggle source

Yields to the proc for every element in the obj recursively.

  • obj [Hash|Array] object to walk

  • proc [Proc] to yield to on each element

static VALUE
mimic_recurse_proc(VALUE self, VALUE obj) {
    rb_need_block();
    mimic_walk(Qnil, obj, Qnil);

    return Qnil;
}
restore(source, proc=nil) click to toggle source

Loads a Ruby Object from a JSON source that can be either a String or an IO. If Proc is given or a block is providedit is called with each nested element of the loaded Object.

  • source [String|IO] JSON source

  • proc [Proc] to yield to on each element or nil

Returns [Object] the decoded Object.

static VALUE
mimic_load(int argc, VALUE *argv, VALUE self) {
    VALUE       obj;
    VALUE       p = Qnil;

    obj = oj_compat_load(argc, argv, self);
    if (2 <= argc) {
        if (rb_cProc == rb_obj_class(argv[1])) {
            p = argv[1];
        } else if (3 <= argc) {
            if (rb_cProc == rb_obj_class(argv[2])) {
                p = argv[2];
            }
        }
    }
    mimic_walk(Qnil, obj, p);

    return obj;
}
state() click to toggle source

Returns [JSON::State] the JSON::State class.

static VALUE
mimic_state(VALUE self) {
    return state_class;
}
generate(obj, opts=nil) click to toggle source

Encode obj as a JSON String. The obj argument must be a Hash, Array, or respond to to_h or to_json. Options other than those listed such as :allow_nan or :max_nesting are ignored.

  • obj [Object|Hash|Array] object to convert to a JSON String

  • opts [Hash] options

    • :indent [String] String to use for indentation.

    • :space [String] String placed after a , or : delimiter

    • :space_before [String] String placed before a : delimiter

    • :object_nl [String] String placed after a JSON object

    • :array_nl [String] String placed after a JSON array

    • :ascii_only [Boolean] if not nil or false then use only ascii characters in the output. Note ::generate does support this even if it is not documented.

Returns [String] generated JSON.

VALUE
oj_mimic_generate(int argc, VALUE *argv, VALUE self) {
    struct _options     copts = oj_default_options;

    copts.str_rx.head = NULL;
    copts.str_rx.tail = NULL;

    return mimic_generate_core(argc, argv, &copts);
}