jrjackson 0.0.7 → 0.1.0

data/benchmarking/benchmark.rb

@@ -1,13 +1,18 @@
+#!/usr/bin/env ruby
+
 require 'rubygems'
 require 'benchmark'
+require 'thread'
 require 'digest'
 require 'json'
-require 'lib/jrjackson'
+require 'gson'
+
+require File.expand_path('lib/jrjackson')
 
 HASH = {:one => nil, :two => nil, :three => nil, :four => {:a => nil, :b => nil, :c =>nil},
 :five => {:d => nil, :e => nil},
 :six => {:f => nil, :g => nil, :h =>nil, :i => nil, :j => nil, :k => nil, :l => nil},
-:seven => nil, :eight => nil,
+:seven => nil, :eight => [],
 :nine => {:m => {:A => nil, :B => nil}}}
 
 def random_string
@@ -22,6 +27,14 @@ def random_float
   random_number + rand
 end
 
+def fill_array
+  value = []
+  5.times do
+    value.push send(METHODS[rand(3)])
+  end
+  value
+end
+
 def randomize_entries hsh
   new_hsh = {}
   hsh.each_pair do |key, value|
@@ -30,6 +43,8 @@ def randomize_entries hsh
       new_hsh[key] = send METHODS[rand(3)]
     when Hash
       new_hsh[key] = randomize_entries value
+    when Array
+      new_hsh[key] = fill_array
     end
   end
   new_hsh
@@ -39,44 +54,101 @@ METHODS = [:random_string, :random_number, :random_float]
 
 org_array = []
 one = []
-#
-0.upto(50000) do |i|
+
+0.upto(5000) do |i|
   hsh = HASH.dup
   org_array << randomize_entries(hsh)
 end
 
 generated_array = []
 generated_smile = []
-
+q = Queue.new
 
 org_array.each do |hsh|
-  generated_array << JrJackson::Json.generate(hsh)
-  generated_smile << JrJackson::Smile.generate(hsh)
+  generated_array << JrJackson::Raw.generate(hsh)
 end
 
-Benchmark.bmbm("jackson generate: plus some margin".size) do |x|
+Benchmark.bmbm("jackson parse symbol keys:  ".size) do |x|
 
-  x.report("jackson generate:") do
-    org_array.each {|hsh| JrJackson::Json.generate(hsh)  }
+  x.report("json java parse:") do
+    th1 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| ::JSON.parse("[#{string}]").first }}
+      q << true
+    end
+    th2 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| ::JSON.parse("[#{string}]").first }}
+      q << true
+    end
+    q.pop
+    q.pop
+    # 50.times {generated_array.each {|string| ::JSON.parse("[#{string}]").first }}
   end
 
-  x.report("smile generate:") do
-    org_array.each {|hsh| JrJackson::Smile.generate(hsh)  }
+  x.report("gson parse:") do
+    th1 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| ::Gson::Decoder.new({}).decode(string) }}
+      q << true
+    end
+    th2 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| ::Gson::Decoder.new({}).decode(string) }}
+      q << true
+    end
+    q.pop
+    q.pop
+    # 50.times {generated_array.each {|string| ::Gson::Decoder.new({}).decode(string) }}
   end
 
-  x.report("ruby generate:") do
-    org_array.each {|hsh|  JSON.fast_generate(hsh) }
+  x.report("jackson parse raw:") do
+    th1 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| JrJackson::Raw.parse(string) }}
+      q << true
+    end
+    th2 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| JrJackson::Raw.parse(string) }}
+      q << true
+    end
+    q.pop
+    q.pop
+    # 50.times {generated_array.each {|string| JrJackson::Raw.parse(string) }}
   end
 
-  x.report("jackson parse:") do
-    generated_array.each {|string| JrJackson::Json.parse(string) }
+  x.report("jackson parse symbol keys:") do
+    th1 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| JrJackson::Sym.parse(string) }}
+      q << true
+    end
+    th2 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| JrJackson::Sym.parse(string) }}
+      q << true
+    end
+    q.pop
+    q.pop
+    # 50.times {generated_array.each {|string| JrJackson::Sym.parse(string) }}
   end
 
-  x.report("smile parse:") do
-    generated_smile.each {|string| JrJackson::Smile.parse(string)  }
+  x.report("jackson parse string keys:") do
+    th1 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| JrJackson::Str.parse(string) }}
+      q << true
+    end
+    th2 = Thread.new(generated_array) do |arry|
+      50.times {arry.each {|string| JrJackson::Str.parse(string) }}
+      q << true
+    end
+    q.pop
+    q.pop
+    # 50.times {generated_array.each {|string| JrJackson::Str.parse(string) }}
   end
 
-  x.report("ruby parse:") do
-    generated_array.each {|string| JSON.parse(string) }
+  x.report("json java generate:") do
+    50.times {org_array.each {|hsh|  hsh.to_json }}
+  end
+
+  x.report("gson generate:") do
+    50.times {org_array.each {|hsh|  ::Gson::Encoder.new({}).encode(hsh) }}
+  end
+
+  x.report("jackson generate:") do
+    50.times {org_array.each {|hsh| JrJackson::Raw.generate(hsh)  }}
   end
 end

data/jrjackson.gemspec

@@ -2,39 +2,40 @@
 
 Gem::Specification.new do |s|
   s.name        = 'jrjackson'
-  s.version     = '0.0.7'
-  s.date        = '2012-03-14'
+  s.version     = '0.1.0'
+  s.date        = '2013-03-31'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Guy Boertje']
   s.email       = ['guyboertje@gmail.com']
   s.homepage    = "http://github.com/guyboertje/jrjackson"
   s.summary     = %q{A JRuby wrapper for the java jackson json processor jar}
-  s.description = %q{}
+  s.description = %q{A mostly native JRuby wrapper for the java jackson json processor jar}
+
+  s.add_development_dependency 'bundler', '~> 1.0'
 
   # = MANIFEST =
   s.files = %w[
     Gemfile
-    README
+    README.md
     Rakefile
+    benchmarking/.jrubyrc
     benchmarking/benchmark.rb
     jrjackson.gemspec
     lib/jrjackson.rb
-    lib/jrjackson/jackson-core-asl-1.9.5.jar
-    lib/jrjackson/jackson-mapper-asl-1.9.5.jar
-    lib/jrjackson/jackson-smile-1.9.5.jar
+    lib/jrjackson/jars/jrjackson-1.0.jar
     lib/jrjackson/jrjackson.rb
-    lib/jrjackson/rubify.rb
-    lib/jrjackson/rubify_with_symbol_keys.rb
     lib/jrjackson/version.rb
-    lib/jrjackson_r.rb
-    lib/jrjackson_r_sym.rb
+    lib/require_relative_patch.rb
+    pom.xml
     profiling/profiled.rb
+    src/main/java/com/jrjackson/JrJacksonRaw.java
+    src/main/java/com/jrjackson/JrJacksonService.java
+    src/main/java/com/jrjackson/JrJacksonStr.java
+    src/main/java/com/jrjackson/JrJacksonSym.java
+    src/main/java/com/jrjackson/ParseError.java
+    src/main/java/com/jrjackson/RubyObjectDeserializer.java
+    src/main/java/com/jrjackson/RubyObjectSymDeserializer.java
   ]
   # = MANIFEST =
 
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-
-  s.add_development_dependency  'awesome_print',      '~> 0.4.0'
-
 end

data/lib/jrjackson.rb

@@ -1,10 +1,2 @@
-unless RUBY_PLATFORM =~ /java/
-  error "This library is only compatible with a java-based ruby environment like JRuby."
-  exit 255
-end
-
-require 'java'
-
-$CLASSPATH << 'jrjackson'
-
-require File.join("jrjackson","jrjackson")
+require "require_relative_patch" unless Kernel.respond_to?(:require_relative)
+require_relative "jrjackson/jrjackson"

data/lib/jrjackson/jrjackson.rb

@@ -1,41 +1,51 @@
-%W(jackson-core-asl-1.9.5.jar jackson-mapper-asl-1.9.5.jar jackson-smile-1.9.5.jar).each {|f| require File.join("jrjackson",f)}
+unless RUBY_PLATFORM =~ /java/
+  puts "This library is only compatible with a java-based ruby environment like JRuby."
+  exit 255
+end
 
-module JrJackson
-  include_package "org.codehaus.jackson"
-  include_package "org.codehaus.jackson.map"
-  include_package "org.codehaus.jackson.smile"
+require_relative "jars/jrjackson-1.0.jar"
+require 'com/jrjackson/jr_jackson'
 
-  Jclass = java.lang.Object.java_class
+module JrJackson
+  module Json
+      class << self
+      TIME_REGEX = %r(\A\d{4}-\d\d-\d\d\s\d\d:\d\d:\d\d)
+      def load(json_string, options = {})
+        mod = if options[:raw]
+          JrJackson::Raw
+        elsif options[:symbolize_keys]
+          JrJackson::Sym
+        else
+          JrJackson::Str
+        end
+        if json_string.is_a?(String) && json_string =~ TIME_REGEX
+          mod.parse("\"#{json_string}\"")
+        else
+          mod.parse(json_string)
+        end
+      end
 
-  Mapper = ObjectMapper.new
-  SmileMapper = ObjectMapper.new(SmileFactory.new)
+      def dump(object)
+        case object
+        when Array, Hash
+          JrJackson::Raw.generate(object)
+        when String
+          "\"#{object}\""
+        when nil, true, false
+          object
+        else
+          if object.respond_to?(:to_json)
+            object.to_json
+          elsif object.respond_to?(:to_s)
+            object.to_s
+          else
+            object
+          end
+        end
+      end
 
-  module Json
-    def self.parse(json_string)
-      Mapper.read_value json_string, Jclass
-    end
-    def self.generate(object)
-      Mapper.writeValueAsString(object)
-    end
-    def self.load(json_string)
-      Mapper.read_value json_string, Jclass
-    end
-    def self.dump(object)
-      Mapper.writeValueAsString(object)
-    end
-  end
-  module Smile
-    def self.parse(smile_bytes)
-      SmileMapper.read_value smile_bytes,0,smile_bytes.size, Jclass
-    end
-    def self.generate(object)
-      SmileMapper.writeValueAsBytes(object)
-    end
-    def self.load(smile_bytes)
-      SmileMapper.read_value smile_bytes,0,smile_bytes.size, Jclass
-    end
-    def self.dump(object)
-      SmileMapper.writeValueAsBytes(object)
+      alias :parse :load
+      alias :generate :dump
     end
   end
 end

data/lib/jrjackson/version.rb

@@ -1,4 +1,4 @@
 
 module JrJackson
-  VERSION = '0.0.7'
+  VERSION = '0.1.0'
 end

data/lib/require_relative_patch.rb

@@ -0,0 +1,6 @@
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+  

data/pom.xml

@@ -0,0 +1,86 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>com.jrjackson.jruby</groupId>
+  <artifactId>jrjackson</artifactId>
+  <packaging>jar</packaging>
+  <version>1.0</version>
+  <name>jrjackson</name>
+  <url>http://maven.apache.org</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.jruby</groupId>
+      <artifactId>jruby</artifactId>
+      <version>1.7.3</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-core</artifactId>
+      <version>2.1.4</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-annotations</artifactId>
+      <version>2.1.4</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.1.4</version>
+    </dependency>
+  </dependencies>
+  <build>
+    <plugins>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-compiler-plugin</artifactId>
+          <version>3.0</version>
+          <configuration>
+            <source>1.6</source>
+            <target>1.6</target>
+          </configuration>
+        </plugin>
+        <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-surefire-plugin</artifactId>
+            <version>2.12.2</version>
+            <configuration>
+                <parallel>methods</parallel>
+                <threadCount>10</threadCount>
+            </configuration>
+        </plugin>
+        <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-shade-plugin</artifactId>
+            <version>1.6</version>
+            <executions>
+                <execution>
+                    <phase>package</phase>
+                    <goals>
+                        <goal>shade</goal>
+                    </goals>
+                    <configuration>
+                        <artifactSet>
+                            <excludes>
+                                <exclude>org.jruby:jruby</exclude>
+                            </excludes>
+                        </artifactSet>
+                    </configuration>
+                </execution>
+            </executions>
+        </plugin>
+    </plugins>
+  </build>
+</project>

data/src/main/java/com/jrjackson/JrJacksonRaw.java

@@ -0,0 +1,76 @@
+package com.jrjackson;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubyIO;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.ext.stringio.RubyStringIO;
+import org.jruby.java.addons.IOJavaAddons;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.RubyDateFormat;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.text.DateFormat;
+import java.util.*;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+@JRubyModule(name = "JrJacksonRaw")
+public class JrJacksonRaw extends RubyObject {
+  protected static final ObjectMapper mapper = new ObjectMapper();
+
+  static {
+    mapper.setDateFormat(new RubyDateFormat("yyyy-MM-dd HH:mm:ss z", Locale.US, true));
+  }
+
+  public JrJacksonRaw(Ruby ruby, RubyClass metaclass) {
+    super(ruby, metaclass);
+  }
+
+  @JRubyMethod(module = true, name = {"parse", "load"}, required = 1)
+  public static IRubyObject parse(ThreadContext context, IRubyObject self, IRubyObject arg) {
+    Ruby ruby = context.getRuntime();
+    try {
+      Object o;
+      if (arg instanceof RubyString) {
+        o = mapper.readValue(arg.toString(), Object.class);
+      } else if ((arg instanceof RubyIO) || (arg instanceof RubyStringIO)) {
+        IRubyObject stream = IOJavaAddons.AnyIO.any_to_inputstream(context, arg);
+        o =  mapper.readValue((InputStream)stream.toJava(InputStream.class), Object.class);
+      } else {
+        throw ruby.newArgumentError("Unsupported source. This method accepts String or IO");
+      }
+      return (RubyObject)JavaUtil.convertJavaToRuby(ruby, o);
+    }
+    catch (JsonProcessingException e) {
+      throw ParseError.newParseError(ruby, e.getLocalizedMessage());
+    }
+    catch (IOException e) {
+      throw ruby.newIOError(e.getLocalizedMessage());
+    }
+  }
+
+  @JRubyMethod(module = true, name = {"generate", "dump"}, required = 1)
+  public static IRubyObject generate(ThreadContext context, IRubyObject self, IRubyObject arg) {
+    Ruby ruby = context.getRuntime();
+    Object obj = arg.toJava(Object.class);
+    try {
+      String s = mapper.writeValueAsString(obj);
+      return ruby.newString(s);
+    }
+    catch (JsonProcessingException e) {
+      throw ParseError.newParseError(ruby, e.getLocalizedMessage());
+    }
+    catch (IOException e) {
+      throw ruby.newIOError(e.getLocalizedMessage());
+    }
+  }
+}