oj 2.0.0 → 3.0.0

data/ext/oj/val_stack.h

@@ -0,0 +1,188 @@
+/* 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"
+#include <stdint.h>
+#if USE_PTHREAD_MUTEX
+#include <pthread.h>
+#endif
+
+#define STACK_INC	64
+
+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 {
+    volatile VALUE	val;
+    const char		*key;
+    char		karray[32];
+    volatile VALUE	key_val;
+    union {
+	struct {
+	    const char	*classname;
+	    VALUE	clas;
+	};
+	OddArgs		odd_args;
+    };
+    uint16_t		klen;
+    uint16_t		clen;
+    char		next; // ValNext
+    char		k1;   // first original character in the key
+    char		kalloc;
+} *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
+#if USE_PTHREAD_MUTEX
+    pthread_mutex_t	mutex;
+#elif USE_RB_MUTEX
+    VALUE		mutex;
+#endif
+
+} *ValStack;
+
+extern VALUE	oj_stack_init(ValStack stack);
+
+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);
+	stack->head = NULL;
+    }
+}
+
+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;
+	Val	head = stack->head;
+
+	// A realloc can trigger a GC so make sure it happens outside the lock
+	// but lock before changing pointers.
+	if (stack->base == stack->head) {
+	    head = ALLOC_N(struct _Val, len + STACK_INC);
+	    memcpy(head, stack->base, sizeof(struct _Val) * len);
+	} else {
+	    REALLOC_N(head, struct _Val, len + STACK_INC);
+	}
+#if USE_PTHREAD_MUTEX
+	pthread_mutex_lock(&stack->mutex);
+#elif USE_RB_MUTEX
+	rb_mutex_lock(stack->mutex);
+#endif
+	stack->head = head;
+	stack->tail = stack->head + toff;
+	stack->end = stack->head + len + STACK_INC;
+#if USE_PTHREAD_MUTEX
+	pthread_mutex_unlock(&stack->mutex);
+#elif USE_RB_MUTEX
+	rb_mutex_unlock(stack->mutex);
+#endif
+    }
+    stack->tail->val = val;
+    stack->tail->next = next;
+    stack->tail->classname = NULL;
+    stack->tail->clas = Qundef;
+    stack->tail->key = 0;
+    stack->tail->key_val = Qundef;
+    stack->tail->clen = 0;
+    stack->tail->klen = 0;
+    stack->tail->kalloc = 0;
+    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/active_support_helper.rb

@@ -0,0 +1,41 @@
+
+require 'active_support/time'
+
+module Oj
+
+  # Exists only to handle the ActiveSupport::TimeWithZone.
+  class ActiveSupportHelper
+
+    def self.createTimeWithZone(utc, zone)
+      ActiveSupport::TimeWithZone.new(utc - utc.gmt_offset, ActiveSupport::TimeZone[zone])
+    end
+  end
+
+end
+
+Oj.register_odd(ActiveSupport::TimeWithZone, Oj::ActiveSupportHelper, :createTimeWithZone, :utc, 'time_zone.name')
+
+# This is a hack to work around an oddness with DateTime and the ActiveSupport
+# that causes a hang when some methods are called from C. Hour, min(ute),
+# sec(ond) and other methods are special but they can be called from C until
+# activesupport/time is required. After that they can not be even though
+# resond_to? returns true. By defining methods to call super the problem goes
+# away. There is obviously some magic going on under the covers that I don't
+# understand.
+class DateTime
+  def hour()
+    super
+  end
+  def min()
+    super
+  end
+  def sec()
+    super
+  end
+  def sec_fraction()
+    super
+  end
+  def offset()
+    super
+  end
+end

data/lib/oj/bag.rb

@@ -13,7 +13,7 @@ module Oj
     # value. This is intended for testing purposes only.
     # @example Oj::Bag.new(:@x => 42, :@y => 57)
     # @param [Hash] args instance variable symbols and their values
-    def initialize(args={ })
+    def initialize(args = {})
       args.each do |k,v|
         self.instance_variable_set(k, v)
       end
@@ -25,8 +25,7 @@ module Oj
     #                   variable reader, otherwise false.
     def respond_to?(m)
       return true if super
-      at_m = ('@' + m.to_s).to_sym
-      instance_variables.include?(at_m)
+      instance_variables.include?(:"@#{m}")
     end
 
     # Handles requests for variable values. Others cause an Exception to be
@@ -37,7 +36,7 @@ module Oj
     # @raise [NoMethodError] if the instance variable is not defined.
     def method_missing(m, *args, &block)
       raise ArgumentError.new("wrong number of arguments (#{args.size} for 0) to method #{m}") unless args.nil? or args.empty?
-      at_m = ('@' + m.to_s).to_sym
+      at_m = :"@#{m}"
       raise NoMethodError.new("undefined method #{m}", m) unless instance_variable_defined?(at_m)
       instance_variable_get(at_m)
     end
@@ -50,13 +49,10 @@ module Oj
       ova = other.instance_variables
       iv = instance_variables
       return false if ova.size != iv.size
-      iv.each do |vid|
-        return false if instance_variable_get(vid) != other.instance_variable_get(vid)
-      end
-      true
+      iv.all? { |vid| instance_variable_get(vid) != other.instance_variable_get(vid) }
     end
     alias == eql?
-    
+
     # Define a new class based on the Oj::Bag class. This is used internally in
     # the Oj module and is available to service wrappers that receive XML
     # requests that include Objects of Classes not defined in the storage
@@ -66,7 +62,7 @@ module Oj
     # @raise [NameError] if the classname is invalid.
     def self.define_class(classname)
       classname = classname.to_s unless classname.is_a?(String)
-      tokens = classname.split('::').map { |n| n.to_sym }
+      tokens = classname.split('::').map(&:to_sym)
       raise NameError.new("Invalid classname '#{classname}") if tokens.empty?
       m = Object
       tokens[0..-2].each do |sym|

data/lib/oj/easy_hash.rb

@@ -0,0 +1,52 @@
+
+module Oj
+
+  # A Hash subclass that normalizes the hash keys to allow lookup by the
+  # key.to_s or key.to_sym. It also supports looking up hash values by methods
+  # that match the keys.
+  class EasyHash < Hash
+
+    # Initializes the instance to an empty Hash.
+    def initialize()
+    end
+
+    # Replaces the Object.respond_to?() method.
+    # @param [Symbol] m method symbol
+    # @return [Boolean] true for any method that matches an instance
+    #                   variable reader, otherwise false.
+    def respond_to?(m)
+      return true if super
+      return true if has_key?(key)
+      return true if has_key?(key.to_s)
+      has_key?(key.to_sym)
+    end
+
+    def [](key)
+      return fetch(key, nil) if has_key?(key)
+      return fetch(key.to_s, nil) if has_key?(key.to_s)
+      fetch(key.to_sym, nil)
+    end
+
+    # Handles requests for Hash values. Others cause an Exception to be raised.
+    # @param [Symbol|String] m method symbol
+    # @return [Boolean] the value of the specified instance variable.
+    # @raise [ArgumentError] if an argument is given. Zero arguments expected.
+    # @raise [NoMethodError] if the instance variable is not defined.
+    def method_missing(m, *args, &block)
+      if m.to_s.end_with?('=')
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 1 with #{m}) to method #{m}") if args.nil? or 1 != args.length
+        m = m[0..-2]
+        return store(m.to_s, args[0]) if has_key?(m.to_s)
+        return store(m.to_sym, args[0]) if has_key?(m.to_sym)
+        return store(m, args[0])
+      else
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0 with #{m}) to method #{m}") unless args.nil? or args.empty?
+        return fetch(m, nil) if has_key?(m)
+        return fetch(m.to_s, nil) if has_key?(m.to_s)
+        return fetch(m.to_sym, nil) if has_key?(m.to_sym)
+      end
+      raise NoMethodError.new("undefined method #{m}", m)
+    end
+
+  end # EasyHash
+end # Oj

data/lib/oj/json.rb

@@ -0,0 +1,172 @@
+
+require 'ostruct'
+require 'oj/state'
+
+module JSON
+  NaN = 0.0/0.0 unless defined?(::JSON::NaN)
+  Infinity = 1.0/0.0 unless defined?(::JSON::Infinity)
+  MinusInfinity = -1.0/0.0 unless defined?(::JSON::MinusInfinity)
+  # Taken from the unit test. Note that items like check_circular? are not
+  # present.
+  PRETTY_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                              :allow_nan             => false,
+                                              :array_nl              => "\n",
+                                              :ascii_only            => false,
+                                              :buffer_initial_length => 1024,
+                                              :depth                 => 0,
+                                              :indent                => "  ",
+                                              :max_nesting           => 100,
+                                              :object_nl             => "\n",
+                                              :space                 => " ",
+                                              :space_before          => "",
+                                            }) unless defined?(::JSON::PRETTY_STATE_PROTOTYPE)
+  SAFE_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                            :allow_nan             => false,
+                                            :array_nl              => "",
+                                            :ascii_only            => false,
+                                            :buffer_initial_length => 1024,
+                                            :depth                 => 0,
+                                            :indent                => "",
+                                            :max_nesting           => 100,
+                                            :object_nl             => "",
+                                            :space                 => "",
+                                            :space_before          => "",
+                                            }) unless defined?(::JSON::SAFE_STATE_PROTOTYPE)
+  FAST_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                            :allow_nan             => false,
+                                            :array_nl              => "",
+                                            :ascii_only            => false,
+                                            :buffer_initial_length => 1024,
+                                            :depth                 => 0,
+                                            :indent                => "",
+                                            :max_nesting           => 0,
+                                            :object_nl             => "",
+                                            :space                 => "",
+                                            :space_before          => "",
+                                            }) unless defined?(::JSON::FAST_STATE_PROTOTYPE)
+
+  def self.dump_default_options
+    Oj::MimicDumpOption.new
+  end
+
+  def self.dump_default_options=(h)
+    m = Oj::MimicDumpOption.new
+    h.each do |k,v|
+      m[k] = v
+    end
+  end
+
+  def self.parser=(p)
+    @@parser = p
+  end
+
+  def self.parser()
+    @@parser
+  end
+
+  def self.generator=(g)
+    @@generator = g
+  end
+
+  def self.generator()
+    @@generator
+  end
+
+  module Ext
+    class Parser
+      def initialize(src)
+        raise TypeError.new("already initialized") unless @source.nil?
+        @source = src
+      end
+
+      def source()
+        raise TypeError.new("already initialized") if @source.nil?
+        @source
+      end
+      
+      def parse()
+        raise TypeError.new("already initialized") if @source.nil?
+        JSON.parse(@source)
+      end
+      
+    end # Parser
+  end # Ext
+  
+  State = ::JSON::Ext::Generator::State
+
+  Parser = ::JSON::Ext::Parser
+  self.parser = ::JSON::Ext::Parser
+  self.generator = ::JSON::Ext::Generator
+
+  # Taken directly from the json gem. Shamelessly copied. It is similar in
+  # some ways to the Oj::Bag class or the Oj::EasyHash class.
+  class GenericObject < OpenStruct
+    class << self
+      alias [] new
+      
+      def json_creatable?
+        @json_creatable
+      end
+
+      attr_writer :json_creatable
+
+      def json_create(data)
+        data = data.dup
+        data.delete JSON.create_id
+        self[data]
+      end
+
+      def from_hash(object)
+        case
+        when object.respond_to?(:to_hash)
+          result = new
+          object.to_hash.each do |key, value|
+            result[key] = from_hash(value)
+          end
+          result
+        when object.respond_to?(:to_ary)
+          object.to_ary.map { |a| from_hash(a) }
+        else
+          object
+        end
+      end
+
+      def load(source, proc = nil, opts = {})
+        result = ::JSON.load(source, proc, opts.merge(:object_class => self))
+        result.nil? ? new : result
+      end
+
+      def dump(obj, *args)
+        ::JSON.dump(obj, *args)
+      end
+
+    end # self
+
+    self.json_creatable = false
+
+    def to_hash
+      table
+    end
+
+    def [](name)
+      __send__(name)
+    end unless method_defined?(:[])
+
+    def []=(name, value)
+      __send__("#{name}=", value)
+    end unless method_defined?(:[]=)
+
+    def |(other)
+      self.class[other.to_hash.merge(to_hash)]
+    end
+
+    def as_json(*)
+      { JSON.create_id => self.class.name }.merge to_hash
+    end
+
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+  end
+  
+end # JSON