multi_json 0.0.5 → 1.0.0.rc

data/.gitignore

@@ -23,8 +23,12 @@ log
 *.gem
 .bundle
 pkg
+Gemfile.lock
 
 ## RCOV
 coverage.data
 
+## RUBINIUS
+*.rbc
+
 ## PROJECT::SPECIFIC

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx
+  - jruby

data/Gemfile

@@ -1,10 +1,7 @@
 source "http://rubygems.org"
 
-group :development, :test do
-  gem 'activesupport', '~> 3.0', :require => nil
-  gem 'json', '~> 1.4', :require => nil
-  gem 'json_pure', '~> 1.4', :require => nil
-  gem 'yajl-ruby', '~> 0.7', :require => nil
-end
-
 gemspec
+
+gem 'json',      '~> 1.4', :require => nil
+gem 'json_pure', '~> 1.4', :require => nil
+gem 'yajl-ruby', '~> 0.7', :require => nil, :platforms => :ruby

data/README.rdoc

@@ -3,20 +3,20 @@
 Lots of Ruby libraries utilize JSON parsing in some form, and everyone has their favorite JSON library. In order to best support multiple JSON parsers and libraries, <tt>multi_json</tt> is a general-purpose swappable JSON backend library. You use it like so:
 
     require 'multi_json'
-    
+
     MultiJson.engine = :yajl
     MultiJson.decode('{"abc":"def"}') # decoded using Yajl
-    
+
     MultiJson.engine = :json_gem
     MultiJson.engine = MultiJson::Engines::JsonGem # equivalent to previous line
     MultiJson.encode({:abc => 'def'}) # encoded using the JSON gem
-    
+
 The <tt>engine</tt> setter takes either a symbol or a class (to allow for custom JSON parsers) that responds to both <tt>.decode</tt> and <tt>.encode</tt> at the class level.
 
-MultiJSON tries to have intelligent defaulting. That is, if you have any of the supported engines already loaded, it will utilize them before attempting to load any. When loading, libraries are ordered by speed. First Yajl-Ruby, then the JSON gem, then ActiveSupport, then JSON pure.
+MultiJSON tries to have intelligent defaulting. That is, if you have any of the supported engines already loaded, it will utilize them before attempting to load any. When loading, libraries are ordered by speed. First Yajl-Ruby, then the JSON gem, then JSON pure. If no JSON library is available, MultiJSON falls back to a bundled version of <a href="https://github.com/kr/okjson">OkJson</a>.
 
 == Note on Patches/Pull Requests
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a
@@ -27,4 +27,4 @@ MultiJSON tries to have intelligent defaulting. That is, if you have any of the
 
 == Copyright
 
-Copyright (c) 2010 Michael Bleigh and Intridea, Inc. See LICENSE for details.
+Copyright (c) 2010 Michael Bleigh and Intridea, Inc. See LICENSE for details.

data/Rakefile

@@ -1,25 +1,14 @@
 require 'rubygems'
-require 'bundler'
-
-Bundler::GemHelper.install_tasks
+begin
+  require 'bundler'
+  Bundler::GemHelper.install_tasks
+rescue LoadError => e
+  puts "although not required, it's recommended that you use bundler during development"
+end
 
 require 'rspec/core/rake_task'
 desc "Run all examples"
-RSpec::Core::RakeTask.new(:spec) do |t|
-end
-
-task :cleanup_rcov_files do
-  rm_rf 'coverage.data'
-end
-
-namespace :spec do
-  desc "Run all examples using rcov"
-  RSpec::Core::RakeTask.new :rcov => :cleanup_rcov_files do |t|
-    t.rcov = true
-    t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
-    t.rcov_opts << %[--text-report --sort coverage --no-html --aggregate coverage.data]
-  end
-end
+RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 
@@ -30,3 +19,19 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task :cleanup_rcov_files do
+  rm_rf 'coverage.data'
+end
+
+begin
+  namespace :spec do
+    desc "Run all examples using rcov"
+    RSpec::Core::RakeTask.new :rcov => :cleanup_rcov_files do |t|
+      t.rcov = true
+      t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+      t.rcov_opts << %[--text-report --sort coverage --no-html --aggregate coverage.data]
+    end
+  end
+rescue LoadError
+end

data/lib/multi_json.rb

@@ -12,8 +12,8 @@ module MultiJson
   REQUIREMENT_MAP = [
     ["yajl", :yajl],
     ["json", :json_gem],
-    ["active_support", :active_support],
-    ["json/pure", :json_pure]
+    ["json/pure", :json_pure],
+    ["okjson", :okjson]
   ]
 
   # The default engine based on what you currently
@@ -23,7 +23,6 @@ module MultiJson
   def default_engine
     return :yajl if defined?(::Yajl)
     return :json_gem if defined?(::JSON)
-    return :active_support if defined?(::ActiveSupport::JSON)
 
     REQUIREMENT_MAP.each do |(library, engine)|
       begin
@@ -40,7 +39,7 @@ module MultiJson
   #
   # * <tt>:json_gem</tt>
   # * <tt>:json_pure</tt>
-  # * <tt>:active_support</tt> (useful for inside Rails apps)
+  # * <tt>:okjson</tt>
   # * <tt>:yajl</tt>
   def engine=(new_engine)
     case new_engine

data/lib/multi_json/engines/okjson.rb

@@ -0,0 +1,34 @@
+require "multi_json/vendor/okjson" unless defined?(::OkJson)
+
+module MultiJson
+  module Engines
+    class Okjson
+      def self.decode(string, options = {}) #:nodoc:
+        result = OkJson.decode(string)
+        options[:symbolize_keys] ? symbolize_keys(result) : result
+      end
+
+      def self.encode(object) #:nodoc:
+        OkJson.encode(stringify_keys(object))
+      end
+
+      def self.symbolize_keys(object) #:nodoc:
+        return object unless object.is_a?(Hash)
+        object.inject({}) do |result, (key, value)|
+          new_key   = key.is_a?(String) ? key.to_sym : key
+          new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+          result.merge! new_key => new_value
+        end
+      end
+
+      def self.stringify_keys(object) #:nodoc:
+        return object unless object.is_a?(Hash)
+        object.inject({}) do |result, (key, value)|
+          new_key   = key.is_a?(Symbol) ? key.to_s : key
+          new_value = value.is_a?(Hash) ? stringify_keys(value) : value
+          result.merge! new_key => new_value
+        end
+      end
+    end
+  end
+end

data/lib/multi_json/vendor/okjson.rb

@@ -0,0 +1,581 @@
+# Copyright 2011 Keith Rarick
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# See https://github.com/kr/okjson for updates.
+
+require 'stringio'
+
+# Some parts adapted from
+# http://golang.org/src/pkg/json/decode.go and
+# http://golang.org/src/pkg/utf8/utf8.go
+module OkJson
+  extend self
+
+
+  # Decodes a json document in string s and
+  # returns the corresponding ruby value.
+  # String s must be valid UTF-8. If you have
+  # a string in some other encoding, convert
+  # it first.
+  #
+  # String values in the resulting structure
+  # will be UTF-8.
+  def decode(s)
+    ts = lex(s)
+    v, ts = textparse(ts)
+    if ts.length > 0
+      raise Error, 'trailing garbage'
+    end
+    v
+  end
+
+
+  # Parses a "json text" in the sense of RFC 4627.
+  # Returns the parsed value and any trailing tokens.
+  # Note: this is almost the same as valparse,
+  # except that it does not accept atomic values.
+  def textparse(ts)
+    if ts.length < 0
+      raise Error, 'empty'
+    end
+
+    typ, _, val = ts[0]
+    case typ
+    when '{' then objparse(ts)
+    when '[' then arrparse(ts)
+    else
+      raise Error, "unexpected #{val.inspect}"
+    end
+  end
+
+
+  # Parses a "value" in the sense of RFC 4627.
+  # Returns the parsed value and any trailing tokens.
+  def valparse(ts)
+    if ts.length < 0
+      raise Error, 'empty'
+    end
+
+    typ, _, val = ts[0]
+    case typ
+    when '{' then objparse(ts)
+    when '[' then arrparse(ts)
+    when :val,:str then [val, ts[1..-1]]
+    else
+      raise Error, "unexpected #{val.inspect}"
+    end
+  end
+
+
+  # Parses an "object" in the sense of RFC 4627.
+  # Returns the parsed value and any trailing tokens.
+  def objparse(ts)
+    ts = eat('{', ts)
+    obj = {}
+
+    if ts[0][0] == '}'
+      return obj, ts[1..-1]
+    end
+
+    k, v, ts = pairparse(ts)
+    obj[k] = v
+
+    if ts[0][0] == '}'
+      return obj, ts[1..-1]
+    end
+
+    loop do
+      ts = eat(',', ts)
+
+      k, v, ts = pairparse(ts)
+      obj[k] = v
+
+      if ts[0][0] == '}'
+        return obj, ts[1..-1]
+      end
+    end
+  end
+
+
+  # Parses a "member" in the sense of RFC 4627.
+  # Returns the parsed values and any trailing tokens.
+  def pairparse(ts)
+    (typ, _, k), ts = ts[0], ts[1..-1]
+    if typ != :str
+      raise Error, "unexpected #{k.inspect}"
+    end
+    ts = eat(':', ts)
+    v, ts = valparse(ts)
+    [k, v, ts]
+  end
+
+
+  # Parses an "array" in the sense of RFC 4627.
+  # Returns the parsed value and any trailing tokens.
+  def arrparse(ts)
+    ts = eat('[', ts)
+    arr = []
+
+    if ts[0][0] == ']'
+      return arr, ts[1..-1]
+    end
+
+    v, ts = valparse(ts)
+    arr << v
+
+    if ts[0][0] == ']'
+      return arr, ts[1..-1]
+    end
+
+    loop do
+      ts = eat(',', ts)
+
+      v, ts = valparse(ts)
+      arr << v
+
+      if ts[0][0] == ']'
+        return arr, ts[1..-1]
+      end
+    end
+  end
+
+
+  def eat(typ, ts)
+    if ts[0][0] != typ
+      raise Error, "expected #{typ} (got #{ts[0].inspect})"
+    end
+    ts[1..-1]
+  end
+
+
+  # Sans s and returns a list of json tokens,
+  # excluding white space (as defined in RFC 4627).
+  def lex(s)
+    ts = []
+    while s.length > 0
+      typ, lexeme, val = tok(s)
+      if typ == nil
+        raise Error, "invalid character at #{s[0,10].inspect}"
+      end
+      if typ != :space
+        ts << [typ, lexeme, val]
+      end
+      s = s[lexeme.length..-1]
+    end
+    ts
+  end
+
+
+  # Scans the first token in s and
+  # returns a 3-element list, or nil
+  # if no such token exists.
+  #
+  # The first list element is one of
+  # '{', '}', ':', ',', '[', ']',
+  # :val, :str, and :space.
+  #
+  # The second element is the lexeme.
+  #
+  # The third element is the value of the
+  # token for :val and :str, otherwise
+  # it is the lexeme.
+  def tok(s)
+    case s[0]
+    when ?{  then ['{', s[0,1], s[0,1]]
+    when ?}  then ['}', s[0,1], s[0,1]]
+    when ?:  then [':', s[0,1], s[0,1]]
+    when ?,  then [',', s[0,1], s[0,1]]
+    when ?[  then ['[', s[0,1], s[0,1]]
+    when ?]  then [']', s[0,1], s[0,1]]
+    when ?n  then nulltok(s)
+    when ?t  then truetok(s)
+    when ?f  then falsetok(s)
+    when ?"  then strtok(s)
+    when Spc then [:space, s[0,1], s[0,1]]
+    when ?\t then [:space, s[0,1], s[0,1]]
+    when ?\n then [:space, s[0,1], s[0,1]]
+    when ?\r then [:space, s[0,1], s[0,1]]
+    else          numtok(s)
+    end
+  end
+
+
+  def nulltok(s);  s[0,4] == 'null'  && [:val, 'null',  nil]   end
+  def truetok(s);  s[0,4] == 'true'  && [:val, 'true',  true]  end
+  def falsetok(s); s[0,5] == 'false' && [:val, 'false', false] end
+
+
+  def numtok(s)
+    m = /-?([1-9][0-9]+|[0-9])([.][0-9]+)?([eE][+-]?[0-9]+)?/.match(s)
+    if m && m.begin(0) == 0
+      if m[3] && !m[2]
+        [:val, m[0], Integer(m[1])*(10**Integer(m[3][1..-1]))]
+      elsif m[2]
+        [:val, m[0], Float(m[0])]
+      else
+        [:val, m[0], Integer(m[0])]
+      end
+    end
+  end
+
+
+  def strtok(s)
+    m = /"([^"\\]|\\["\/\\bfnrt]|\\u[0-9a-fA-F]{4})*"/.match(s)
+    if ! m
+      raise Error, "invalid string literal at #{abbrev(s)}"
+    end
+    [:str, m[0], unquote(m[0])]
+  end
+
+
+  def abbrev(s)
+    t = s[0,10]
+    p = t['`']
+    t = t[0,p] if p
+    t = t + '...' if t.length < s.length
+    '`' + t + '`'
+  end
+
+
+  # Converts a quoted json string literal q into a UTF-8-encoded string.
+  # The rules are different than for Ruby, so we cannot use eval.
+  # Unquote will raise an error if q contains control characters.
+  def unquote(q)
+    q = q[1...-1]
+    a = q.dup # allocate a big enough string
+    r, w = 0, 0
+    while r < q.length
+      c = q[r]
+      case true
+      when c == ?\\
+        r += 1
+        if r >= q.length
+          raise Error, "string literal ends with a \"\\\": \"#{q}\""
+        end
+
+        case q[r]
+        when ?",?\\,?/,?'
+          a[w] = q[r]
+          r += 1
+          w += 1
+        when ?b,?f,?n,?r,?t
+          a[w] = Unesc[q[r]]
+          r += 1
+          w += 1
+        when ?u
+          r += 1
+          uchar = begin
+            hexdec4(q[r,4])
+          rescue RuntimeError => e
+            raise Error, "invalid escape sequence \\u#{q[r,4]}: #{e}"
+          end
+          r += 4
+          if surrogate? uchar
+            if q.length >= r+6
+              uchar1 = hexdec4(q[r+2,4])
+              uchar = subst(uchar, uchar1)
+              if uchar != Ucharerr
+                # A valid pair; consume.
+                r += 6
+              end
+            end
+          end
+          w += ucharenc(a, w, uchar)
+        else
+          raise Error, "invalid escape char #{q[r]} in \"#{q}\""
+        end
+      when c == ?", c < Spc
+        raise Error, "invalid character in string literal \"#{q}\""
+      else
+        # Copy anything else byte-for-byte.
+        # Valid UTF-8 will remain valid UTF-8.
+        # Invalid UTF-8 will remain invalid UTF-8.
+        a[w] = c
+        r += 1
+        w += 1
+      end
+    end
+    a[0,w]
+  end
+
+
+  # Encodes unicode character u as UTF-8
+  # bytes in string a at position i.
+  # Returns the number of bytes written.
+  def ucharenc(a, i, u)
+    case true
+    when u <= Uchar1max
+      a[i] = (u & 0xff).chr
+      1
+    when u <= Uchar2max
+      a[i+0] = (Utag2 | ((u>>6)&0xff)).chr
+      a[i+1] = (Utagx | (u&Umaskx)).chr
+      2
+    when u <= Uchar3max
+      a[i+0] = (Utag3 | ((u>>12)&0xff)).chr
+      a[i+1] = (Utagx | ((u>>6)&Umaskx)).chr
+      a[i+2] = (Utagx | (u&Umaskx)).chr
+      3
+    else
+      a[i+0] = (Utag4 | ((u>>18)&0xff)).chr
+      a[i+1] = (Utagx | ((u>>12)&Umaskx)).chr
+      a[i+2] = (Utagx | ((u>>6)&Umaskx)).chr
+      a[i+3] = (Utagx | (u&Umaskx)).chr
+      4
+    end
+  end
+
+
+  def hexdec4(s)
+    if s.length != 4
+      raise Error, 'short'
+    end
+    (nibble(s[0])<<12) | (nibble(s[1])<<8) | (nibble(s[2])<<4) | nibble(s[3])
+  end
+
+
+  def subst(u1, u2)
+    if Usurr1 <= u1 && u1 < Usurr2 && Usurr2 <= u2 && u2 < Usurr3
+      return ((u1-Usurr1)<<10) | (u2-Usurr2) + Usurrself
+    end
+    return Ucharerr
+  end
+
+
+  def unsubst(u)
+    if u < Usurrself || u > Umax || surrogate?(u)
+      return Ucharerr, Ucharerr
+    end
+    u -= Usurrself
+    [Usurr1 + ((u>>10)&0x3ff), Usurr2 + (u&0x3ff)]
+  end
+
+
+  def surrogate?(u)
+    Usurr1 <= u && u < Usurr3
+  end
+
+
+  def nibble(c)
+    case true
+    when ?0 <= c && c <= ?9 then c.ord - ?0.ord
+    when ?a <= c && c <= ?z then c.ord - ?a.ord + 10
+    when ?A <= c && c <= ?Z then c.ord - ?A.ord + 10
+    else
+      raise Error, "invalid hex code #{c}"
+    end
+  end
+
+
+  # Encodes x into a json text. It may contain only
+  # Array, Hash, String, Numeric, true, false, nil.
+  # (Note, this list excludes Symbol.)
+  # X itself must be an Array or a Hash.
+  # No other value can be encoded, and an error will
+  # be raised if x contains any other value, such as
+  # Nan, Infinity, Symbol, and Proc, or if a Hash key
+  # is not a String.
+  # Strings contained in x must be valid UTF-8.
+  def encode(x)
+    case x
+    when Hash    then objenc(x)
+    when Array   then arrenc(x)
+    else
+      raise Error, 'root value must be an Array or a Hash'
+    end
+  end
+
+
+  def valenc(x)
+    case x
+    when Hash    then objenc(x)
+    when Array   then arrenc(x)
+    when String  then strenc(x)
+    when Numeric then numenc(x)
+    when true    then "true"
+    when false   then "false"
+    when nil     then "null"
+    else
+      raise Error, "cannot encode #{x.class}: #{x.inspect}"
+    end
+  end
+
+
+  def objenc(x)
+    '{' + x.map{|k,v| keyenc(k) + ':' + valenc(v)}.join(',') + '}'
+  end
+
+
+  def arrenc(a)
+    '[' + a.map{|x| valenc(x)}.join(',') + ']'
+  end
+
+
+  def keyenc(k)
+    case k
+    when String then strenc(k)
+    else
+      raise Error, "Hash key is not a string: #{k.inspect}"
+    end
+  end
+
+
+  def strenc(s)
+    t = StringIO.new
+    t.putc(?")
+    r = 0
+    while r < s.length
+      case s[r]
+      when ?"  then t.print('\\"')
+      when ?\\ then t.print('\\\\')
+      when ?\b then t.print('\\b')
+      when ?\f then t.print('\\f')
+      when ?\n then t.print('\\n')
+      when ?\r then t.print('\\r')
+      when ?\t then t.print('\\t')
+      else
+        c = s[r]
+        case true
+        when Spc <= c && c <= ?~
+          t.putc(c)
+        when true
+          u, size = uchardec(s, r)
+          r += size - 1 # we add one more at the bottom of the loop
+          if u < 0x10000
+            t.print('\\u')
+            hexenc4(t, u)
+          else
+            u1, u2 = unsubst(u)
+            t.print('\\u')
+            hexenc4(t, u1)
+            t.print('\\u')
+            hexenc4(t, u2)
+          end
+        else
+          # invalid byte; skip it
+        end
+      end
+      r += 1
+    end
+    t.putc(?")
+    t.string
+  end
+
+
+  def hexenc4(t, u)
+    t.putc(Hex[(u>>12)&0xf])
+    t.putc(Hex[(u>>8)&0xf])
+    t.putc(Hex[(u>>4)&0xf])
+    t.putc(Hex[u&0xf])
+  end
+
+
+  def numenc(x)
+    if x.nan? || x.infinite?
+      return 'null'
+    end rescue nil
+    "#{x}"
+  end
+
+
+  # Decodes unicode character u from UTF-8
+  # bytes in string s at position i.
+  # Returns u and the number of bytes read.
+  def uchardec(s, i)
+    n = s.length - i
+    return [Ucharerr, 1] if n < 1
+
+    c0 = s[i].ord
+
+    # 1-byte, 7-bit sequence?
+    if c0 < Utagx
+      return [c0, 1]
+    end
+
+    # unexpected continuation byte?
+    return [Ucharerr, 1] if c0 < Utag2
+
+    # need continuation byte
+    return [Ucharerr, 1] if n < 2
+    c1 = s[i+1].ord
+    return [Ucharerr, 1] if c1 < Utagx || Utag2 <= c1
+
+    # 2-byte, 11-bit sequence?
+    if c0 < Utag3
+      u = (c0&Umask2)<<6 | (c1&Umaskx)
+      return [Ucharerr, 1] if u <= Uchar1max
+      return [u, 2]
+    end
+
+    # need second continuation byte
+    return [Ucharerr, 1] if n < 3
+    c2 = s[i+2].ord
+    return [Ucharerr, 1] if c2 < Utagx || Utag2 <= c2
+
+    # 3-byte, 16-bit sequence?
+    if c0 < Utag4
+      u = (c0&Umask3)<<12 | (c1&Umaskx)<<6 | (c2&Umaskx)
+      return [Ucharerr, 1] if u <= Uchar2max
+      return [u, 3]
+    end
+
+    # need third continuation byte
+    return [Ucharerr, 1] if n < 4
+    c3 = s[i+3].ord
+    return [Ucharerr, 1] if c3 < Utagx || Utag2 <= c3
+
+    # 4-byte, 21-bit sequence?
+    if c0 < Utag5
+      u = (c0&Umask4)<<18 | (c1&Umaskx)<<12 | (c2&Umaskx)<<6 | (c3&Umaskx)
+      return [Ucharerr, 1] if u <= Uchar3max
+      return [u, 4]
+    end
+
+    return [Ucharerr, 1]
+  end
+
+
+  class Error < ::StandardError
+  end
+
+
+  Utagx = 0x80 # 1000 0000
+  Utag2 = 0xc0 # 1100 0000
+  Utag3 = 0xe0 # 1110 0000
+  Utag4 = 0xf0 # 1111 0000
+  Utag5 = 0xF8 # 1111 1000
+  Umaskx = 0x3f # 0011 1111
+  Umask2 = 0x1f # 0001 1111
+  Umask3 = 0x0f # 0000 1111
+  Umask4 = 0x07 # 0000 0111
+  Uchar1max = (1<<7) - 1
+  Uchar2max = (1<<11) - 1
+  Uchar3max = (1<<16) - 1
+  Ucharerr = 0xFFFD # unicode "replacement char"
+  Usurrself = 0x10000
+  Usurr1 = 0xd800
+  Usurr2 = 0xdc00
+  Usurr3 = 0xe000
+  Umax = 0x10ffff
+
+  Spc = ' '[0]
+  Unesc = {?b=>?\b, ?f=>?\f, ?n=>?\n, ?r=>?\r, ?t=>?\t}
+  Hex = '0123456789abcdef'
+end

data/lib/multi_json/version.rb

@@ -1,3 +1,3 @@
 module MultiJson
-  VERSION = "0.0.5"
+  VERSION = "1.0.0.rc"
 end

data/multi_json.gemspec

@@ -4,24 +4,35 @@ require File.expand_path("../lib/multi_json/version", __FILE__)
 Gem::Specification.new do |s|
   s.name = "multi_json"
   s.version = MultiJson::VERSION
+
   s.required_rubygems_version = Gem::Requirement.new(">= 1.3.6") if s.respond_to? :required_rubygems_version=
+
   s.authors = ["Michael Bleigh"]
-  s.description = %q{A gem to provide swappable JSON backends utilizing Yajl::Ruby, the JSON gem, ActiveSupport, or JSON pure.}
+  s.email   = ["michael@intridea.com"]
   s.summary = %q{A gem to provide swappable JSON backends.}
-  s.email = ["michael@intridea.com"]
+  s.description = %q{A gem to provide swappable JSON backends utilizing Yajl::Ruby, the JSON gem, ActiveSupport, or JSON pure.}
   s.homepage = "http://github.com/intridea/multi_json"
+
   s.extra_rdoc_files = ["LICENSE", "README.rdoc"]
-  s.rdoc_options = ["--charset=UTF-8"]
+  s.rdoc_options     = ["--charset=UTF-8"]
+
   s.executables = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+
   s.require_paths = ["lib"]
+
   s.add_development_dependency("rake", "~> 0.8")
-  s.add_development_dependency("rcov", "~> 0.9")
   s.add_development_dependency("rspec", "~> 2.0")
-  s.add_development_dependency("activesupport", "~> 3.0")
   s.add_development_dependency("json", "~> 1.4")
   s.add_development_dependency("json_pure", "~> 1.4")
-  s.add_development_dependency("yajl-ruby", "~> 0.7")
+
+  unless ENV['RUBY_VERSION'].match(/^rbx-/)
+    s.add_development_dependency("rcov", "~> 0.9")
+  end
+
+  unless ENV['RUBY_VERSION'].match(/^jruby-/)
+    s.add_development_dependency("yajl-ruby", "~> 0.7")
+  end
 end
 

data/spec/multi_json_spec.rb

@@ -1,8 +1,8 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 class MockDecoder
   def self.decode(string, options = {})
-    {'abc' => 'def'}
+    { 'abc' => 'def' }
   end
 
   def self.encode(string)
@@ -13,13 +13,19 @@ end
 describe "MultiJson" do
   context 'engines' do
     it 'should default to the best available gem' do
-      require 'yajl'
-      MultiJson.engine.name.should == 'MultiJson::Engines::Yajl'
+      # the yajl-ruby gem does not work on jruby, so the best engine is the JsonGem engine
+      if ENV['RUBY_VERSION'].match(/^jruby-/)
+        require 'json'
+        MultiJson.engine.name.should == 'MultiJson::Engines::JsonGem'
+      else
+        require 'yajl'
+        MultiJson.engine.name.should == 'MultiJson::Engines::Yajl'
+      end
     end
 
     it 'should be settable via a symbol' do
-      MultiJson.engine = :yajl
-      MultiJson.engine.name.should == 'MultiJson::Engines::Yajl'
+      MultiJson.engine = :json_gem
+      MultiJson.engine.name.should == 'MultiJson::Engines::JsonGem'
     end
 
     it 'should be settable via a class' do
@@ -28,7 +34,7 @@ describe "MultiJson" do
     end
   end
 
-  %w(active_support json_gem json_pure yajl).each do |engine|
+  %w(json_gem json_pure okjson yajl).each do |engine|
     context engine do
       before do
         begin
@@ -41,7 +47,7 @@ describe "MultiJson" do
       describe '.encode' do
         it 'should write decodable JSON' do
           [
-            {'abc' => 'def'},
+            { 'abc' => 'def' },
             [1, 2, 3, "4"]
           ].each do |example|
             MultiJson.decode(MultiJson.encode(example)).should == example
@@ -51,7 +57,7 @@ describe "MultiJson" do
 
       describe '.decode' do
         it 'should properly decode valid JSON' do
-          MultiJson.decode('{"abc":"def"}').should == {'abc' => 'def'}
+          MultiJson.decode('{"abc":"def"}').should == { 'abc' => 'def' }
         end
 
         it 'should raise MultiJson::DecodeError on invalid JSON' do
@@ -60,8 +66,13 @@ describe "MultiJson" do
           end.should raise_error(MultiJson::DecodeError)
         end
 
+        it 'should stringify symbol keys when encoding' do
+          encoded_json = MultiJson.encode(:a => 1, :b => {:c => 2})
+          MultiJson.decode(encoded_json).should == { "a" => 1, "b" => { "c" => 2 } }
+        end
+
         it 'should allow for symbolization of keys' do
-          MultiJson.decode('{"abc":{"def":"hgi"}}', :symbolize_keys => true).should == {:abc => {:def => 'hgi'}}
+          MultiJson.decode('{"abc":{"def":"hgi"}}', :symbolize_keys => true).should == { :abc => { :def => 'hgi' } }
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,11 +1,9 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'multi_json'
-require 'rspec'
-require 'rspec/autorun'
 begin
   require 'bundler'
-  Bundler.setup
 rescue LoadError
-  $stderr.puts "Bundler (or a dependency) not available."
+  puts "although not required, it's recommended that you use bundler during development"
 end
+
+require 'multi_json'
+require 'rspec'
+require 'rspec/autorun'

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: multi_json
 version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
+  hash: 7712010
+  prerelease: 6
   segments: 
+  - 1
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - rc
+  version: 1.0.0.rc
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -15,8 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-04 00:00:00 -05:00
-default_executable: 
+date: 2011-04-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
@@ -33,25 +33,10 @@ dependencies:
         version: "0.8"
   type: :development
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rcov
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 25
-        segments: 
-        - 0
-        - 9
-        version: "0.9"
-  type: :development
-  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -62,26 +47,26 @@ dependencies:
         - 0
         version: "2.0"
   type: :development
-  version_requirements: *id003
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: json
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
         hash: 7
         segments: 
-        - 3
-        - 0
-        version: "3.0"
+        - 1
+        - 4
+        version: "1.4"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: json_pure
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -92,26 +77,26 @@ dependencies:
         - 4
         version: "1.4"
   type: :development
-  version_requirements: *id005
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: json_pure
+  name: rcov
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 25
         segments: 
-        - 1
-        - 4
-        version: "1.4"
+        - 0
+        - 9
+        version: "0.9"
   type: :development
-  version_requirements: *id006
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: yajl-ruby
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -122,7 +107,7 @@ dependencies:
         - 7
         version: "0.7"
   type: :development
-  version_requirements: *id007
+  version_requirements: *id006
 description: A gem to provide swappable JSON backends utilizing Yajl::Ruby, the JSON gem, ActiveSupport, or JSON pure.
 email: 
 - michael@intridea.com
@@ -137,22 +122,22 @@ files:
 - .document
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.rdoc
 - Rakefile
 - lib/multi_json.rb
-- lib/multi_json/engines/active_support.rb
 - lib/multi_json/engines/json_gem.rb
 - lib/multi_json/engines/json_pure.rb
+- lib/multi_json/engines/okjson.rb
 - lib/multi_json/engines/yajl.rb
+- lib/multi_json/vendor/okjson.rb
 - lib/multi_json/version.rb
 - multi_json.gemspec
 - spec/multi_json_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/intridea/multi_json
 licenses: []
 
@@ -184,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: A gem to provide swappable JSON backends.
@@ -192,3 +177,4 @@ test_files:
 - spec/multi_json_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+has_rdoc: 

data/Gemfile.lock

@@ -1,38 +0,0 @@
-PATH
-  remote: .
-  specs:
-    multi_json (0.0.5)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activesupport (3.0.1)
-    diff-lcs (1.1.2)
-    json (1.4.6)
-    json_pure (1.4.6)
-    rake (0.8.7)
-    rcov (0.9.9)
-    rspec (2.0.0)
-      rspec-core (= 2.0.0)
-      rspec-expectations (= 2.0.0)
-      rspec-mocks (= 2.0.0)
-    rspec-core (2.0.0)
-    rspec-expectations (2.0.0)
-      diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.0)
-      rspec-core (= 2.0.0)
-      rspec-expectations (= 2.0.0)
-    yajl-ruby (0.7.8)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport (~> 3.0)
-  json (~> 1.4)
-  json_pure (~> 1.4)
-  multi_json!
-  rake (~> 0.8)
-  rcov (~> 0.9)
-  rspec (~> 2.0)
-  yajl-ruby (~> 0.7)

data/lib/multi_json/engines/active_support.rb

@@ -1,32 +0,0 @@
-require 'active_support' unless defined?(::ActiveSupport::JSON)
-
-module MultiJson
-  module Engines
-    # Use ActiveSupport to encode/decode JSON.
-    class ActiveSupport
-      def self.decode(string, options = {}) #:nodoc:
-        hash = ::ActiveSupport::JSON.decode(string)
-        options[:symbolize_keys] ? symbolize_keys(hash) : hash
-      end
-
-      def self.encode(object) #:nodoc:
-        ::ActiveSupport::JSON.encode(object)
-      end
-
-      def self.symbolize_keys(hash) #:nodoc:
-        hash.inject({}){|result, (key, value)|
-          new_key = case key
-                    when String then key.to_sym
-                    else key
-                    end
-          new_value = case value
-                      when Hash then symbolize_keys(value)
-                      else value
-                      end
-          result[new_key] = new_value
-          result
-        }
-      end
-    end
-  end
-end