msgpack 0.5.7 → 0.5.8

data/ChangeLog

@@ -1,4 +1,10 @@
 
+2013-12-14 version 0.5.8:
+
+* Fixed compatibility with Ruby 2.1.0
+* Added :symbolize_keys option to MessagePack.load and Unpacker#initialize
+
+
 2013-10-12 version 0.5.7:
 
 * Added deserialization support for the new MessagePack spec

data/Rakefile

@@ -52,7 +52,7 @@ else
   end
 end
 
-task :default => :build
+task :default => [:spec, :build, :doc]
 
 
 ###

data/doclib/msgpack.rb

@@ -3,53 +3,75 @@ module MessagePack
   #
   # Serializes an object into an IO or String.
   #
-  # @overload dump(obj)
+  # @overload dump(obj, options={})
+  #   @param obj [Object] object to be serialized
+  #   @param options [Hash]
   #   @return [String] serialized data
   #
-  # @overload dump(obj, io)
+  # @overload dump(obj, io, options={})
+  #   @param obj [Object] object to be serialized
+  #   @param io [IO]
+  #   @param options [Hash]
   #   @return [IO]
   #
-  def self.dump(arg)
+  # See Packer#initialize for supported options.
+  #
+  def self.dump(obj)
   end
 
   #
   # Serializes an object into an IO or String. Alias of dump.
   #
-  # @overload dump(obj)
+  # @overload pack(obj, options={})
+  #   @param obj [Object] object to be serialized
+  #   @param options [Hash]
   #   @return [String] serialized data
   #
-  # @overload dump(obj, io)
+  # @overload pack(obj, io, options={})
+  #   @param obj [Object] object to be serialized
+  #   @param io [IO]
+  #   @param options [Hash]
   #   @return [IO]
   #
-  def self.pack(arg)
+  # See Packer#initialize for supported options.
+  #
+  def self.pack(obj)
   end
 
   #
   # Deserializes an object from an IO or String.
   #
-  # @overload load(string)
+  # @overload load(string, options={})
   #   @param string [String] data to deserialize
+  #   @param options [Hash]
   #
-  # @overload load(io)
+  # @overload load(io, options={})
   #   @param io [IO]
+  #   @param options [Hash]
   #
   # @return [Object] deserialized object
   #
-  def self.load(arg)
+  # See Unpacker#initialize for supported options.
+  #
+  def self.load(src, options={})
   end
 
   #
   # Deserializes an object from an IO or String. Alias of load.
   #
-  # @overload unpack(string)
+  # @overload unpack(string, options={})
   #   @param string [String] data to deserialize
+  #   @param options [Hash]
   #
-  # @overload unpack(io)
+  # @overload unpack(io, options={})
   #   @param io [IO]
+  #   @param options [Hash]
   #
   # @return [Object] deserialized object
   #
-  def self.unpack(arg)
+  # See Unpacker#initialize for supported options.
+  #
+  def self.unpack(src, options={})
   end
 end
 

data/doclib/msgpack/packer.rb

@@ -18,6 +18,8 @@ module MessagePack
     #   This packer writes serialzied objects into the IO when the internal buffer is filled.
     #   _io_ must respond to write(string) or append(string) method.
     #
+    # See also Buffer#initialize for options.
+    #
     def initialize(*args)
     end
 

data/doclib/msgpack/unpacker.rb

@@ -17,7 +17,11 @@ module MessagePack
     #   This unpacker reads data from the _io_ to fill the internal buffer.
     #   _io_ must respond to readpartial(length [,string]) or read(length [,string]) method.
     #
-    # See Buffer#initialize for supported options.
+    # Supported options:
+    #
+    # * *:symbolize_keys* deserialize keys of Hash objects as Symbol instead of String
+    #
+    # See also Buffer#initialize for other options.
     #
     def initialize(*args)
     end

data/ext/msgpack/packer_class.c

@@ -79,19 +79,17 @@ static VALUE Packer_initialize(int argc, VALUE* argv, VALUE self)
         io = argv[0];
         options = argv[1];
         if(rb_type(options) != T_HASH) {
-            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(io));
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
         }
 
     } else {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
     }
 
     PACKER(self, pk);
-    if(io != Qnil || options != Qnil) {
-        MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
-    }
+    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
 
-    // TODO options
+    // TODO MessagePack_Unpacker_initialize and options
 
     return self;
 }
@@ -194,20 +192,31 @@ static VALUE Packer_write_to(VALUE self, VALUE io)
 
 VALUE MessagePack_pack(int argc, VALUE* argv)
 {
-    // TODO options
-
     VALUE v;
     VALUE io = Qnil;
+    VALUE options = Qnil;
 
-    switch(argc) {
-    case 2:
-        io = argv[1];
-        /* pass-through */
-    case 1:
+    if(argc == 1) {
+        v = argv[0];
+
+    } else if(argc == 2) {
+        v = argv[0];
+        if(rb_type(argv[1]) == T_HASH) {
+            options = argv[1];
+        } else {
+            io = argv[1];
+        }
+
+    } else if(argc == 3) {
         v = argv[0];
-        break;
-    default:
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+        io = argv[1];
+        options = argv[2];
+        if(rb_type(options) != T_HASH) {
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
+        }
+
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
     }
 
     VALUE self = Packer_alloc(cMessagePack_Packer);
@@ -215,9 +224,8 @@ VALUE MessagePack_pack(int argc, VALUE* argv)
     //msgpack_packer_reset(s_packer);
     //msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
 
-    if(io != Qnil) {
-        MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, Qnil);
-    }
+    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
+    // TODO MessagePack_Unpacker_initialize and options
 
     msgpack_packer_write_value(pk, v);
 

data/ext/msgpack/unpacker.c

@@ -607,7 +607,12 @@ int msgpack_unpacker_read(msgpack_unpacker_t* uk, size_t target_stack_depth)
                 top->type = STACK_TYPE_MAP_VALUE;
                 break;
             case STACK_TYPE_MAP_VALUE:
-                rb_hash_aset(top->object, top->key, uk->last_object);
+                if(uk->symbolize_keys && rb_type(top->key) == T_STRING) {
+                    /* here uses rb_intern_str instead of rb_intern so that Ruby VM can GC unused symbols */
+                    rb_hash_aset(top->object, ID2SYM(rb_intern_str(top->key)), uk->last_object);
+                } else {
+                    rb_hash_aset(top->object, top->key, uk->last_object);
+                }
                 top->type = STACK_TYPE_MAP_KEY;
                 break;
             }

data/ext/msgpack/unpacker.h

@@ -57,6 +57,9 @@ struct msgpack_unpacker_t {
     size_t reading_raw_remaining;
 
     VALUE buffer_ref;
+
+    /* options */
+    bool symbolize_keys;
 };
 
 #define UNPACKER_BUFFER_(uk) (&(uk)->buffer)
@@ -83,6 +86,11 @@ void msgpack_unpacker_mark(msgpack_unpacker_t* uk);
 
 void msgpack_unpacker_reset(msgpack_unpacker_t* uk);
 
+static inline void msgpack_unpacker_set_symbolized_keys(msgpack_unpacker_t* uk, bool enable)
+{
+    uk->symbolize_keys = enable;
+}
+
 
 /* error codes */
 #define PRIMITIVE_CONTAINER_START 1

data/ext/msgpack/unpacker_class.c

@@ -70,6 +70,9 @@ static VALUE Unpacker_initialize(int argc, VALUE* argv, VALUE self)
         VALUE v = argv[0];
         if(rb_type(v) == T_HASH) {
             options = v;
+            if(rb_type(options) != T_HASH) {
+                rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
+            }
         } else {
             io = v;
         }
@@ -78,7 +81,7 @@ static VALUE Unpacker_initialize(int argc, VALUE* argv, VALUE self)
         io = argv[0];
         options = argv[1];
         if(rb_type(options) != T_HASH) {
-            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(io));
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
         }
 
     } else {
@@ -86,15 +89,24 @@ static VALUE Unpacker_initialize(int argc, VALUE* argv, VALUE self)
     }
 
     UNPACKER(self, uk);
-    if(io != Qnil || options != Qnil) {
-        MessagePack_Buffer_initialize(UNPACKER_BUFFER_(uk), io, options);
-    }
 
-    // TODO options
+    MessagePack_Unpacker_initialize(uk, io, options);
 
     return self;
 }
 
+void MessagePack_Unpacker_initialize(msgpack_unpacker_t* uk, VALUE io, VALUE options)
+{
+    MessagePack_Buffer_initialize(UNPACKER_BUFFER_(uk), io, options);
+
+    if(options != Qnil) {
+        VALUE v;
+
+        v = rb_hash_aref(options, ID2SYM(rb_intern("symbolize_keys")));
+        msgpack_unpacker_set_symbolized_keys(uk, RTEST(v));
+    }
+}
+
 static void raise_unpacker_error(int r)
 {
     switch(r) {
@@ -288,8 +300,15 @@ static VALUE Unpacker_reset(VALUE self)
 VALUE MessagePack_unpack(int argc, VALUE* argv)
 {
     VALUE src;
+    VALUE options = Qnil;
 
     switch(argc) {
+    case 2:
+        options = argv[1];
+        if(rb_type(options) != T_HASH) {
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
+        }
+        /* pass-through */
     case 1:
         src = argv[0];
         break;
@@ -297,27 +316,19 @@ VALUE MessagePack_unpack(int argc, VALUE* argv)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
     }
 
-    VALUE io = Qnil;
-    if(rb_type(src) != T_STRING) {
-        io = src;
-        src = Qnil;
-    }
-
     VALUE self = Unpacker_alloc(cMessagePack_Unpacker);
     UNPACKER(self, uk);
     //msgpack_unpacker_reset(s_unpacker);
     //msgpack_buffer_reset_io(UNPACKER_BUFFER_(s_unpacker));
 
-    /* prefer reference than copying */
+    /* prefer reference than copying; see MessagePack_Unpacker_module_init */
     msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(uk), 0);
 
-    if(io != Qnil) {
-        MessagePack_Buffer_initialize(UNPACKER_BUFFER_(uk), io, Qnil);
-    }
-
-    if(src != Qnil) {
-        /* prefer reference than copying; see MessagePack_Unpacker_module_init */
+    if(rb_type(src) == T_STRING) {
+        MessagePack_Unpacker_initialize(uk, Qnil, options);
         msgpack_buffer_append_string(UNPACKER_BUFFER_(uk), src);
+    } else {
+        MessagePack_Unpacker_initialize(uk, src, options);
     }
 
     int r = msgpack_unpacker_read(uk, 0);

data/ext/msgpack/unpacker_class.h

@@ -26,5 +26,7 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack);
 
 VALUE MessagePack_unpack(int argc, VALUE* argv);
 
+void MessagePack_Unpacker_initialize(msgpack_unpacker_t* uk, VALUE io, VALUE options);
+
 #endif
 

data/lib/msgpack.rb

@@ -1,9 +1,6 @@
-here = File.expand_path(File.dirname(__FILE__))
-require File.join(here, 'msgpack', 'version')
+require "msgpack/version"
 begin
-  m = /(\d+.\d+)/.match(RUBY_VERSION)
-  ver = m[1]
-  require File.join(here, 'msgpack', ver, 'msgpack')
+  require "msgpack/#{RUBY_VERSION[/\d+.\d+/]}/msgpack"
 rescue LoadError
-  require File.join(here, 'msgpack', 'msgpack')
+  require "msgpack/msgpack"
 end

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-	VERSION = "0.5.7"
+	VERSION = "0.5.8"
 end

data/spec/buffer_io_spec.rb

@@ -201,7 +201,7 @@ describe Buffer do
       fragments.each {|s|
         lambda {
           b.skip_all(s.size)
-        }.should_not raise_error(EOFError)
+        }.should_not raise_error
       }
       b.empty?.should == true
       lambda {

data/spec/unpacker_spec.rb

@@ -230,6 +230,18 @@ describe Unpacker do
     parsed.should == true
   end
 
+  it 'MessagePack.unpack symbolize_keys' do
+    symbolized_hash = {:a => 'b', :c => 'd'}
+    MessagePack.load(MessagePack.pack(symbolized_hash), symbolize_keys: true).should == symbolized_hash
+    MessagePack.unpack(MessagePack.pack(symbolized_hash), symbolize_keys: true).should == symbolized_hash
+  end
+
+  it 'Unpacker#unpack symbolize_keys' do
+    unpacker = Unpacker.new(:symbolize_keys => true)
+    symbolized_hash = {:a => 'b', :c => 'd'}
+    unpacker.feed(MessagePack.pack(symbolized_hash)).read.should == symbolized_hash
+  end
+
   it "msgpack str 8 type" do
     MessagePack.unpack([0xd9, 0x00].pack('C*')).should == ""
     MessagePack.unpack([0xd9, 0x01].pack('C*') + 'a').should == "a"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-13 00:00:00.000000000 Z
+date: 2013-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler