bones-rpc-adapter-msgpack 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1df5582bead38cbe911c2b8690a6f4d9eab4ff7
-  data.tar.gz: d5afec1dabce19378c0ba82befbc79e1ad7b1ada
+  metadata.gz: c1a820a5d6ab6ad54a540a935c9e3aa952f184ec
+  data.tar.gz: 2c177cbe7c16a83b33b86fe5581529d06c26e4c7
 SHA512:
-  metadata.gz: 7c0ac5acfe09d95783e17261db3252d32262c4ddea24c6e6af65a84ae89ad7715ba7fc3ad555c7976c3b68c34165e6c7b591d64c5a52195c753169bbfdd740cd
-  data.tar.gz: ec3274d024fdf22b5934d5f4ac5385d8e25e1a924f073de73cadaa749621cc04533f10521b85a39194c38c04c935c41b01969664877604871ea887524e7a1c46
+  metadata.gz: 7b7cf534927b6abdd024020db390532d1389866b246c3ef053ce4593d07c7e79c9b23a1e80df030515f994070abeaacedcf218971a9d6090c577e18f51efec42
+  data.tar.gz: 9b3a85d3401427150f6e3136c043da9b215b93201a034d1376462135eb14077e0032be0ae98eb6bb00951e607568d22b7afb9a2158bea82ff982ef44191a2e8b

data/lib/bones/rpc/adapter/msgpack.rb

@@ -1,11 +1,6 @@
 # encoding: utf-8
 require 'bones/rpc/adapter'
-
-if !!(RUBY_PLATFORM =~ /java/)
-  require 'msgpack-jruby'
-else
-  require 'msgpack'
-end
+require 'msgpack'
 
 module Bones
   module RPC
@@ -32,23 +27,39 @@ module Bones
         end
 
         def unpacker(data)
-          ::MessagePack::Unpacker.new(StringIO.new(data))
+          Unpacker.new(StringIO.new(data))
         end
 
         def parser(data)
           Adapter::Parser.new(self, data)
         end
 
-        def unpacker_pos(parser)
-          size = parser.unpacker.buffer.size
-          pos  = parser.unpacker.buffer.io.pos
-          (pos > size) ? (pos - size) : 0
-        end
+        if !!(RUBY_PLATFORM =~ /java/)
+          require 'bones/rpc/adapter/msgpack/ruby'
+          Unpacker = Bones::RPC::Adapter::Msgpack::Ruby::Decoder
+
+          def unpacker_pos(parser)
+            parser.unpacker.buffer.pos
+          end
+
+          def unpacker_seek(parser, n)
+            parser.unpacker.buffer.seek(n)
+            return n
+          end
+        else
+          Unpacker = ::MessagePack::Unpacker
+
+          def unpacker_pos(parser)
+            size = parser.unpacker.buffer.size
+            pos  = parser.unpacker.buffer.io.pos
+            (pos > size) ? (pos - size) : 0
+          end
 
-        def unpacker_seek(parser, n)
-          pos = unpacker_pos(parser)
-          parser.unpacker.buffer.skip(n - pos) if pos < n
-          return pos
+          def unpacker_seek(parser, n)
+            pos = unpacker_pos(parser)
+            parser.unpacker.buffer.skip(n - pos) if pos < n
+            return pos
+          end
         end
 
         Adapter.register self

data/lib/bones/rpc/adapter/msgpack/ruby.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+
+module Bones
+  module RPC
+    module Adapter
+      module Msgpack
+        module Ruby
+          def self.unpack(bytes)
+            Decoder.new(bytes).next
+          end
+
+          class Decoder
+            attr_reader :buffer
+
+            def initialize(buffer)
+              @buffer = ::Bones::RPC::Parser::Buffer.new(buffer)
+            end
+
+            def next
+              buffer.transaction do
+                consume_next
+              end
+            rescue TypeError
+              raise EOFError
+            end
+            alias :read :next
+
+            private
+
+            DECODINGS = []
+            DECODINGS[0xc0] = lambda { |d| nil }
+            DECODINGS[0xc2] = lambda { |d| false }
+            DECODINGS[0xc3] = lambda { |d| true }
+            DECODINGS[0xc4] = lambda { |d| d.consume_string(d.consume_byte, Encoding::BINARY) }
+            DECODINGS[0xc5] = lambda { |d| d.consume_string(d.consume_int16, Encoding::BINARY) }
+            DECODINGS[0xc6] = lambda { |d| d.consume_string(d.consume_int32, Encoding::BINARY) }
+            DECODINGS[0xca] = lambda { |d| d.consume_float }
+            DECODINGS[0xcb] = lambda { |d| d.consume_double }
+            DECODINGS[0xcc] = lambda { |d| d.consume_byte }
+            DECODINGS[0xcd] = lambda { |d| d.consume_int16 }
+            DECODINGS[0xce] = lambda { |d| d.consume_int32 }
+            DECODINGS[0xcf] = lambda { |d| d.consume_int64 }
+            DECODINGS[0xd0] = lambda { |d| d.consume_byte - 0x100 }
+            DECODINGS[0xd1] = lambda { |d| d.consume_int16 - 0x10000 }
+            DECODINGS[0xd2] = lambda { |d| d.consume_int32 - 0x100000000 }
+            DECODINGS[0xd3] = lambda { |d| d.consume_int64 - 0x10000000000000000 }
+            DECODINGS[0xd9] = lambda { |d| d.consume_string(d.consume_byte) }
+            DECODINGS[0xda] = lambda { |d| d.consume_string(d.consume_int16) }
+            DECODINGS[0xdb] = lambda { |d| d.consume_string(d.consume_int32) }
+            DECODINGS[0xdc] = lambda { |d| d.consume_array(d.consume_int16) }
+            DECODINGS[0xdd] = lambda { |d| d.consume_array(d.consume_int32) }
+            DECODINGS[0xde] = lambda { |d| Hash[*d.consume_array(d.consume_int16 * 2)] }
+            DECODINGS[0xdf] = lambda { |d| Hash[*d.consume_array(d.consume_int32 * 2)] }
+
+            FLOAT_FMT = 'g'.freeze
+            DOUBLE_FMT = 'G'.freeze
+
+            public
+
+            def consume_byte
+              buffer.getbyte
+            end
+
+            def consume_int16
+              (consume_byte << 8) | consume_byte
+            end
+
+            def consume_int32
+              (consume_byte << 24) | (consume_byte << 16) | (consume_byte << 8) | consume_byte
+            end
+
+            def consume_int64
+              n  = (consume_byte << 56)
+              n |= (consume_byte << 48)
+              n |= (consume_byte << 40)
+              n |= (consume_byte << 32)
+              n |= (consume_byte << 24)
+              n |= (consume_byte << 16)
+              n |= (consume_byte << 8)
+              n |=  consume_byte
+              n
+            end
+
+            def consume_float
+              f, = buffer.read(4).unpack(FLOAT_FMT)
+              f
+            end
+
+            def consume_double
+              d, = buffer.read(8).unpack(DOUBLE_FMT)
+              d
+            end
+
+            def consume_string(size, encoding=Encoding::UTF_8)
+              s = buffer.read(size)
+              s.force_encoding(encoding)
+              s
+            end
+
+            def consume_array(size)
+              Array.new(size) { consume_next }
+            end
+
+            def consume_next
+              b = consume_byte
+              if (method = DECODINGS[b])
+                method.call(self)
+              elsif b <= 0b01111111
+                b
+              elsif b & 0b11100000 == 0b11100000
+                b - 0x100
+              elsif b & 0b11100000 == 0b10100000
+                size = b & 0b00011111
+                consume_string(size)
+              elsif b & 0b11110000 == 0b10010000
+                size = b & 0b00001111
+                consume_array(size)
+              elsif b & 0b11110000 == 0b10000000
+                size = b & 0b00001111
+                Hash[*consume_array(size * 2)]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/adapter/msgpack/version.rb

@@ -3,7 +3,7 @@ module Bones
   module RPC
     module Adapter
       module Msgpack
-        VERSION = "0.0.1"
+        VERSION = "0.0.2"
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bones-rpc-adapter-msgpack
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Andrew Bennett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-08 00:00:00.000000000 Z
+date: 2013-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bones-rpc
@@ -83,6 +83,7 @@ files:
 - bones-rpc-adapter-msgpack.gemspec
 - lib/bones-rpc-adapter-msgpack.rb
 - lib/bones/rpc/adapter/msgpack.rb
+- lib/bones/rpc/adapter/msgpack/ruby.rb
 - lib/bones/rpc/adapter/msgpack/version.rb
 homepage: ''
 licenses: