oj 2.0.14 → 2.1.0

data/ext/oj/strict.c

@@ -0,0 +1,166 @@
+/* strict.c
+ * Copyright (c) 2012, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "oj.h"
+#include "err.h"
+#include "parse.h"
+
+// Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
+#define OJ_INFINITY (1.0/0.0)
+
+static void
+noop_end(struct _ParseInfo *pi) {
+}
+
+static void
+add_value(ParseInfo pi, VALUE val) {
+    pi->stack.head->val = val;
+}
+
+static void
+add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    VALUE	rstr = rb_str_new(str, len);
+
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rstr, oj_utf8_encoding);
+#endif
+    pi->stack.head->val = rstr;
+}
+
+static void
+add_num(ParseInfo pi, NumInfo ni) {
+    pi->stack.head->val = oj_num_as_value(ni);
+}
+
+static VALUE
+start_hash(ParseInfo pi) {
+    return rb_hash_new();
+}
+
+static VALUE
+hash_key(ParseInfo pi, const char *key, size_t klen) {
+    VALUE	rkey = rb_str_new(key, klen);
+
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rkey, oj_utf8_encoding);
+#endif
+    if (Yes == pi->options.sym_key) {
+	rkey = rb_str_intern(rkey);
+    }
+    return rkey;
+}
+
+static void
+hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
+    VALUE	rstr = rb_str_new(str, len);
+
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rstr, oj_utf8_encoding);
+#endif
+    rb_hash_aset(stack_peek(&pi->stack)->val, hash_key(pi, key, klen), rstr);
+}
+
+static void
+hash_set_num(struct _ParseInfo *pi, const char *key, size_t klen, NumInfo ni) {
+    rb_hash_aset(stack_peek(&pi->stack)->val, hash_key(pi, key, klen), oj_num_as_value(ni));
+}
+
+static void
+hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
+    rb_hash_aset(stack_peek(&pi->stack)->val, hash_key(pi, key, klen), value);
+}
+
+static VALUE
+start_array(ParseInfo pi) {
+    return rb_ary_new();
+}
+
+static void
+array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    VALUE	rstr = rb_str_new(str, len);
+
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rstr, oj_utf8_encoding);
+#endif
+    rb_ary_push(stack_peek(&pi->stack)->val, rstr);
+}
+
+static void
+array_append_num(ParseInfo pi, NumInfo ni) {
+    rb_ary_push(stack_peek(&pi->stack)->val, oj_num_as_value(ni));
+}
+
+static void
+array_append_value(ParseInfo pi, VALUE value) {
+    rb_ary_push(stack_peek(&pi->stack)->val, value);
+}
+
+void
+oj_set_strict_callbacks(ParseInfo pi) {
+    pi->start_hash = start_hash;
+    pi->end_hash = noop_end;
+    pi->hash_set_cstr = hash_set_cstr;
+    pi->hash_set_num = hash_set_num;
+    pi->hash_set_value = hash_set_value;
+    pi->start_array = start_array;
+    pi->end_array = noop_end;
+    pi->array_append_cstr = array_append_cstr;
+    pi->array_append_num = array_append_num;
+    pi->array_append_value = array_append_value;
+    pi->add_cstr = add_cstr;
+    pi->add_num = add_num;
+    pi->add_value = add_value;
+    pi->expect_value = 1;
+}
+
+VALUE
+oj_strict_parse(int argc, VALUE *argv, VALUE self) {
+    struct _ParseInfo	pi;
+
+    pi.options = oj_default_options;
+    oj_set_strict_callbacks(&pi);
+
+    return oj_pi_parse(argc, argv, &pi, 0);
+}
+
+VALUE
+oj_strict_parse_cstr(int argc, VALUE *argv, char *json) {
+    struct _ParseInfo	pi;
+
+    pi.options = oj_default_options;
+    oj_set_strict_callbacks(&pi);
+
+    return oj_pi_parse(argc, argv, &pi, json);
+}

data/ext/oj/val_stack.c

@@ -0,0 +1,48 @@
+/* val_stack.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "val_stack.h"
+
+const char*
+oj_stack_next_string(ValNext n) {
+    switch (n) {
+    case NEXT_ARRAY_NEW:	return "array element or close";
+    case NEXT_ARRAY_ELEMENT:	return "array element";
+    case NEXT_ARRAY_COMMA:	return "comma";
+    case NEXT_HASH_NEW:		return "hash pair or close";
+    case NEXT_HASH_KEY:		return "hash key";
+    case NEXT_HASH_COLON:	return "colon";
+    case NEXT_HASH_VALUE:	return "hash value";
+    case NEXT_HASH_COMMA:	return "comma";
+    case NEXT_NONE:		break;
+    default:			break;
+    }
+    return "nothing";
+}

data/ext/oj/val_stack.h

@@ -0,0 +1,167 @@
+/* val_stack.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __OJ_VAL_STACK_H__
+#define __OJ_VAL_STACK_H__
+
+#include "ruby.h"
+#include "odd.h"
+
+#define STACK_INC	32
+
+typedef enum {
+    NEXT_NONE		= 0,
+    NEXT_ARRAY_NEW	= 'a',
+    NEXT_ARRAY_ELEMENT	= 'e',
+    NEXT_ARRAY_COMMA	= ',',
+    NEXT_HASH_NEW	= 'h',
+    NEXT_HASH_KEY	= 'k',
+    NEXT_HASH_COLON	= ':',
+    NEXT_HASH_VALUE	= 'v',
+    NEXT_HASH_COMMA	= 'n',
+} ValNext;
+
+typedef struct _Val {
+    VALUE	val;
+    const char	*key;
+    union {
+	const char	*classname;
+	OddArgs		odd_args;
+    };
+    uint16_t	klen;
+    uint16_t	clen;
+    char	next; // ValNext
+    char	k1;   // first original character in the key
+} *Val;
+
+typedef struct _ValStack {
+    struct _Val	base[STACK_INC];
+    Val		head;	// current stack
+    Val		end;	// stack end
+    Val		tail;	// pointer to one past last element name on stack
+} *ValStack;
+
+inline static void
+stack_init(ValStack stack) {
+    stack->head = stack->base;
+    stack->end = stack->base + sizeof(stack->base) / sizeof(struct _Val);
+    stack->tail = stack->head;
+    stack->head->val = Qundef;
+    stack->head->key = 0;
+    stack->head->classname = 0;
+    stack->head->klen = 0;
+    stack->head->clen = 0;
+    stack->head->next = NEXT_NONE;
+    //stack->head->type = TYPE_NONE;
+}
+
+inline static int
+stack_empty(ValStack stack) {
+    return (stack->head == stack->tail);
+}
+
+inline static void
+stack_cleanup(ValStack stack) {
+    if (stack->base != stack->head) {
+        xfree(stack->head);
+    }
+}
+
+inline static void
+stack_push(ValStack stack, VALUE val, ValNext next) {
+    if (stack->end <= stack->tail) {
+	size_t	len = stack->end - stack->head;
+	size_t	toff = stack->tail - stack->head;
+
+	if (stack->base == stack->head) {
+	    stack->head = ALLOC_N(struct _Val, len + STACK_INC);
+	    memcpy(stack->head, stack->base, sizeof(struct _Val) * len);
+	} else {
+	    REALLOC_N(stack->head, struct _Val, len + STACK_INC);
+	}
+	stack->tail = stack->head + toff;
+	stack->end = stack->head + len + STACK_INC;
+    }
+    stack->tail->val = val;
+    stack->tail->next = next;
+    stack->tail->classname = 0;
+    stack->tail->key = 0;
+    stack->tail->clen = 0;
+    stack->tail->klen = 0;
+    //stack->tail->type = TYPE_NONE;
+    stack->tail++;
+}
+
+inline static size_t
+stack_size(ValStack stack) {
+    return stack->tail - stack->head;
+}
+
+inline static Val
+stack_peek(ValStack stack) {
+    if (stack->head < stack->tail) {
+	return stack->tail - 1;
+    }
+    return 0;
+}
+
+inline static Val
+stack_peek_up(ValStack stack) {
+    if (stack->head < stack->tail - 1) {
+	return stack->tail - 2;
+    }
+    return 0;
+}
+
+inline static Val
+stack_prev(ValStack stack) {
+    return stack->tail;
+}
+
+inline static VALUE
+stack_head_val(ValStack stack) {
+    if (Qundef != stack->head->val) {
+	return stack->head->val;
+    }
+    return Qnil;
+}
+
+inline static Val
+stack_pop(ValStack stack) {
+    if (stack->head < stack->tail) {
+	stack->tail--;
+	return stack->tail;
+    }
+    return 0;
+}
+
+extern const char*	oj_stack_next_string(ValNext n);
+
+#endif /* __OJ_VAL_STACK_H__ */

data/lib/oj.rb

@@ -29,5 +29,6 @@ require 'oj/bag'
 require 'oj/error'
 require 'oj/mimic'
 require 'oj/saj'
+require 'oj/schandler'
 
 require 'oj/oj' # C extension

data/lib/oj/saj.rb

@@ -1,7 +1,9 @@
 module Oj
-  # A SAX style parse handler for JSON hence the acronym SAJ for Simple API for JSON. The Oj::Saj handler class should be subclassed
-  # and then used with the Oj.saj_parse() method. The Saj methods will then be
-  # called as the file is parsed.
+  # A SAX style parse handler for JSON hence the acronym SAJ for Simple API for
+  # JSON. The Oj::Saj handler class should be subclassed and then used with
+  # the Oj.sajkey_parse() method. The Saj methods will then be called as the
+  # file is parsed.
+  #
   # @example
   # 
   #  require 'oj'
@@ -21,8 +23,9 @@ module Oj
   #    Oj.saj_parse(cnt, f)
   #  end
   #
-  # To make the desired methods active while parsing the desired method should be made public in the subclasses. If the
-  # methods remain private they will not be called during parsing.
+  # To make the desired methods active while parsing the desired method should
+  # be made public in the subclasses. If the methods remain private they will
+  # not be called during parsing.
   #
   #    def hash_start(key); end
   #    def hash_end(key); end
@@ -36,9 +39,9 @@ module Oj
     def initialize()
     end
 
-    # To make the desired methods active while parsing the desired method
-    # should be made public in the subclasses. If the methods remain private
-    # they will not be called during parsing.
+    # To make the desired methods active while parsing the desired method should
+    # be made public in the subclasses. If the methods remain private they will
+    # not be called during parsing.
     private
 
     def hash_start(key)

data/lib/oj/schandler.rb

@@ -0,0 +1,70 @@
+module Oj
+  # A Simple Callback Parser (SCP) for JSON. The Oj::ScHandler class should be
+  # subclassed and then used with the Oj.sc_parse() method. The Scp methods will
+  # then be called as the file is parsed. The handler does not have to be a
+  # subclass of the ScHandler class as long as it responds to the desired
+  # methods.
+  #
+  # @example
+  # 
+  #  require 'oj'
+  #
+  #  class MyHandler < ::Oj::ScHandler
+  #    def initialize()
+  #      @hash_cnt = 0
+  #    end
+  #
+  #    def start_hash()
+  #      @hash_cnt += 1
+  #    end
+  #  end
+  #
+  #  cnt = MyHandler.new()
+  #  File.open('any.json', 'r') do |f|
+  #    Oj.sc_parse(cnt, f)
+  #  end
+  #
+  # To make the desired methods active while parsing the desired method should
+  # be made public in the subclasses. If the methods remain private they will
+  # not be called during parsing.
+  #
+  #    def hash_start(); end
+  #    def hash_end(); end
+  #    def array_start(); end
+  #    def array_end(); end
+  #    def add_value(value); end
+  #    def error(message, line, column); end
+  #
+  class ScHandler
+    # Create a new instance of the ScHandler class.
+    def initialize()
+    end
+
+    # To make the desired methods active while parsing the desired method should
+    # be made public in the subclasses. If the methods remain private they will
+    # not be called during parsing.
+    private
+
+    def hash_start()
+    end
+
+    def hash_end()
+    end
+
+    def array_start()
+    end
+
+    def array_end()
+    end
+
+    def add_value(value)
+    end
+    
+    def hash_set(h, key, value)
+    end
+    
+    def array_append(a, value)
+    end
+    
+  end # ScHandler
+end # Oj