Module: Oj::Rails

Defined in:
ext/oj/rails.c,
ext/oj/rails.c

Overview

Module that provides rails and active support compatibility.

Defined Under Namespace

Classes: Encoder

Class Method Summary collapse

Class Method Details

.deoptimize(*classes) ⇒ Object

Turn off Oj rails optimization on the specified classes.

  • classes [Class] a list of classes to deoptimize


959
960
961
962
963
964
 
# File 'ext/oj/rails.c', line 959

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

    return Qnil;
}

.encode(obj, opts = nil) ⇒ Object

Encode obj as a JSON String.

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

Returns [String]



1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
 
# File 'ext/oj/rails.c', line 1115

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 ⇒ Object

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.



920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
 
# File 'ext/oj/rails.c', line 920

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);
    // Setting the default mode breaks the prmoise in the docs not to.
    // oj_default_options.mode = RailsMode;

    return Qnil;
}

.optimize(*classes) ⇒ Object

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


907
908
909
910
911
912
 
# File 'ext/oj/rails.c', line 907

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

    return Qnil;
}

.optimized?(clas) ⇒ Boolean

Returns true if the specified Class is being optimized.

Returns:

  • (Boolean) 


991
992
993
994
995
996
997
998
 
# File 'ext/oj/rails.c', line 991

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 ⇒ Object

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



1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
 
# File 'ext/oj/rails.c', line 1228

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

    rb_global_variable(&oj_json_parser_error_class);
    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 ⇒ Object

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.



1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
 
# File 'ext/oj/rails.c', line 1170

static VALUE rails_set_encoder(VALUE self) {
    VALUE active;
    VALUE json;
    VALUE encoding;
    VALUE pv;
    VALUE verbose;
    VALUE enc = resolve_classpath("ActiveSupport::JSON::Encoding");

    if (Qnil != enc) {
        escape_html = Qtrue == rb_iv_get(self, "@escape_html_entities_in_json");
        xml_time    = Qtrue == rb_iv_get(enc, "@use_standard_json_time_format");
    }
    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.");
    }
    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, "use_standard_json_time_format");
    rb_define_module_function(encoding, "use_standard_json_time_format", rails_use_standard_json_time_format_get, 0);

    pv          = rb_iv_get(encoding, "@escape_html_entities_in_json");
    escape_html = Qtrue == pv;
    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);
    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_get, 0);

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

    // Last, because ActiveSupport builds and caches encoders inside
    // json_encoder= and they should see the settings above already in the
    // defaults. escape_html and xml_time are read ahead of it for the same
    // reason.
    rb_funcall(active, rb_intern("json_encoder="), 1, encoder_class);

    return Qnil;
}