msgpack-jruby 1.0.0-java

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/benchmark

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format doc
+

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use jruby-1.6.2@msgpack-jruby

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'viiite'
+  gem 'ffi-ncurses'
+  gem 'bson'
+  gem 'json'
+end

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler'
+
+
+Bundler::GemHelper.install_tasks
+
+task :clean do
+  rm Dir['lib/ext/**/*.class']
+end
+
+task :compile do
+  exec %(javac -source 1.6 -target 1.6 -cp lib/ext/msgpack-0.5.2-devel.jar:$MY_RUBY_HOME/lib/jruby.jar -d lib/ext ext/java/org/msgpack/**/*.java)
+end
+
+BENCHMARK_RUBIES = ['1.9.2-p290', 'jruby-1.6.2', 'jruby-1.6.4']
+BENCHMARK_GEMSET = 'msgpack-jruby-benchmarking'
+
+task :benchmark do
+  rubies = BENCHMARK_RUBIES.map { |rb| "#{rb}@#{BENCHMARK_GEMSET}" }
+  cmd = %(rvm #{rubies.join(',')} exec viiite run spec/benchmark.rb | tee benchmark | viiite report --hierarchy --regroup=bench,ruby)
+  puts cmd
+  system cmd
+end

data/ext/java/org/msgpack/jruby/MessagePack.java

@@ -0,0 +1,156 @@
+package org.msgpack.jruby;
+
+
+import java.io.IOException;
+import java.io.ByteArrayOutputStream;
+import java.math.BigInteger;
+import java.util.Map;
+import java.util.HashMap;
+import java.lang.reflect.Field;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyInteger;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyBignum;
+import org.jruby.RubyNil;
+import org.msgpack.Packer;
+import org.msgpack.Unpacker;
+import org.msgpack.MessagePackObject;
+import org.msgpack.MessageTypeException;
+import org.msgpack.object.MapType;
+
+
+public class MessagePack {
+	private static final MessagePack instance = new MessagePack();
+	
+	public static RubyString pack(RubyObject o) throws IOException {
+		return instance.packObject(o);
+	}
+	
+	public static RubyObject unpack(RubyString s) throws IOException {
+		return instance.unpackString(s);
+	}
+	
+	public RubyString packObject(IRubyObject o) throws IOException {
+		ByteArrayOutputStream stream = new ByteArrayOutputStream();
+		_pack(o, new Packer(stream));
+		Ruby runtime = o == null ? Ruby.getGlobalRuntime() : o.getRuntime();
+		return RubyString.newString(runtime, stream.toByteArray());
+	}
+	
+	private void _pack(IRubyObject o, Packer packer) throws IOException {
+		if (o == null || o instanceof RubyNil) {
+			packer.packNil();
+		} else if (o instanceof RubyBoolean) {
+			packer.packBoolean((Boolean) ((RubyBoolean) o).toJava(Boolean.class));
+		} else if (o instanceof RubyBignum) {
+			packer.packBigInteger(((RubyBignum) o).getBigIntegerValue());
+		} else if (o instanceof RubyInteger) {
+			packer.packLong(((RubyInteger) o).getLongValue());
+		} else if (o instanceof RubyFixnum) {
+			packer.packLong(((RubyFixnum) o).getLongValue());
+		} else if (o instanceof RubyFloat) {
+			packer.packDouble(((RubyFloat) o).getDoubleValue());
+		} else if (o instanceof RubyString) {
+			byte[] bytes = ((RubyString) o).getBytes();
+			packer.packRaw(bytes.length);
+			packer.packRawBody(bytes);
+		} else if (o instanceof RubySymbol) {
+			_pack((IRubyObject) ((RubySymbol) o).to_s(), packer);
+		} else if (o instanceof RubyArray) {
+			RubyArray array = (RubyArray) o;
+			int count = array.size();
+			packer.packArray(count);
+			for (int i = 0; i < count; i++) {
+				_pack(array.entry(i), packer);
+			}
+		} else if (o instanceof RubyHash) {
+			RubyHash hash = (RubyHash) o;
+			int count = hash.size();
+			packer.packMap(count);
+			RubyArray keys = hash.keys();
+			RubyArray values = hash.rb_values();
+			for (int i = 0; i < count; i++) {
+				_pack(keys.entry(i), packer);
+				_pack(values.entry(i), packer);
+			}
+		} else {
+			throw Ruby.getGlobalRuntime().newArgumentError(String.format("Cannot pack type: %s", o.getClass().getName()));
+		}
+	}
+
+	public RubyObject unpackString(RubyString blob) throws IOException {
+		RubyObject obj = null;
+		Unpacker unpacker = new Unpacker();
+		unpacker.wrap(blob.getBytes());
+		return _unpack(unpacker.iterator().next(), blob.getRuntime());
+	}
+	
+	private static Field cachedMapField = null;
+	
+	private RubyObject _unpack(MessagePackObject mpo, Ruby runtime) throws IOException {
+		if (mpo.isNil()) {
+			return null;
+		} else if (mpo.isBooleanType()) {
+			return RubyBoolean.newBoolean(runtime, mpo.asBoolean());
+		} else if (mpo.isIntegerType()) {
+			try {
+				return RubyFixnum.newFixnum(runtime, mpo.asLong());
+			} catch (MessageTypeException mte) {
+				return RubyBignum.newBignum(runtime, mpo.asBigInteger());
+			}
+		} else if (mpo.isFloatType()) {
+			return RubyFloat.newFloat(runtime, mpo.asDouble());
+		} else if (mpo.isArrayType()) {
+			MessagePackObject[] mpoElements = mpo.asArray();
+			RubyObject[] elements = new RubyObject[mpoElements.length];
+			int count = mpoElements.length;
+			for (int i = 0; i < count; i++ ) {
+				elements[i] = _unpack(mpoElements[i], runtime);
+			}
+			return RubyArray.newArray(runtime, elements);
+		} else if (mpo.isMapType()) {
+			// This is hackish, but the only way to make sure that hashes 
+			// keep their order. MessagePack's unpacking subsystem does not 
+			// expose the key/value pair array, only a Map constructed from
+			// that array. This code first attempts to get that array from a
+			// private field, and if that fails it falls back on using the
+			// unordered Map.
+			RubyHash hash = null;
+			try {
+				if (cachedMapField == null) {
+					cachedMapField = mpo.getClass().getDeclaredField("map");
+					cachedMapField.setAccessible(true);
+				}
+				MessagePackObject[] keyValuePairs = (MessagePackObject[]) cachedMapField.get(mpo);
+				int count = keyValuePairs.length;
+				hash = RubyHash.newHash(runtime);
+				for (int i = 0; i < count; i += 2) {
+					hash.put(_unpack(keyValuePairs[i], runtime), _unpack(keyValuePairs[i + 1], runtime));
+				}
+			} catch (IllegalAccessException iae) {
+			} catch (NoSuchFieldException nfe) {
+			}
+			if (hash == null) {
+				Map<MessagePackObject, MessagePackObject> mpoMap = mpo.asMap();
+				hash = RubyHash.newHash(runtime);
+				for (Map.Entry<MessagePackObject, MessagePackObject> entry : mpoMap.entrySet()) {
+					hash.put(_unpack(entry.getKey(), runtime), _unpack(entry.getValue(), runtime));
+				}
+			}
+			return hash;
+			
+		} else if (mpo.isRawType()) {
+			return RubyString.newString(runtime, mpo.asByteArray());
+		} else {
+			throw runtime.newArgumentError(String.format("Cannot upack type: %s", mpo.getClass().getName()));
+		}
+	}
+}

data/lib/msgpack.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'java'
+
+$CLASSPATH << File.expand_path('../ext', __FILE__) << File.expand_path('../ext/msgpack-0.5.2-devel.jar', __FILE__)
+
+MessagePack = org.msgpack.jruby.MessagePack

data/lib/msgpack/version.rb

@@ -0,0 +1,3 @@
+module MessagePack
+  VERSION = '1.0.0'
+end

data/msgpack-jruby.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path('../lib', __FILE__)
+
+require 'msgpack/version'
+
+
+Gem::Specification.new do |s|
+  s.name        = 'msgpack-jruby'
+  s.version     = MessagePack::VERSION
+  s.platform    = 'java'
+  s.authors     = ['Theo Hultberg']
+  s.email       = ['theo@iconara.net']
+  s.homepage    = 'http://github.com/iconara/msgpack-jruby'
+  s.summary     = %q{MessagePack implementation for JRuby}
+  s.description = %q{JRuby compatible MessagePack implementation that does not use FFI}
+
+  s.rubyforge_project = 'msgpack-jruby'
+
+  s.files         = `git ls-files`.split("\n")
+  # 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.require_paths = %w(lib)
+end

data/spec/benchmark.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+if RUBY_PLATFORM.include?('java')
+  # JRuby should use this library, MRI should use the standard gem
+  $: << File.expand_path('../../lib', __FILE__)
+end
+
+require 'viiite'
+require 'msgpack'
+require 'json'
+require 'bson'
+
+
+OBJECT_STRUCTURE = {'x' => ['y', 34, 2**30 + 3, 2.1223423423356, {'hello' => 'world', '5' => [63, 'asjdl']}]}
+ENCODED_MSGPACK = "\x81\xA1x\x95\xA1y\"\xCE@\x00\x00\x03\xCB@\x00\xFA\x8E\x9F9\xFA\xC1\x82\xA5hello\xA5world\xA15\x92?\xA5asjdl"
+ENCODED_BSON = "d\x00\x00\x00\x04x\x00\\\x00\x00\x00\x020\x00\x02\x00\x00\x00y\x00\x101\x00\"\x00\x00\x00\x102\x00\x03\x00\x00@\x013\x00\xC1\xFA9\x9F\x8E\xFA\x00@\x034\x002\x00\x00\x00\x02hello\x00\x06\x00\x00\x00world\x00\x045\x00\x19\x00\x00\x00\x100\x00?\x00\x00\x00\x021\x00\x06\x00\x00\x00asjdl\x00\x00\x00\x00\x00"
+ENCODED_JSON = '{"x":["y",34,1073741827,2.1223423423356,{"hello":"world","5":[63,"asjdl"]}]}'
+ITERATIONS = 1_00_000
+
+Viiite.bm do |b|
+  b.variation_point :ruby, Viiite.which_ruby
+  
+  [:json, :msgpack].each do |lib|
+    b.variation_point :lib, lib
+    
+  
+    b.report(:pack) do
+      ITERATIONS.times do
+        case lib
+        when :msgpack then MessagePack.pack(OBJECT_STRUCTURE)
+        when :bson then BSON::BSON_JAVA.serialize(OBJECT_STRUCTURE).to_s
+        when :json then OBJECT_STRUCTURE.to_json
+        end
+      end
+    end
+  
+    b.report(:unpack) do
+      ITERATIONS.times do
+        case lib
+        when :msgpack then MessagePack.unpack(ENCODED_MSGPACK)
+        when :bson then BSON::BSON_JAVA.deserialize(ENCODED_BSON)
+        when :json then JSON.parse(ENCODED_JSON)
+        end
+      end
+    end
+    
+    b.report(:pack_unpack) do
+      ITERATIONS.times do
+        case lib
+        when :msgpack then MessagePack.unpack(MessagePack.pack(OBJECT_STRUCTURE))
+        when :bson then BSON::BSON_JAVA.deserialize(BSON::BSON_JAVA.serialize(OBJECT_STRUCTURE).to_s)
+        when :json then JSON.parse(OBJECT_STRUCTURE.to_json)
+        end
+      end
+    end
+
+    b.report(:unpack_pack) do
+      ITERATIONS.times do
+        case lib
+        when :msgpack then MessagePack.pack(MessagePack.unpack(ENCODED_MSGPACK))
+        when :bson then BSON::BSON_JAVA.serialize(BSON::BSON_JAVA.deserialize(ENCODED_BSON)).to_s
+        when :json then OBJECT_STRUCTURE.to_json(JSON.parse(ENCODED_JSON))
+        end
+      end
+    end
+  end
+end

data/spec/msgpack_spec.rb

@@ -0,0 +1,76 @@
+# encoding: ascii-8bit
+
+require_relative 'spec_helper'
+
+
+describe MessagePack do
+  tests = {
+    'constant values' => [
+      ['true', true, "\xC3"],
+      ['false', false, "\xC2"],
+      ['nil', nil, "\xC0"]
+    ],
+    'numbers' => [
+      ['zero', 0, "\x00"],
+      ['127', 127, "\x7F"],
+      ['128', 128, "\xCC\x80"],
+      ['256', 256, "\xCD\x01\x00"],
+      ['-1', -1, "\xFF"],
+      ['-33', -33, "\xD0\xDF"],
+      ['-129', -129, "\xD1\xFF\x7F"],
+      ['small integers', 42, "*"],
+      ['medium integers', 333, "\xCD\x01M"],
+      ['large integers', 2**31 - 1, "\xCE\x7F\xFF\xFF\xFF"],
+      ['huge integers', 2**64 - 1, "\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"],
+      ['negative integers', -1, "\xFF"],
+      ['1.0', 1.0, "\xcb\x3f\xf0\x00\x00\x00\x00\x00\x00"],
+      ['small floats', 3.14, "\xCB@\t\x1E\xB8Q\xEB\x85\x1F"],
+      ['big floats', Math::PI * 1_000_000_000_000_000_000, "\xCBC\xC5\xCC\x96\xEF\xD1\x19%"],
+      ['negative floats', -2.1, "\xCB\xC0\x00\xCC\xCC\xCC\xCC\xCC\xCD"]
+    ],
+    'strings' => [
+      ['strings', 'hello world', "\xABhello world"],
+      ['empty strings', '', "\xA0"]
+    ],
+    'arrays' => [
+      ['empty arrays', [], "\x90"],
+      ['arrays with strings', ["hello", "world"], "\x92\xA5hello\xA5world"],
+      ['arrays with mixed values', ["hello", "world", 42], "\x93\xA5hello\xA5world*"],
+      ['arrays of arrays', [[[[1, 2], 3], 4]], "\x91\x92\x92\x92\x01\x02\x03\x04"],
+      ['empty arrays', [], "\x90"]
+    ],
+    'hashes' => [
+      ['empty hashes', {}, "\x80"],
+      ['hashes', {'foo' => 'bar'}, "\x81\xA3foo\xA3bar"],
+      ['hashes with mixed keys and values', {'foo' => 'bar', 3 => 'three', 'four' => 4, 'x' => ['y'], 'a' => 'b'}, "\x85\xA3foo\xA3bar\x03\xA5three\xA4four\x04\xA1x\x91\xA1y\xA1a\xA1b"],
+      ['hashes of hashes', {{'x' => {'y' => 'z'}} => 's'}, "\x81\x81\xA1x\x81\xA1y\xA1z\xA1s"],
+      ['hashes with nils', {'foo' => nil}, "\x81\xA3foo\xC0"]
+    ]
+  }
+
+  tests.each do |ctx, its|
+    context("with #{ctx}") do
+      its.each do |desc, unpacked, packed|
+        it("encodes #{desc}") do
+          MessagePack.pack(unpacked).should == packed
+        end
+      
+        it "decodes #{desc}" do
+          MessagePack.unpack(packed).should == unpacked
+        end
+      end
+    end
+  end
+  
+  context 'with symbols' do
+    it 'encodes symbols as strings' do
+      MessagePack.pack(:symbol).should == "\xA6symbol"
+    end
+  end
+
+  context 'with other things' do
+    it 'raises an error on #pack' do
+      expect { MessagePack.pack(self) }.to raise_error(ArgumentError, /^Cannot pack type:/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'msgpack'

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: msgpack-jruby
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: java
+authors: 
+- Theo Hultberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-15 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: JRuby compatible MessagePack implementation that does not use FFI
+email: 
+- theo@iconara.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Rakefile
+- ext/java/org/msgpack/jruby/MessagePack.java
+- lib/ext/msgpack-0.5.2-devel.jar
+- lib/ext/org/msgpack/jruby/MessagePack.class
+- lib/msgpack.rb
+- lib/msgpack/version.rb
+- msgpack-jruby.gemspec
+- spec/benchmark.rb
+- spec/msgpack_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/iconara/msgpack-jruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: msgpack-jruby
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: MessagePack implementation for JRuby
+test_files: []
+