msgpack-jruby 1.3.1-java → 1.3.2-java

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-  VERSION = '1.3.1'
+  VERSION = '1.3.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack-jruby
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
   prerelease:
 platform: java
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-02-19 00:00:00.000000000 Z
+date: 2013-02-21 00:00:00.000000000 Z
 dependencies: []
 description: JRuby compatible MessagePack implementation that does not use FFI
 email:
@@ -18,29 +18,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".rvmrc"
-- ".travis.yml"
-- Gemfile
-- Gemfile.lock
-- README.mdown
-- Rakefile
-- ext/.gitignore
-- ext/java/MsgpackJrubyService.java
-- ext/java/org/msgpack/jruby/MessagePackLibrary.java
-- ext/java/org/msgpack/jruby/RubyObjectPacker.java
-- ext/java/org/msgpack/jruby/RubyObjectUnpacker.java
-- lib/ext/javassist-3.15.0-GA.jar
-- lib/ext/msgpack-0.6.6.jar
 - lib/msgpack.rb
 - lib/msgpack/version.rb
-- msgpack-jruby.gemspec
-- spec/benchmarks/shootout_bm.rb
-- spec/benchmarks/symbolize_keys_bm.rb
-- spec/msgpack/unpacker_spec.rb
-- spec/msgpack_spec.rb
-- spec/spec_helper.rb
+- lib/ext/javassist-3.15.0-GA.jar
+- lib/ext/msgpack-0.6.6.jar
+- lib/ext/msgpack_jruby.jar
 homepage: http://github.com/iconara/msgpack-jruby
 licenses: []
 post_install_message:

data/.gitignore

@@ -1,5 +0,0 @@
-*.gem
-.bundle
-pkg/*
-/benchmark
-/lib/ext/msgpack_jruby.jar

data/.rspec

@@ -1,4 +0,0 @@
--Ilib
---color
---format doc
-spec

data/.rvmrc

@@ -1,3 +0,0 @@
-rvm jruby-1.6.7 gemset create msgpack-jruby
-rvm jruby-1.7.2 gemset create msgpack-jruby
-rvm use jruby-1.7.2@msgpack-jruby

data/.travis.yml

@@ -1,11 +0,0 @@
-language: ruby
-rvm:
-  - jruby-18mode
-  - jruby-19mode
-  - jruby-1.7.0
-  - jruby-head
-jdk:
-  - openjdk7
-  - oraclejdk7
-  - openjdk6
-bundler_args: --without development

data/Gemfile

@@ -1,19 +0,0 @@
-source :rubygems
-
-gemspec
-
-gem 'rake'
-
-group :development do
-  gem 'jruby-openssl'
-  gem 'viiite'
-  gem 'ffi-ncurses'
-  gem 'bson'
-  gem 'bson_ext', :platforms => :mri
-  gem 'json'
-  gem 'msgpack', :platforms => :mri
-end
-
-group :test do
-  gem 'rspec'
-end

data/Gemfile.lock

@@ -1,60 +0,0 @@
-PATH
-  remote: .
-  specs:
-    msgpack-jruby (1.3.1-java)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    alf (0.10.1)
-      highline (~> 1.6.2)
-      myrrha (~> 1.2.1)
-      quickl (~> 0.4.1)
-    bouncy-castle-java (1.5.0146.1)
-    bson (1.5.2)
-    bson (1.5.2-java)
-    bson_ext (1.5.2)
-      bson (= 1.5.2)
-    diff-lcs (1.1.3)
-    ffi (1.0.9)
-    ffi (1.0.9-java)
-    ffi-ncurses (0.3.3)
-      ffi (>= 0.6.3)
-    gnuplot (2.3.6)
-    highline (1.6.2)
-    jruby-openssl (0.7.4)
-      bouncy-castle-java
-    json (1.5.0)
-    json (1.5.0-java)
-    msgpack (0.4.6)
-    myrrha (1.2.1)
-    quickl (0.4.1)
-    rake (10.0.2)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.4)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
-    viiite (0.1.0)
-      alf (~> 0.10.0)
-      gnuplot (~> 2.3.6)
-      quickl (~> 0.4.0)
-
-PLATFORMS
-  java
-  ruby
-
-DEPENDENCIES
-  bson
-  bson_ext
-  ffi-ncurses
-  jruby-openssl
-  json
-  msgpack
-  msgpack-jruby!
-  rake
-  rspec
-  viiite

data/README.mdown

@@ -1,26 +0,0 @@
-# MessagePack for JRuby
-
-A MessagePack implementation for JRuby, built on top of the MessagePack Java libraries. Faster and easier to use than using the C MessagePack gem in JRuby.
-
-## Installation
-
-    gem install msgpack-jruby
-
-or with Bundler
-
-    gem 'msgpack-jruby', :require => 'msgpack'
-
-## Extra features
-
-* Decode keys as symbols by passing `:symbolize_keys => true` to `#unpack`.
-* Decode strings with their right encoding by passing `:encoding => Encoding::UTF_8` to `#unpack`.
-
-## Copyright
-
-Copyright 2012 Theo Hultberg
-
-_Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License You may obtain a copy of the License at_
-
-[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
-
-_Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License._

data/Rakefile

@@ -1,64 +0,0 @@
-$: << 'lib'
-
-require 'bundler/setup'
-require 'rspec/core/rake_task'
-require 'msgpack/version'
-
-
-task :default => :spec
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :spec => :package
-
-task :clean do
-  rm Dir['ext/java/**/*.class']
-end
-
-task :compile do
-  classpath = (Dir["lib/ext/*.jar"] + ["#{ENV['MY_RUBY_HOME']}/lib/jruby.jar"]).join(':')
-  system %(javac -Xlint:-options -source 1.6 -target 1.6 -cp #{classpath} ext/java/*.java ext/java/org/msgpack/jruby/*.java)
-  exit($?.exitstatus) unless $?.success?
-end
-
-task :package => :compile do
-  class_files = Dir['ext/java/**/*.class'].map { |path| path = path.sub('ext/java/', ''); "-C ext/java '#{path}'" }
-  system %(jar cf lib/ext/msgpack_jruby.jar #{class_files.join(' ')})
-  exit($?.exitstatus) unless $?.success?
-end
-
-task :release => :package do
-  version_string = "v#{MessagePack::VERSION}"
-  unless %x(git tag -l).include?(version_string)
-    system %(git tag -a #{version_string} -m #{version_string})
-  end
-  system %(gem build msgpack-jruby.gemspec && gem push msgpack-jruby-*.gem && mv msgpack-jruby-*.gem pkg)
-end
-
-namespace :benchmark do
-  BENCHMARK_RUBIES = ['1.9.2-p0', 'jruby-1.6.5', 'jruby-head']
-  BENCHMARK_GEMSET = 'msgpack-jruby-benchmarking'
-  BENCHMARK_FILE = 'spec/benchmarks/shootout_bm.rb'
-
-  task :run do
-    rubies = BENCHMARK_RUBIES.map { |rb| "#{rb}@#{BENCHMARK_GEMSET}" }
-    cmd = %(rvm #{rubies.join(',')} exec viiite run #{BENCHMARK_FILE} | tee benchmark | viiite report --hierarchy --regroup=bench,lib,ruby)
-    puts cmd
-    system cmd
-  end
-
-  task :quick do
-    cmd = %(IMPLEMENTATIONS=msgpack viiite run #{BENCHMARK_FILE} | viiite report --hierarchy --regroup=bench)
-    puts cmd
-    system cmd
-  end
-
-  task :setup do
-    rubies = BENCHMARK_RUBIES.map { |rb| "#{rb}@#{BENCHMARK_GEMSET}" }
-    rubies.each do |ruby_version|
-      cmd = %(rvm-shell #{ruby_version} -c 'bundle check || bundle install')
-      puts cmd
-      system cmd
-    end
-  end
-end

data/ext/.gitignore

@@ -1 +0,0 @@
-*.class

data/ext/java/MsgpackJrubyService.java

@@ -1,15 +0,0 @@
-import java.io.IOException;
-        
-import org.jruby.Ruby;
-import org.jruby.runtime.load.BasicLibraryService;
-
-import org.msgpack.jruby.MessagePackLibrary;
-
-
-public class MsgpackJrubyService implements BasicLibraryService {
-  public boolean basicLoad(final Ruby runtime) throws IOException {
-    new MessagePackLibrary().load(runtime, false);
-    return true;
-  }
-}
-

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

@@ -1,245 +0,0 @@
-package org.msgpack.jruby;
-
-
-import java.io.InputStream;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-
-import org.jruby.Ruby;
-import org.jruby.RubyModule;
-import org.jruby.RubyClass;
-import org.jruby.RubyString;
-import org.jruby.RubyObject;
-import org.jruby.RubyHash;
-import org.jruby.RubyIO;
-import org.jruby.RubyStringIO;
-import org.jruby.RubyNumeric;
-import org.jruby.RubyEnumerator;
-import org.jruby.runtime.load.Library;
-import org.jruby.runtime.callback.Callback;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.runtime.Arity;
-import org.jruby.runtime.Block;
-import org.jruby.runtime.ObjectAllocator;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.anno.JRubyClass;
-import org.jruby.anno.JRubyModule;
-import org.jruby.anno.JRubyMethod;
-import org.jruby.util.IOInputStream;
-
-import static org.jruby.runtime.Visibility.*;
-
-import org.msgpack.MessagePack;
-import org.msgpack.packer.BufferPacker;
-import org.msgpack.packer.Packer;
-import org.msgpack.unpacker.MessagePackBufferUnpacker;
-import org.msgpack.unpacker.MessagePackUnpacker;
-import org.msgpack.unpacker.UnpackerIterator;
-import org.msgpack.type.Value;
-import org.msgpack.io.Input;
-import org.msgpack.io.LinkedBufferInput;
-import org.msgpack.io.StreamInput;
-
-
-public class MessagePackLibrary implements Library {
-  public void load(Ruby runtime, boolean wrap) throws IOException {
-    MessagePack msgPack = new MessagePack();
-    RubyModule msgpackModule = runtime.defineModule("MessagePack");
-    msgpackModule.defineAnnotatedMethods(MessagePackModule.class);
-    RubyClass standardErrorClass = runtime.getStandardError();
-    RubyClass unpackErrorClass = msgpackModule.defineClassUnder("UnpackError", standardErrorClass, standardErrorClass.getAllocator());
-    RubyClass unpackerClass = msgpackModule.defineClassUnder("Unpacker", runtime.getObject(), new UnpackerAllocator(msgPack));
-    unpackerClass.defineAnnotatedMethods(Unpacker.class);
-  }
-
-  @JRubyModule(name = "MessagePack")
-  public static class MessagePackModule {
-    private static MessagePack msgPack = new MessagePack();
-    private static RubyObjectPacker packer = new RubyObjectPacker(msgPack);
-    private static RubyObjectUnpacker unpacker = new RubyObjectUnpacker(msgPack);
-    
-    @JRubyMethod(module = true, required = 1)
-    public static IRubyObject pack(ThreadContext ctx, IRubyObject recv, IRubyObject obj) throws IOException {
-      return packer.pack(obj);
-    }
-    
-    @JRubyMethod(module = true, required = 1, optional = 1)
-    public static IRubyObject unpack(ThreadContext ctx, IRubyObject recv, IRubyObject[] args) throws IOException {
-      RubyHash options = (args.length == 2) ? (RubyHash) args[1] : null;
-      RubyString str = args[0].asString();
-      return unpacker.unpack(str, options);
-    }
-  }
-
-  private static class UnpackerAllocator implements ObjectAllocator {
-    private MessagePack msgPack;
-      
-    public UnpackerAllocator(MessagePack msgPack) {
-      this.msgPack = msgPack;
-    }
-      
-    public IRubyObject allocate(Ruby runtime, RubyClass klass) {
-      return new Unpacker(runtime, klass, msgPack);
-    }
-  }
-
-  @JRubyClass(name="MessagePack::Unpacker")
-  public static class Unpacker extends RubyObject {
-    private MessagePack msgPack;
-    private RubyObjectUnpacker rubyObjectUnpacker;
-    private MessagePackBufferUnpacker bufferUnpacker;
-    private MessagePackUnpacker streamUnpacker;
-    private UnpackerIterator unpackerIterator;
-    private IRubyObject stream;
-    private IRubyObject data;
-    private RubyObjectUnpacker.CompiledOptions options;
-    
-    public Unpacker(Ruby runtime, RubyClass type, MessagePack msgPack) {
-      super(runtime, type);
-      this.msgPack = msgPack;
-      this.rubyObjectUnpacker = new RubyObjectUnpacker(msgPack);
-      this.bufferUnpacker = null;
-      this.streamUnpacker = null;
-      this.stream = null;
-      this.data = null;
-    }
-
-    @JRubyMethod(name = "initialize", optional = 2, visibility = PRIVATE)
-    public IRubyObject initialize(ThreadContext ctx, IRubyObject[] args) {
-      if (args.length == 0) {
-        options = new RubyObjectUnpacker.CompiledOptions();
-      } else if (args.length == 1 && args[0] instanceof RubyHash) {
-        options = new RubyObjectUnpacker.CompiledOptions((RubyHash) args[0]);
-      } else if (args.length > 0) {
-        setStream(ctx, args[0]);
-        if (args.length > 2) {
-          options = new RubyObjectUnpacker.CompiledOptions((RubyHash) args[1]);
-        } else {
-          options = new RubyObjectUnpacker.CompiledOptions();
-        }
-      }
-      return this;
-    }
-
-    @JRubyMethod(required = 2)
-    public IRubyObject execute(ThreadContext ctx, IRubyObject data, IRubyObject offset) {
-      return executeLimit(ctx, data, offset, null);
-    }
-
-    @JRubyMethod(name = "execute_limit", required = 3)
-    public IRubyObject executeLimit(ThreadContext ctx, IRubyObject data, IRubyObject offset, IRubyObject limit) {
-      this.data = null;
-      try {
-        int jOffset = RubyNumeric.fix2int(offset);
-        int jLimit = -1;
-        if (limit != null) {
-          jLimit = RubyNumeric.fix2int(limit);
-        }
-        byte[] bytes = data.asString().getBytes();
-        MessagePackBufferUnpacker localBufferUnpacker = new MessagePackBufferUnpacker(msgPack, bytes.length);
-        localBufferUnpacker.wrap(bytes, jOffset, jLimit == -1 ? bytes.length - jOffset : jLimit);
-        this.data = rubyObjectUnpacker.valueToRubyObject(ctx.getRuntime(), localBufferUnpacker.readValue(), options);
-        return ctx.getRuntime().newFixnum(jOffset + localBufferUnpacker.getReadByteCount());
-      } catch (IOException ioe) {
-        // TODO: how to throw Ruby exceptions?
-        return ctx.getRuntime().getNil();
-      }
-    }
-
-    @JRubyMethod(name = "data")
-    public IRubyObject getData(ThreadContext ctx) {
-      if (data == null) {
-        return ctx.getRuntime().getNil();
-      } else {
-        return data;
-      }
-    }
-
-    @JRubyMethod(name = "finished?")
-    public IRubyObject finished_q(ThreadContext ctx) {
-      return data == null ? ctx.getRuntime().getFalse() : ctx.getRuntime().getTrue();
-    }
-
-    @JRubyMethod(required = 1)
-    public IRubyObject feed(ThreadContext ctx, IRubyObject data) {
-      streamUnpacker = null;
-      byte[] bytes = data.asString().getBytes();
-      if (bufferUnpacker == null) {
-        bufferUnpacker = new MessagePackBufferUnpacker(msgPack);
-        unpackerIterator = bufferUnpacker.iterator();
-      }
-      bufferUnpacker.feed(bytes);
-      return ctx.getRuntime().getNil();
-    }
-
-    @JRubyMethod(name = "feed_each", required = 1)
-    public IRubyObject feedEach(ThreadContext ctx, IRubyObject data, Block block) {
-      feed(ctx, data);
-      each(ctx, block);
-      return ctx.getRuntime().getNil();
-    }
-    
-    @JRubyMethod
-    public IRubyObject each(ThreadContext ctx, Block block) {
-      MessagePackUnpacker localUnpacker = null;
-      if (bufferUnpacker == null && streamUnpacker != null) {
-        localUnpacker = streamUnpacker;
-      } else if (bufferUnpacker != null) {
-        localUnpacker = bufferUnpacker;
-      } else {
-        return ctx.getRuntime().getNil();
-      }
-      if (block.isGiven()) {
-        while (unpackerIterator.hasNext()) {
-          Value value = unpackerIterator.next();
-          IRubyObject rubyObject = rubyObjectUnpacker.valueToRubyObject(ctx.getRuntime(), value, options);
-          block.yield(ctx, rubyObject);
-        }
-        return ctx.getRuntime().getNil();
-      } else {
-        return RubyEnumerator.RubyEnumeratorKernel.obj_to_enum(ctx, this);
-      }
-    }
-
-    @JRubyMethod
-    public IRubyObject fill(ThreadContext ctx) {
-      return ctx.getRuntime().getNil();
-    }
-
-    @JRubyMethod
-    public IRubyObject reset(ThreadContext ctx) {
-      if (bufferUnpacker != null) {
-        bufferUnpacker.reset();
-      }
-      if (streamUnpacker != null) {
-        streamUnpacker.reset();
-      }
-      return ctx.getRuntime().getNil();
-    }
-
-    @JRubyMethod(name = "stream")
-    public IRubyObject getStream(ThreadContext ctx) {
-      if (stream == null) {
-        return ctx.getRuntime().getNil();
-      } else {
-        return stream;
-      }
-    }
-
-    @JRubyMethod(name = "stream=", required = 1)
-    public IRubyObject setStream(ThreadContext ctx, IRubyObject stream) {
-      bufferUnpacker = null;
-      this.stream = stream;
-      if (stream instanceof RubyStringIO) {
-        // TODO: RubyStringIO returns negative numbers when read through IOInputStream#read
-        IRubyObject str = ((RubyStringIO) stream).string();
-        byte[] bytes = ((RubyString) str).getBytes();
-        streamUnpacker = new MessagePackUnpacker(msgPack, new ByteArrayInputStream(bytes));
-      } else {
-        streamUnpacker = new MessagePackUnpacker(msgPack, new IOInputStream(stream));
-      }
-      unpackerIterator = streamUnpacker.iterator();
-      return getStream(ctx);
-    }
-  }
-}

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

@@ -1,110 +0,0 @@
-package org.msgpack.jruby;
-
-
-import java.io.IOException;
-
-import org.msgpack.MessagePack;
-import org.msgpack.packer.BufferPacker;
-
-import org.jruby.RubyObject;
-import org.jruby.RubyNil;
-import org.jruby.RubyBoolean;
-import org.jruby.RubyBignum;
-import org.jruby.RubyInteger;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyFloat;
-import org.jruby.RubyString;
-import org.jruby.RubySymbol;
-import org.jruby.RubyArray;
-import org.jruby.RubyHash;
-import org.jruby.runtime.builtin.IRubyObject;
-
-
-public class RubyObjectPacker {
-  private final MessagePack msgPack;
-
-  public RubyObjectPacker(MessagePack msgPack) {
-    this.msgPack = msgPack;
-  }
-
-  public RubyString pack(IRubyObject o) throws IOException {
-    return RubyString.newString(o.getRuntime(), packRaw(o));
-  }
-
-  public byte[] packRaw(IRubyObject o) throws IOException {
-    BufferPacker packer = msgPack.createBufferPacker();
-    write(packer, o);
-    return packer.toByteArray();
-  }
-
-  private void write(BufferPacker packer, IRubyObject o) throws IOException {
-    if (o == null || o instanceof RubyNil) {
-      packer.writeNil();
-    } else if (o instanceof RubyBoolean) {
-      packer.write(((RubyBoolean) o).isTrue());
-    } else if (o instanceof RubyBignum) {
-      write(packer, (RubyBignum) o);
-    } else if (o instanceof RubyInteger) {
-      write(packer, (RubyInteger) o);
-    } else if (o instanceof RubyFixnum) {
-      write(packer, (RubyFixnum) o);
-    } else if (o instanceof RubyFloat) {
-      write(packer, (RubyFloat) o);
-    } else if (o instanceof RubyString) {
-      write(packer, (RubyString) o);
-    } else if (o instanceof RubySymbol) {
-      write(packer, (RubySymbol) o);
-    } else if (o instanceof RubyArray) {
-      write(packer, (RubyArray) o);
-    } else if (o instanceof RubyHash) {
-      write(packer, (RubyHash) o);
-    } else {
-      throw o.getRuntime().newArgumentError(String.format("Cannot pack type: %s", o.getClass().getName()));
-    }
-  }
-
-  private void write(BufferPacker packer, RubyBignum bignum) throws IOException {
-    packer.write(bignum.getBigIntegerValue());
-  }
-
-  private void write(BufferPacker packer, RubyInteger integer) throws IOException {
-    packer.write(integer.getLongValue());
-  }
-
-  private void write(BufferPacker packer, RubyFixnum fixnum) throws IOException {
-    packer.write(fixnum.getLongValue());
-  }
-
-  private void write(BufferPacker packer, RubyFloat flt) throws IOException {
-    packer.write(flt.getDoubleValue());
-  }
-
-  private void write(BufferPacker packer, RubyString str) throws IOException {
-    packer.write(str.getBytes());
-  }
-
-  private void write(BufferPacker packer, RubySymbol sym) throws IOException {
-    write(packer, (RubyString) sym.to_s());
-  }
-
-  private void write(BufferPacker packer, RubyArray array) throws IOException {
-    int count = array.size();
-    packer.writeArrayBegin(count);
-    for (int i = 0; i < count; i++) {
-      write(packer, (RubyObject) array.entry(i));
-    }
-    packer.writeArrayEnd();
-  }
-
-  private void write(BufferPacker packer, RubyHash hash) throws IOException {
-    int count = hash.size();
-    packer.writeMapBegin(count);
-    RubyArray keys = hash.keys();
-    RubyArray values = hash.rb_values();
-    for (int i = 0; i < count; i++) {
-      write(packer, (RubyObject) keys.entry(i));
-      write(packer, (RubyObject) values.entry(i));
-    }
-    packer.writeMapEnd();
-  }
-}

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

@@ -1,158 +0,0 @@
-package org.msgpack.jruby;
-
-
-import java.io.IOException;
-
-import org.msgpack.MessagePack;
-import org.msgpack.MessageTypeException;
-import org.msgpack.unpacker.MessagePackBufferUnpacker;
-import org.msgpack.type.Value;
-import org.msgpack.type.ValueType;
-import org.msgpack.type.BooleanValue;
-import org.msgpack.type.IntegerValue;
-import org.msgpack.type.FloatValue;
-import org.msgpack.type.ArrayValue;
-import org.msgpack.type.MapValue;
-import org.msgpack.type.RawValue;
-
-import org.jruby.Ruby;
-import org.jruby.RubyObject;
-import org.jruby.RubyNil;
-import org.jruby.RubyBoolean;
-import org.jruby.RubyBignum;
-import org.jruby.RubyInteger;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyFloat;
-import org.jruby.RubyString;
-import org.jruby.RubySymbol;
-import org.jruby.RubyArray;
-import org.jruby.RubyHash;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.runtime.ThreadContext;
-
-import org.jcodings.Encoding;
-
-
-public class RubyObjectUnpacker {
-  private final MessagePack msgPack;
-
-  public RubyObjectUnpacker(MessagePack msgPack) {
-    this.msgPack = msgPack;
-  }
-
-  public static class CompiledOptions {
-    public final boolean symbolizeKeys;
-    public final Encoding encoding;
-
-    public CompiledOptions() {
-      this(null);
-    }
-
-    public CompiledOptions(RubyHash options) {
-      if (options == null) {
-        symbolizeKeys = false;
-        encoding = null;
-      } else {
-        Ruby runtime = options.getRuntime();
-        ThreadContext ctx = runtime.getCurrentContext();
-        RubySymbol key = runtime.newSymbol("symbolize_keys");
-        IRubyObject value = options.fastARef(key);
-        symbolizeKeys = value != null && value.isTrue();
-        IRubyObject rubyEncoding = options.fastARef(runtime.newSymbol("encoding"));
-        encoding = runtime.getEncodingService().getEncodingFromObject(rubyEncoding);
-      }
-    }
-  }
-
-  public IRubyObject unpack(RubyString str, RubyHash options) throws IOException {
-    return unpack(str.getRuntime(), str.getBytes(), new CompiledOptions(options));
-  }
-
-  public IRubyObject unpack(Ruby runtime, byte[] data, RubyHash options) throws IOException {
-    return unpack(runtime, data, new CompiledOptions(options));
-  }
-
-  public IRubyObject unpack(Ruby runtime, byte[] data, CompiledOptions options) throws IOException {
-    MessagePackBufferUnpacker unpacker = new MessagePackBufferUnpacker(msgPack);
-    unpacker.wrap(data);
-    return valueToRubyObject(runtime, unpacker.readValue(), options);
-  }
-
-  IRubyObject valueToRubyObject(Ruby runtime, Value value, RubyHash options) throws IOException {
-    return valueToRubyObject(runtime, value, new CompiledOptions(options));
-  }
-
-  IRubyObject valueToRubyObject(Ruby runtime, Value value, CompiledOptions options) {
-    switch (value.getType()) {
-    case NIL:
-      return runtime.getNil();
-    case BOOLEAN:
-      return convert(runtime, value.asBooleanValue());
-    case INTEGER:
-      return convert(runtime, value.asIntegerValue());
-    case FLOAT:
-      return convert(runtime, value.asFloatValue());
-    case ARRAY:
-      return convert(runtime, value.asArrayValue(), options);
-    case MAP:
-      return convert(runtime, value.asMapValue(), options);
-    case RAW:
-      return convert(runtime, value.asRawValue(), options);
-    default:
-      throw runtime.newArgumentError(String.format("Unexpected value: %s", value.toString()));
-    }
-  }
-
-  private IRubyObject convert(Ruby runtime, BooleanValue value) {
-    return RubyBoolean.newBoolean(runtime, value.asBooleanValue().getBoolean());
-  }
-
-  private IRubyObject convert(Ruby runtime, IntegerValue value) {
-    // TODO: is there any way of checking for bignums up front?
-    IntegerValue iv = value.asIntegerValue();
-    try {
-      return RubyFixnum.newFixnum(runtime, iv.getLong());
-    } catch (MessageTypeException mte) {
-      return RubyBignum.newBignum(runtime, iv.getBigInteger());
-    }
-  }
-
-  private IRubyObject convert(Ruby runtime, FloatValue value) {
-    return RubyFloat.newFloat(runtime, value.asFloatValue().getDouble());
-  }
-
-  private IRubyObject convert(Ruby runtime, ArrayValue value, CompiledOptions options) {
-    Value[] elements = value.asArrayValue().getElementArray();
-    int elementCount = elements.length;
-    IRubyObject[] rubyObjects = new IRubyObject[elementCount];
-    for (int i = 0; i < elementCount; i++) {
-      rubyObjects[i] = valueToRubyObject(runtime, elements[i], options);
-    }
-    return RubyArray.newArray(runtime, rubyObjects);
-  }
-
-  private IRubyObject convert(Ruby runtime, MapValue value, CompiledOptions options) {
-    Value[] keysAndValues = value.asMapValue().getKeyValueArray();
-    int kvCount = keysAndValues.length;
-    RubyHash hash = RubyHash.newHash(runtime);
-    for (int i = 0; i < kvCount; i += 2) {
-      Value k = keysAndValues[i];
-      Value v = keysAndValues[i + 1];
-      IRubyObject kk = valueToRubyObject(runtime, k, options);
-      IRubyObject vv = valueToRubyObject(runtime, v, options);
-      if (options.symbolizeKeys) {
-        kk = runtime.newSymbol(kk.asString().getByteList());
-      }
-      hash.put(kk, vv);
-    }
-    return hash;
-  }
-
-  private IRubyObject convert(Ruby runtime, RawValue value, CompiledOptions options) {
-    RubyString string = RubyString.newString(runtime, value.asRawValue().getByteArray());
-    if (options.encoding != null) {
-      string.setEncoding(options.encoding);
-    }
-    return string;
-  }
-}

data/msgpack-jruby.gemspec

@@ -1,24 +0,0 @@
-# -*- 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/benchmarks/shootout_bm.rb

@@ -1,73 +0,0 @@
-# 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'
-
-if RUBY_PLATFORM.include?('java')
-  BSON_IMPL = BSON::BSON_JAVA
-else
-  BSON_IMPL = BSON::BSON_C
-end
-
-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
-IMPLEMENTATIONS = ENV.fetch('IMPLEMENTATIONS', 'json,bson,msgpack').split(',').map(&:to_sym)
-
-Viiite.bm do |b|
-  b.variation_point :ruby, Viiite.which_ruby
-  
-  IMPLEMENTATIONS.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_IMPL.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_IMPL.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_IMPL.deserialize(BSON_IMPL.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_IMPL.serialize(BSON_IMPL.deserialize(ENCODED_BSON)).to_s
-        when :json then OBJECT_STRUCTURE.to_json(JSON.parse(ENCODED_JSON))
-        end
-      end
-    end
-  end
-end

data/spec/benchmarks/symbolize_keys_bm.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path('../../../lib', __FILE__)
-
-require 'viiite'
-require 'msgpack'
-
-
-iterations = 10_000
-data = MessagePack.pack(:hello => 'world', :nested => ['structure', {:value => 42}])
-
-Viiite.bm do |b|
-  b.report(:strings) do
-    iterations.times do
-      MessagePack.unpack(data)
-    end
-  end
-
-  b.report(:symbols) do
-    options = {:symbolize_keys => true}
-    iterations.times do
-      MessagePack.unpack(data, options)
-    end
-  end
-end

data/spec/msgpack/unpacker_spec.rb

@@ -1,254 +0,0 @@
-# encoding: ascii-8bit
-
-require 'stringio'
-require 'tempfile'
-require 'spec_helper'
-
-
-describe ::MessagePack::Unpacker do
-  subject do
-    described_class.new
-  end
-  
-  let :buffer1 do
-    MessagePack.pack(:foo => 'bar')
-  end
-    
-  let :buffer2 do
-    MessagePack.pack(:hello => {:world => [1, 2, 3]})
-  end
-    
-  let :buffer3 do
-    MessagePack.pack(:x => 'y')
-  end
-  
-  describe '#execute/#execute_limit/#finished?' do
-    let :buffer do
-      buffer1 + buffer2 + buffer3
-    end
-    
-    it 'extracts an object from the buffer' do
-      subject.execute(buffer, 0)
-      subject.data.should == {'foo' => 'bar'}
-    end
-
-    it 'extracts an object from the buffer, starting at an offset' do
-      subject.execute(buffer, buffer1.length)
-      subject.data.should == {'hello' => {'world' => [1, 2, 3]}}
-    end
-
-    it 'extracts an object from the buffer, starting at an offset reading bytes up to a limit' do
-      subject.execute_limit(buffer, buffer1.length, buffer2.length)
-      subject.data.should == {'hello' => {'world' => [1, 2, 3]}}
-    end
-    
-    it 'extracts nothing if the limit cuts an object in half' do
-      subject.execute_limit(buffer, buffer1.length, 3)
-      subject.data.should be_nil
-    end
-
-    it 'returns the offset where the object ended' do
-      subject.execute(buffer, 0).should == buffer1.length
-      subject.execute(buffer, buffer1.length).should == buffer1.length + buffer2.length
-    end
-    
-    it 'is finished if #data returns an object' do
-      subject.execute_limit(buffer, buffer1.length, buffer2.length)
-      subject.should be_finished
-      
-      subject.execute_limit(buffer, buffer1.length, 3)
-      subject.should_not be_finished
-    end
-  end
-  
-  describe '#each' do
-    context 'with a buffer' do
-      it 'yields each object in the buffer' do
-        objects = []
-        subject.feed(buffer1)
-        subject.feed(buffer2)
-        subject.feed(buffer3)
-        subject.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-      
-      it 'returns an enumerator when no block is given' do
-        subject.feed(buffer1)
-        subject.feed(buffer2)
-        subject.feed(buffer3)
-        enum = subject.each
-        enum.map { |obj| obj.keys.first }.should == %w[foo hello x]
-      end
-    end
-    
-    context 'with a StringIO stream' do
-      it 'yields each object in the stream' do
-        objects = []
-        subject.stream = StringIO.new(buffer1 + buffer2 + buffer3)
-        subject.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-    end
-    
-    context 'with a File stream' do
-      it 'yields each object in the stream' do
-        objects = []
-        file = Tempfile.new('msgpack')
-        file.write(buffer1)
-        file.write(buffer2)
-        file.write(buffer3)
-        file.open
-        subject.stream = file
-        subject.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-    end
-    
-    context 'with a stream passed to the constructor' do
-      it 'yields each object in the stream' do
-        objects = []
-        unpacker = described_class.new(StringIO.new(buffer1 + buffer2 + buffer3))
-        unpacker.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-    end
-  end
-  
-  describe '#feed_each' do
-    it 'feeds the buffer then runs #each' do
-      objects = []
-      subject.feed_each(buffer1 + buffer2 + buffer3) do |obj|
-        objects << obj
-      end
-      objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-    end
-
-    it 'handles chunked data' do
-      objects = []
-      buffer = buffer1 + buffer2 + buffer3
-      buffer.chars.each do |ch|
-        subject.feed_each(ch) do |obj|
-          objects << obj
-        end
-      end
-      objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-    end
-  end
-  
-  describe '#fill' do
-    it 'is a no-op' do
-      subject.stream = StringIO.new(buffer1 + buffer2 + buffer3)
-      subject.fill
-      subject.each { |obj| }
-    end
-  end
-  
-  describe '#reset' do
-    context 'with a buffer' do
-      it 'is unclear what it is supposed to do'
-    end
-    
-    context 'with a stream' do
-      it 'is unclear what it is supposed to do'
-    end
-  end
-
-  context 'regressions' do
-    it 'handles massive arrays (issue #2)' do
-      array = ['foo'] * 10_000
-      MessagePack.unpack(MessagePack.pack(array)).should have(10_000).items
-    end
-  end
-
-  context 'extensions' do
-    context 'symbolized keys' do
-      let :buffer do
-        MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
-      end
-
-      let :unpacker do
-        described_class.new(:symbolize_keys => true)
-      end
-
-      it 'can symbolize keys when using #execute' do
-        unpacker.execute(buffer, 0)
-        unpacker.data.should == {:hello => 'world', :nested => ['object', {:structure => true}]}
-      end
-
-      it 'can symbolize keys when using #each' do
-        objs = []
-        unpacker.feed(buffer)
-        unpacker.each do |obj|
-          objs << obj
-        end
-        objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
-      end
-
-      it 'can symbolize keys when using #feed_each' do
-        objs = []
-        unpacker.feed_each(buffer) do |obj|
-          objs << obj
-        end
-        objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
-      end
-    end
-
-    context 'encoding', :encodings do
-      def flatten(struct, results = [])
-        case struct
-        when Array
-          struct.each { |v| flatten(v, results) }
-        when Hash
-          struct.each { |k, v| flatten(v, flatten(k, results)) }
-        else
-          results << struct
-        end
-        results
-      end
-
-      let :buffer do
-        MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
-      end
-
-      let :unpacker do
-        described_class.new(:encoding => 'UTF-8')
-      end
-
-      it 'can symbolize keys when using #execute' do
-        unpacker.execute(buffer, 0)
-        strings = flatten(unpacker.data).grep(String)
-        strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
-      end
-
-      it 'can symbolize keys when using #each' do
-        objs = []
-        unpacker.feed(buffer)
-        unpacker.each do |obj|
-          objs << obj
-        end
-        strings = flatten(objs).grep(String)
-        strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
-      end
-
-      it 'can symbolize keys when using #feed_each' do
-        objs = []
-        unpacker.feed_each(buffer) do |obj|
-          objs << obj
-        end
-        strings = flatten(objs).grep(String)
-        strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
-      end
-    end
-  end
-end

data/spec/msgpack_spec.rb

@@ -1,95 +0,0 @@
-# encoding: ascii-8bit
-
-require '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 with an unsupported type' do
-      expect { MessagePack.pack(self) }.to raise_error(ArgumentError, /^Cannot pack type:/)
-    end
-    
-    it 'rasies an error on #unpack with garbage' do
-      pending
-      expect { MessagePack.unpack('asdka;sd') }.to raise_error(MessagePack::UnpackError)
-    end
-  end
-
-  context 'extensions' do
-    it 'can unpack hashes with symbolized keys' do
-      packed = MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
-      unpacked = MessagePack.unpack(packed, :symbolize_keys => true)
-      unpacked.should == {:hello => 'world', :nested => ['object', {:structure => true}]}
-    end
-
-    it 'can unpack strings with a specified encoding', :encodings do
-      packed = MessagePack.pack({'hello' => 'world'})
-      unpacked = MessagePack.unpack(packed, :encoding => Encoding::UTF_8)
-      unpacked['hello'].encoding.should == Encoding::UTF_8
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,10 +0,0 @@
-# encoding: utf-8
-
-require 'bundler/setup'
-require 'msgpack'
-
-
-RSpec.configure do |c|
-  c.treat_symbols_as_metadata_keys_with_true_values = true
-  c.filter_run_excluding :encodings => !(defined? Encoding)
-end