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 collapse
-
.new(mode = nil) ⇒ Object
Creates a new Parser with the specified mode.
-
.saj ⇒ Object
Returns the default SAJ parser.
-
.usual ⇒ Object
Returns the default usual parser.
-
.validate ⇒ Object
Returns the default validate parser.
Instance Method Summary collapse
-
#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= sets the value of the cache_keys flag.
-
cache_keys returns the value of the cache_keys flag.
-
cache_strings= sets the value of the cache_strings to an positive integer less than 35. Strings shorter than
-
that length are cached.
- _cache_strings_ returns the value of the _cache_strings_ integer value.
- _handler=_ sets the SAJ handler
- _handler_ returns the SAJ handler
-
:usual
-
cache_keys= sets the value of the cache_keys flag.
-
cache_keys returns the value of the cache_keys flag.
-
cache_strings= sets the value of the cache_strings to a positive integer less than 35. Strings shorter than
-
that length are cached.
- _cache_strings_ returns the value of the _cache_strings_ integer value.
- _cache_expunge=_ sets the value of the _cache_expunge_ where 0 never expunges, 1 expunges slowly, 2 expunges
faster, and 3 or higher expunges agressively.
- _cache_expunge_ returns the value of the _cache_expunge_ integer value.
- _capacity=_ sets the capacity of the parser. The parser grows automatically but can be updated directly with this
call.
- _capacity_ returns the current capacity of the parser's internal stack.
- _create_id_ returns the value _create_id_ or _nil_ if there is no _create_id_.
- _create_id=_ sets the value _create_id_ or if _nil_ unsets it. 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=_ sets the approach to how decimals are parser. 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.
- _decimal_ returns the value of the decimal conversion option which can be :auto (default), :ruby, :float, or
:bigdecimal.
- _ignore_json_create_ returns the value of the _ignore_json_create_ flag.
- _ignore_json_create=_ sets the value of the _ignore_json_create_ flag. When set the class json_create method is
ignored on parsing in favor of creating an instance and populating directly.
- _missing_class_ return the value of the _missing_class_ indicator.
- _missing_class=_ sets the value of the _missing_class_ flag. 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=_ sets the _omit_null_ flag. If true then null values in a map or object are omitted from the
resulting Hash or Object.
- _omit_null_ returns the value of the _omit_null_ flag.
- _symbol_keys=_ sets the flag that indicates Hash keys should be parsed to Symbols versus Strings.
- _symbol_keys_ returns the value of the _symbol_keys_ flag.
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 |
# File 'ext/oj/parser.c', line 1090
static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
ojParser p = (ojParser)DATA_PTR(self);
const char *key = NULL;
volatile VALUE rkey = *argv;
volatile VALUE rv = Qnil;
#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).
959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 |
# File 'ext/oj/parser.c', line 959
static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
ojParser p = OJ_R_ALLOC(struct _ojParser);
#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;
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 Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
}
|
.saj ⇒ Object
Returns the default SAJ parser. Note the default SAJ parser can not be used concurrently in more than one thread.
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 |
# File 'ext/oj/parser.c', line 1274
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 = Data_Wrap_Struct(parser_class, parser_mark, parser_free, 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.
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 |
# File 'ext/oj/parser.c', line 1251
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 = Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
rb_gc_register_address(&usual_parser);
}
return usual_parser;
}
|
.validate ⇒ Object
Returns the default validate parser.
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 |
# File 'ext/oj/parser.c', line 1296
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 = Data_Wrap_Struct(parser_class, parser_mark, parser_free, 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.
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 |
# File 'ext/oj/parser.c', line 1174
static VALUE parser_file(VALUE self, VALUE filename) {
ojParser p = (ojParser)DATA_PTR(self);
const char *path;
int fd;
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);
return p->result(p);
}
#endif
byte buf[16385];
size_t size = sizeof(buf) - 1;
size_t rsize;
while (true) {
if (0 < (rsize = read(fd, buf, size))) {
buf[rsize] = '\0';
parse(p, buf);
}
if (rsize <= 0) {
if (0 != rsize) {
rb_raise(rb_eIOError, "error reading from %s", path);
}
break;
}
}
return p->result(p);
}
|
#just_one ⇒ Object
Returns the current state of the just_one [Boolean] option.
1221 1222 1223 1224 1225 |
# File 'ext/oj/parser.c', line 1221
static VALUE parser_just_one(VALUE self) {
ojParser p = (ojParser)DATA_PTR(self);
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.
1235 1236 1237 1238 1239 1240 1241 |
# File 'ext/oj/parser.c', line 1235
static VALUE parser_just_one_set(VALUE self, VALUE v) {
ojParser p = (ojParser)DATA_PTR(self);
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.
1157 1158 1159 1160 1161 1162 1163 1164 1165 |
# File 'ext/oj/parser.c', line 1157
static VALUE parser_load(VALUE self, VALUE reader) {
ojParser p = (ojParser)DATA_PTR(self);
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.
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 |
# File 'ext/oj/parser.c', line 1120
static VALUE parser_parse(VALUE self, VALUE json) {
ojParser p = (ojParser)DATA_PTR(self);
const byte *ptr = (const byte *)StringValuePtr(json);
parser_reset(p);
p->start(p);
parse(p, ptr);
return p->result(p);
}
|