jrjackson 0.2.9 → 0.3.0

data/test/jrjackson_test.rb

@@ -12,6 +12,15 @@ require 'stringio'
 require 'time'
 
 class JrJacksonTest < Test::Unit::TestCase
+#   def test_serialize_date
+#     # default date format
+#     time_string = "2014-12-18 18:18:18 +0000"
+#     source_time = Time.parse(time_string)
+#     # source_time = Date.today
+#     serialized_output = JrJackson::Json.dump({current_time: source_time})
+#     assert_equal %Q{{"current_time":"#{time_string}"}}, serialized_output
+#   end
+# end
 
   class CustomToH
     attr_accessor :one, :two, :six
@@ -48,12 +57,163 @@ class JrJacksonTest < Test::Unit::TestCase
       @now = tm
     end
     def to_time
-      @now
+      @now.to_time
     end
   end
 
   CustomStruct = Struct.new(:one, :two, :six)
 
+
+  class ScHandler
+    attr_accessor :calls
+
+    def initialize(arr = [])
+      @calls = arr
+    end
+
+    def hash_start()
+      @calls << [:hash_start]
+      {}
+    end
+
+    def hash_end()
+      @calls << [:hash_end]
+    end
+
+    def hash_key(key)
+      @calls << [:hash_key, key]
+      return 'too' if 'two' == key
+      return :symbol if 'symbol' == key
+      key
+    end
+
+    def array_start()
+      @calls << [:array_start]
+      []
+    end
+
+    def array_end()
+      @calls << [:array_end]
+    end
+
+    def add_value(value)
+      @calls << [:add_value, value]
+    end
+
+    def hash_set(h, key, value)
+      # h[key] = value
+      @calls << [:hash_set, key, value]
+    end
+
+    def array_append(a, value)
+      # a.push(value)
+      @calls << [:array_append, value]
+    end
+  end
+
+  JsonString = %Q|{
+    "array": [
+      {
+        "num"   : 3,
+        "string": "message",
+        "hash"  : {
+          "h2"  : {
+            "a" : [ 1, 2, 3 ]
+          }
+        }
+      }
+    ],
+    "boolean" : true
+  }|
+
+  def test_sc_parse
+    array = []
+    handler = ScHandler.new(array)
+    JrJackson::Json.sc_load(handler, JsonString)
+    assert_equal(
+      [
+        [:hash_start],
+        [:array_start],
+        [:hash_start],
+        [:hash_key, 'num'],
+        [:hash_set, "num", 3],
+        [:hash_key, 'string'],
+        [:hash_set, "string", "message"],
+        [:hash_start],
+        [:hash_start],
+        [:array_start],
+        [:array_append, 1],
+        [:array_append, 2],
+        [:array_append, 3],
+        [:array_end],
+        [:hash_key, "a"],
+        [:hash_set, "a", []],
+        [:hash_end],
+        [:hash_key, "h2"],
+        [:hash_set, "h2", {}],
+        [:hash_end],
+        [:hash_key, "hash"],
+        [:hash_set, "hash", {}],
+        [:hash_end],
+        [:array_append, {}],
+        [:array_end],
+        [:hash_key, "array"],
+        [:hash_set, "array", []],
+        [:hash_key, 'boolean'],
+        [:hash_set, "boolean", true],
+        [:hash_end],
+        [:add_value, {}]
+      ],
+    handler.calls
+  )
+  end
+
+  class SjHandler
+    attr_reader :calls
+    def initialize(arr = []) @calls = arr; end
+    def hash_start(key) @calls << [:hash_start, key]; end
+    def hash_end(key) @calls << [:hash_end, key]; end
+    def array_start(key) @calls << [:array_start, key]; end
+    def array_end(key) @calls << [:array_end, key]; end
+    def add_value(value, key) @calls << [:add_value, value, key]; end
+    def error(message, line, column) @calls << [:error, message, line, column]; end
+  end
+
+  def test_sj_parse
+    handler = SjHandler.new()
+    JrJackson::Json.sj_load(handler, JsonString)
+    assert_equal(
+      [
+        [:hash_start, nil],
+        [:array_start, 'array'],
+        [:hash_start, nil],
+        [:add_value, 3, 'num'],
+        [:add_value, 'message', 'string'],
+        [:hash_start, 'hash'],
+        [:hash_start, 'h2'],
+        [:array_start, 'a'],
+        [:add_value, 1, nil],
+        [:add_value, 2, nil],
+        [:add_value, 3, nil],
+        [:array_end, 'a'],
+        [:hash_end, 'h2'],
+        [:hash_end, 'hash'],
+        [:hash_end, nil],
+        [:array_end, 'array'],
+        [:add_value, true, 'boolean'],
+        [:hash_end, nil]
+      ],
+      handler.calls
+    )
+  end
+
+  def test_datetime
+    h = {datetime: DateTime.parse("2014-01-27T18:24:46+01:00")}
+    expected = '{"datetime":"2014-01-27 17:24:46 +0000"}'
+    actual = JrJackson::Json.dump(h)
+    assert_equal expected, actual
+  end
+
   def test_threading
     q1, q2, q3 = Queue.new, Queue.new, Queue.new
 
@@ -79,26 +239,35 @@ class JrJacksonTest < Test::Unit::TestCase
     json_string = JrJackson::Json.dump({"utf8" => "żółć"})
     expected = {utf8: "żółć"}
     actual = JrJackson::Json.load(json_string, :symbolize_keys => true)
+
+    assert_equal expected, actual
+  end
+
+  def test_deserialize_JSON_with_two_entries
+    json_string = JrJackson::Json.dump({'foo' => 'foo_value', 'bar' => 'bar_value'})
+    expected = {foo: 'foo_value', bar: 'bar_value'}
+    actual = JrJackson::Json.load(json_string, :symbolize_keys => true)
     assert_equal expected, actual
   end
 
   def test_serialize_non_json_datatypes_as_values
     dt = Time.now
+    today = Date.today
     co1 = CustomToH.new("uno", :two, 6.0)
     co2 = CustomToHash.new("uno", :two, 6.0)
     co3 = CustomToJson.new(1.0, 2, 6.0)
     co4 = CustomStruct.new(1, 2, 6)
-    co5 = CustomToTime.new(dt)
+    co5 = CustomToTime.new(today)
     source = {'sym' => :a_symbol, 'dt' => dt, 'co1' => co1, 'co2' => co2, 'co3' => co3, 'co4' => co4, 'co5' => co5}
     json_string = JrJackson::Json.dump(source)
     expected = {
       :sym => "a_symbol",
-      :dt => dt.strftime("%F %T %z"),
+      :dt => dt.to_s,
       :co1 => {:one => "uno", :two => "two", :six => 6.0 },
       :co2 => {:one => "uno", :two => "two", :six => 6.0 },
       :co3 => {:one => 1.0, :two => 2.0, :six => 6.0 },
       :co4 => [1, 2, 6],
-      :co5 => dt.strftime("%F %T %z")
+      :co5 => today.to_time.to_s
     }
     actual = JrJackson::Json.load(json_string, :symbolize_keys => true)
     assert_equal expected, actual
@@ -153,6 +322,89 @@ class JrJacksonTest < Test::Unit::TestCase
     assert_equal "{\"time\":\"2014-06-10T22:18:40.000Z\"}", JrJackson::Json.dump({"time" => time}, :date_format => "yyyy-MM-dd'T'HH:mm:ss.SSSX", :timezone => "UTC")
   end
 
+  def test_can_parse_returning_java_objects
+    expected = {"arr"=>[2, 3, 4],
+      "flo"=>0.333E1,
+      "moo"=>"bar",
+      "utf8"=>"żółć",
+      "zzz"=>{"bar"=>-9}}
+    json = '{"utf8":"żółć", "moo": "bar", "zzz": {"bar":-9}, "arr": [2,3,4], "flo": 3.33}'
+
+    actual = JrJackson::Json.parse_java(json)
+
+    assert_equal Java::JavaUtil::HashMap, actual.class
+    assert_equal Java::JavaUtil::ArrayList, actual["arr"].class
+    assert_equal Java::JavaMath::BigDecimal, actual["flo"].class
+    assert_equal "3.33", actual["flo"].to_s
+    assert_equal "bar", actual["moo"]
+    assert_equal "żółć", actual["utf8"]
+    assert_equal Java::JavaUtil::HashMap, actual["zzz"].class
+    assert_equal Bignum, actual["zzz"]["bar"].class
+    assert_equal -9, actual["zzz"]["bar"]
+  end
+
+  def test_can_parse_returning_ruby_objects_string_keys
+    expected = {
+      "a"=>"żółć", # string
+      "b"=>true,    # boolean
+      "c"=>12345,   # number
+      "d"=>
+       [true,
+        [false,
+         [-123456789, nil],
+         0.39676E1,
+         ["Something else.", false],
+         nil]], # mix it up array
+      "e"=>{"zero"=>nil, "one"=>1, "two"=>2, "three"=>[3], "four"=>[0, 1, 2, 3, 4]}, # hash
+      "żółć"=>nil,# nil
+      "h"=>{"a"=>{"b"=>{"c"=>{"d"=>{"e"=>{"f"=>{"g"=>nil}}}}}}},# deep hash, not that deep
+      "i"=>[[[[[[[nil]]]]]]] # deep array, again, not that deep
+    }
+    json = JrJackson::Json.dump(expected)
+    actual = JrJackson::Json.parse_ruby(json)
+    assert_equal expected, actual
+    actual = JrJackson::Ruby.parse(json, {})
+    assert_equal expected, actual
+  end
+
+  def test_can_compat_parse_returning_ruby_objects_string_keys
+    expected = {
+      "a"=>"żółć", # string
+      "b"=>true,    # boolean
+      "c"=>12345,   # number
+      "d"=>
+       [true,
+        [false,
+         [-123456789, nil],
+         0.39676E1,
+         ["Something else.", false],
+         nil]], # mix it up array
+      "e"=>{"zero"=>nil, "one"=>1, "two"=>2, "three"=>[3], "four"=>[0, 1, 2, 3, 4]}, # hash
+      "żółć"=>nil,# nil
+      "h"=>{"a"=>{"b"=>{"c"=>{"d"=>{"e"=>{"f"=>{"g"=>nil}}}}}}},# deep hash, not that deep
+      "i"=>[[[[[[[nil]]]]]]] # deep array, again, not that deep
+    }
+    json = JrJackson::Json.dump(expected)
+    actual = JrJackson::Ruby.compat_parse(json, {})
+    assert_equal expected, actual
+  end
+
+  def test_can_parse_returning_ruby_objects_symbol_keys
+    expected = {:a=>"Alpha",
+     :b=>true,
+     :c=>12345,
+     :d=>
+      [true, [false, [-123456789, nil], 3.9676, ["Something else.", false], nil]],
+     :e=>{:zero=>nil, :one=>1, :two=>2, :three=>[3], :four=>[0, 1, 2, 3, 4]},
+     :f=>nil,
+     :h=>{:a=>{:b=>{:c=>{:d=>{:e=>{:f=>{:g=>nil}}}}}}},
+     :i=>[[[[[[[nil]]]]]]]
+    }
+    json = JrJackson::Json.dump(expected)
+    actual = JrJackson::Ruby.parse_sym(json, {})
+    assert_equal expected, actual
+  end
+
   def test_can_parse_nulls
     expected = {"foo" => nil}
     json = '{"foo":null}'
@@ -163,7 +415,7 @@ class JrJacksonTest < Test::Unit::TestCase
   def test_stringio
     expected = {"foo" => 5, "utf8" => "żółć"}
     json = ::StringIO.new('{"foo":5, "utf8":"żółć"}')
-    actual = JrJackson::Json.load(json)
+    actual = JrJackson::Json.load_ruby(json)
     assert_equal expected, actual
   end
 
@@ -200,8 +452,12 @@ class JrJacksonTest < Test::Unit::TestCase
     actual = JrJackson::Json.parse(json, :use_bigdecimal => true, :symbolize_keys => true)[:foo]
     assert_bigdecimal_equal expected, actual
 
+    actual = JrJackson::Java.parse(json, {})['foo']
+    assert_bigdecimal_similar expected, actual
+
     actual = JrJackson::Json.parse(json, :use_bigdecimal => true, :raw => true)['foo']
     assert_bigdecimal_similar expected, actual
+
   end
 
   def test_cannot_serialize_object
@@ -214,6 +470,15 @@ class JrJacksonTest < Test::Unit::TestCase
     assert_match /Cannot find Serializer for class: org.jruby.RubyBasicObject/, err.message
   end
 
+  def test_supports_pretty_printing
+    object = {"foo" => 5, "utf8" => "żółć"}
+    
+    actual = JrJackson::Json.dump(object, :pretty => true)
+    assert_equal "{\n  \"foo\" : 5,\n  \"utf8\" : \"żółć\"\n}", actual
+  end
+
+  # -----------------------------
+
   def assert_bigdecimal_equal(expected, actual)
     assert_equal expected, actual
     assert_equal expected.class, actual.class
@@ -221,7 +486,7 @@ class JrJacksonTest < Test::Unit::TestCase
   end
 
   def assert_bigdecimal_similar(expected, actual)
-    assert_equal BigDecimal.new(expected.to_s), BigDecimal.new(actual.to_s)
+    assert_equal BigDecimal.new(expected.to_s).round(11), BigDecimal.new(actual.to_s).round(11)
     assert_equal Java::JavaMath::BigDecimal, actual.class
   end
 

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: jrjackson
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.0
 platform: ruby
 authors:
 - Guy Boertje
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-06-24 00:00:00.000000000 Z
+date: 2015-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
-  type: :development
+  name: bundler
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
 description: A mostly native JRuby wrapper for the java jackson json processor jar
@@ -31,56 +31,88 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".jrubyrc"
+- .__jrubyrc
+- .gitignore
 - Gemfile
 - README.md
 - Rakefile
+- alt_bench.rb
 - changelog.md
 - dependency-reduced-pom.xml
 - jrjackson.gemspec
 - lib/jrjackson.rb
 - lib/jrjackson/build_info.rb
 - lib/jrjackson/jars/jrjackson-1.2.12.jar
+- lib/jrjackson/jars/jrjackson-1.2.16.jar
 - lib/jrjackson/jrjackson.rb
 - lib/require_relative_patch.rb
 - pom.xml
 - profiling/profiled.rb
 - run_all_individual_bench.sh
+- run_jruby_individual_bench.sh
+- run_mri_individual_bench.sh
+- src/main/java/com/jrjackson/IParseHandler.java
+- src/main/java/com/jrjackson/JavaBigDecimalValueConverter.java
+- src/main/java/com/jrjackson/JavaBigIntValueConverter.java
+- src/main/java/com/jrjackson/JavaConverter.java
+- src/main/java/com/jrjackson/JavaFloatValueConverter.java
+- src/main/java/com/jrjackson/JavaHandler.java
+- src/main/java/com/jrjackson/JavaLongValueConverter.java
+- src/main/java/com/jrjackson/JjParse.java
+- src/main/java/com/jrjackson/JrJacksonBase.java
+- src/main/java/com/jrjackson/JrJacksonJava.java
 - src/main/java/com/jrjackson/JrJacksonRaw.java
+- src/main/java/com/jrjackson/JrJacksonRuby.java
+- src/main/java/com/jrjackson/JrJacksonSaj.java
+- src/main/java/com/jrjackson/JrJacksonSch.java
 - src/main/java/com/jrjackson/JrJacksonService.java
+- src/main/java/com/jrjackson/JrParse.java
 - src/main/java/com/jrjackson/ParseError.java
 - src/main/java/com/jrjackson/RubyAnySerializer.java
+- src/main/java/com/jrjackson/RubyBigDecimalValueConverter.java
+- src/main/java/com/jrjackson/RubyBigIntValueConverter.java
+- src/main/java/com/jrjackson/RubyConverter.java
+- src/main/java/com/jrjackson/RubyDateFormat.java
+- src/main/java/com/jrjackson/RubyFloatValueConverter.java
+- src/main/java/com/jrjackson/RubyHandler.java
+- src/main/java/com/jrjackson/RubyIntValueConverter.java
 - src/main/java/com/jrjackson/RubyJacksonModule.java
 - src/main/java/com/jrjackson/RubyKeyConverter.java
+- src/main/java/com/jrjackson/RubyNameConverter.java
 - src/main/java/com/jrjackson/RubyObjectDeserializer.java
 - src/main/java/com/jrjackson/RubyStringConverter.java
-- src/main/java/com/jrjackson/RubySymbolConverter.java
+- src/main/java/com/jrjackson/RubyStringKeyConverter.java
+- src/main/java/com/jrjackson/RubyStringNameConverter.java
+- src/main/java/com/jrjackson/RubySymbolKeyConverter.java
+- src/main/java/com/jrjackson/RubySymbolNameConverter.java
 - src/main/java/com/jrjackson/RubyUtils.java
-- src/test/java/com/jrjackson/jruby/AppTest.java
+- src/main/java/com/jrjackson/SajParse.java
+- src/main/java/com/jrjackson/SchParse.java
+- src/main/java/com/jrjackson/StreamParse.java
 - test/jrjackson_test.rb
 homepage: http://github.com/guyboertje/jrjackson
 licenses:
 - Apache License 2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
 specification_version: 4
 summary: A JRuby wrapper for the java jackson json processor jar
 test_files: []
+has_rdoc:

data/src/test/java/com/jrjackson/jruby/AppTest.java

@@ -1,38 +0,0 @@
-package com.jrjackson.jruby;
-
-import junit.framework.Test;
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-/**
- * Unit test for simple App.
- */
-public class AppTest 
-    extends TestCase
-{
-    /**
-     * Create the test case
-     *
-     * @param testName name of the test case
-     */
-    public AppTest( String testName )
-    {
-        super( testName );
-    }
-
-    /**
-     * @return the suite of tests being tested
-     */
-    public static Test suite()
-    {
-        return new TestSuite( AppTest.class );
-    }
-
-    /**
-     * Rigourous Test :-)
-     */
-    public void testApp()
-    {
-        assertTrue( true );
-    }
-}