module Oj::Rails - Oj

# module Oj::Rails

Module that provides rails and active support compatibility.

### Public Class Methods

deoptimize(*classes) click to toggle source

Turn off Oj rails optimization on the specified classes.

- classes [Class] a list of classes to deoptimize

    static VALUE
    rails_deoptimize(int argc, VALUE *argv, VALUE self) {
        optimize(argc, argv, &ropts, false);

        return Qnil;
    }

encode(obj) click to toggle source

- obj [Object] object to encode

Returns encoded object as a JSON string.

    static VALUE
    rails_encode(int argc, VALUE *argv, VALUE self) {
        if (1 > argc) {
            rb_raise(rb_eArgError, "wrong number of arguments (0 for 1).");
        }
        if (1 == argc) {
            return encode(*argv, NULL, &oj_default_options, 0, NULL);
        } else {
            return encode(*argv, NULL, &oj_default_options, argc - 1, argv + 1);
        }
    }

mimic_JSON() click to toggle source

Document-module: ::mimic_JSON

Sets the JSON method to use Oj similar to Oj.mimic_JSON except with the ActiveSupport monkey patches instead of the json gem monkey patches.

    VALUE
    rails_mimic_json(VALUE self) {
        VALUE       json;

        if (rb_const_defined_at(rb_cObject, rb_intern("JSON"))) {
            json = rb_const_get_at(rb_cObject, rb_intern("JSON"));
        } else {
            json = rb_define_module("JSON");
        }
        oj_mimic_json_methods(json);
        // TBD

        return Qnil;
    }

optimize(*classes) click to toggle source

Use Oj rails optimized routines to encode the specified classes. This ignores the as_json() method on the class and uses an internal encoding instead. Passing in no classes indicates all should use the optimized version of encoding for all previously optimized classes. Passing in the Object class set a global switch that will then use the optimized behavior for all classes.

- classes [Class] a list of classes to optimize

    static VALUE
    rails_optimize(int argc, VALUE *argv, VALUE self) {
        optimize(argc, argv, &ropts, true);

        return Qnil;
    }

optimized?(clas) click to toggle source

Returns true if the specified Class is being optimized.

    static VALUE
    rails_optimized(VALUE self, VALUE clas) {
        ROpt        ro = oj_rails_get_opt(&ropts, clas);

        if (NULL == ro) {
            return Qfalse;
        }
        return (ro->on) ? Qtrue : Qfalse;
    }

set_decoder() click to toggle source

Sets the JSON.parse function to be the Oj::parse function which is json gem compatible.

    static VALUE
    rails_set_decoder(VALUE self) {
        VALUE       json;
        VALUE       json_error;
        VALUE       verbose;

        if (rb_const_defined_at(rb_cObject, rb_intern("JSON"))) {
            json = rb_const_get_at(rb_cObject, rb_intern("JSON"));
        } else {
            json = rb_define_module("JSON");
        }
        if (rb_const_defined_at(json, rb_intern("JSONError"))) {
            json_error = rb_const_get(json, rb_intern("JSONError"));
        } else {
            json_error = rb_define_class_under(json, "JSONError", rb_eStandardError);
        }
        if (rb_const_defined_at(json, rb_intern("ParserError"))) {
            oj_json_parser_error_class = rb_const_get(json, rb_intern("ParserError"));
        } else {
            oj_json_parser_error_class = rb_define_class_under(json, "ParserError", json_error);
        }
        // rb_undef_method doesn't work for modules or maybe sometimes
        // doesn't. Anyway setting verbose should hide the warning.
        verbose = rb_gv_get("$VERBOSE");
        rb_gv_set("$VERBOSE", Qfalse);
        rb_undef_method(json, "parse");
        rb_define_module_function(json, "parse", oj_mimic_parse, -1);
        rb_gv_set("$VERBOSE", verbose);

        return Qnil;
    }

set_encoder() click to toggle source

Sets the ActiveSupport.encoder to Oj::Rails::Encoder and wraps some of the formatting globals used by ActiveSupport to allow the use of those globals in the Oj::Rails optimizations.

    static VALUE
    rails_set_encoder(VALUE self) {
        VALUE       active;
        VALUE       json;
        VALUE       encoding;
        VALUE       pv;
        VALUE       verbose;

        if (rb_const_defined_at(rb_cObject, rb_intern("ActiveSupport"))) {
            active = rb_const_get_at(rb_cObject, rb_intern("ActiveSupport"));
        } else {
            rb_raise(rb_eStandardError, "ActiveSupport not loaded.");
        }
        rb_funcall(active, rb_intern("json_encoder="), 1, encoder_class);

        json = rb_const_get_at(active, rb_intern("JSON"));
        encoding = rb_const_get_at(json, rb_intern("Encoding"));

        // rb_undef_method doesn't work for modules or maybe sometimes
        // doesn't. Anyway setting verbose should hide the warning.
        verbose = rb_gv_get("$VERBOSE");
        rb_gv_set("$VERBOSE", Qfalse);
        rb_undef_method(encoding, "use_standard_json_time_format=");
        rb_define_module_function(encoding, "use_standard_json_time_format=", rails_use_standard_json_time_format, 1);

        rb_undef_method(encoding, "escape_html_entities_in_json=");
        rb_define_module_function(encoding, "escape_html_entities_in_json=", rails_escape_html_entities_in_json, 1);

        pv = rb_iv_get(encoding, "@time_precision");
        oj_default_options.sec_prec = NUM2INT(pv);
        rb_undef_method(encoding, "time_precision=");
        rb_define_module_function(encoding, "time_precision=", rails_time_precision, 1);
        rb_gv_set("$VERBOSE", verbose);

        return Qnil;
    }