msgpack 1.1.0-x86-mingw32 → 1.2.0-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a14d7c50f725d0f018ea5edd3f8ee518cc4ea0c
-  data.tar.gz: 766fc725559c924ce4ed8ca9affde6eda4678c3f
+  metadata.gz: 7c14dafc60f8a2d68c22006e7891636397a3c93c
+  data.tar.gz: e67291dc047e8b406b3792bda09be8517152393c
 SHA512:
-  metadata.gz: 3b93c0ae9ae100a5390869484c41dddf1473a0d40c9c8c0c979fe85eef811f0ab2949fe8f2ba4c97a19686c2e1446caff4eefd901881c202086dea2ab9a9caa8
-  data.tar.gz: 42af8e7e8ef6bb2e2e89a580de78c32f3c94f392ac91c810d62f56580a18e9c3030097c2cfc33ef5374c42c72ed1ac4886684d3fb57f2528411fa258c1592b67
+  metadata.gz: f9153cbc455911a43e90a833bc7923246a91a493acb0c996f901ea73660924a4fd605f17166ebf6005674345bc2feb4bc7449d1986d90612a01cf5dd2796a3b8
+  data.tar.gz: 0b3580e1e142564498353a02f86dba9e3e52da0364d5c79d9771fbe6cc7ce85f033af86964404698b3b36ac8efbf16953d4ef7c16cd8421675a157fb2d2254da

data/ChangeLog

@@ -1,3 +1,9 @@
+2017-12-07 version 1.2.0:
+
+* Add MessagePack::Factory#dump and MessagePack::Factory#load as convenient methods
+  like MessagePack.dump and MessagePack.load
+* Fix bug to accept MessagePack::Factory#register_type after #freeze
+
 2017-02-28 version 1.1.0:
 
 * Fix the extention type handling to accept modules in addition to classes

data/doclib/msgpack/factory.rb

@@ -19,6 +19,22 @@ module MessagePack
     def packer(*args)
     end
 
+    #
+    # Serialize the passed value
+    #
+    # If it could not serialize the object, it raises
+    # NoMethodError: undefined method `to_msgpack' for #<the_object>.
+    #
+    # @param obj [Object] object to serialize
+    # @param options [Hash]
+    # @return [String] serialized object
+    #
+    # See Packer#initialize for supported options.
+    #
+    def dump(obj, options={})
+    end
+    alias pack dump
+
     #
     # Creates a MessagePack::Unpacker instance, which has ext types already registered.
     # Options are passed to MessagePack::Unpacker#initialized.
@@ -28,6 +44,23 @@ module MessagePack
     def unpacker(*args)
     end
 
+    #
+    # Deserializes an object from the string or io and returns it.
+    #
+    # If there're not enough data to deserialize one object, this method raises EOFError.
+    # If data format is invalid, this method raises MessagePack::MalformedFormatError.
+    # If the object nests too deeply, this method raises MessagePack::StackError.
+    #
+    # @param data [String]
+    # @param options [Hash]
+    # @return [Object] deserialized object
+    #
+    # See Unpacker#initialize for supported options.
+    #
+    def load(data, options={})
+    end
+    alias unpack load
+
     #
     # Register a type and Class to be registered for packer and/or unpacker.
     # If options are not speicified, factory will use :to_msgpack_ext for packer, and

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

@@ -75,6 +75,11 @@ public class Factory extends RubyObject {
 
     IRubyObject packerArg;
     IRubyObject unpackerArg;
+
+    if (isFrozen()) {
+        throw runtime.newRuntimeError("can't modify frozen Factory");
+    }
+
     if (args.length == 2) {
       packerArg = runtime.newSymbol("to_msgpack_ext");
       unpackerArg = runtime.newSymbol("from_msgpack_ext");

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

@@ -20,11 +20,8 @@ import org.jruby.internal.runtime.methods.DynamicMethod;
 
 
 public class MessagePackLibrary implements Library {
-  public static Factory defaultFactory;
-
   public void load(Ruby runtime, boolean wrap) {
     RubyModule msgpackModule = runtime.defineModule("MessagePack");
-    msgpackModule.defineAnnotatedMethods(MessagePackModule.class);
     RubyClass standardErrorClass = runtime.getStandardError();
     RubyClass unpackErrorClass = msgpackModule.defineClassUnder("UnpackError", standardErrorClass, standardErrorClass.getAllocator());
     RubyClass underflowErrorClass = msgpackModule.defineClassUnder("UnderflowError", unpackErrorClass, unpackErrorClass.getAllocator());
@@ -44,94 +41,5 @@ public class MessagePackLibrary implements Library {
     bufferClass.defineAnnotatedMethods(Buffer.class);
     RubyClass factoryClass = msgpackModule.defineClassUnder("Factory", runtime.getObject(), new Factory.FactoryAllocator());
     factoryClass.defineAnnotatedMethods(Factory.class);
-    defaultFactory = new Factory(runtime, factoryClass);
-    defaultFactory.initialize(runtime.getCurrentContext());
-    msgpackModule.defineConstant("DefaultFactory", defaultFactory);
-    installCoreExtensions(runtime);
-  }
-
-  private void installCoreExtensions(Ruby runtime) {
-    RubyClass extensionValueClass = runtime.getModule("MessagePack").getClass("ExtensionValue");
-    installCoreExtensions(
-      runtime,
-      runtime.getNilClass(),
-      runtime.getTrueClass(),
-      runtime.getFalseClass(),
-      runtime.getFixnum(),
-      runtime.getBignum(),
-      runtime.getFloat(),
-      runtime.getString(),
-      runtime.getArray(),
-      runtime.getHash(),
-      runtime.getSymbol(),
-      extensionValueClass
-    );
-  }
-
-  private void installCoreExtensions(Ruby runtime, RubyClass... classes) {
-    for (RubyClass cls : classes) {
-      cls.addMethod("to_msgpack", createToMsgpackMethod(runtime, cls));
-    }
-  }
-
-  private DynamicMethod createToMsgpackMethod(final Ruby runtime, RubyClass cls) {
-    return new DynamicMethod(cls, Visibility.PUBLIC, CallConfiguration.FrameNoneScopeNone) {
-      @Override
-      public IRubyObject call(ThreadContext context, IRubyObject recv, RubyModule clazz, String name, IRubyObject[] args, Block block) {
-        if (args.length == 0) {
-          IRubyObject[] allArgs = { recv };
-          return MessagePackModule.pack(runtime.getCurrentContext(), null, allArgs);
-        } else if (args.length == 1 && args[0] instanceof Packer) {
-          Packer packer = (Packer)args[0];
-          return packer.write(runtime.getCurrentContext(), recv);
-        } else if (args.length == 1) {
-          IRubyObject[] allArgs = { recv, args[0] };
-          return MessagePackModule.pack(runtime.getCurrentContext(), null, allArgs);
-        } else {
-          throw runtime.newArgumentError(String.format("wrong number of arguments (%d for 0..1)", args.length));
-        }
-      }
-
-      @Override
-      public DynamicMethod dup() {
-        return this;
-      }
-    };
-  }
-
-  @JRubyModule(name = "MessagePack")
-  public static class MessagePackModule {
-    @JRubyMethod(module = true, required = 1, optional = 1, alias = {"dump"})
-    public static IRubyObject pack(ThreadContext ctx, IRubyObject recv, IRubyObject[] args) {
-      IRubyObject[] extraArgs = null;
-      if (args.length == 0) {
-        extraArgs = new IRubyObject[] {};
-      } else {
-        extraArgs = new IRubyObject[args.length - 1];
-        System.arraycopy(args, 1, extraArgs, 0, args.length - 1);
-      }
-      Packer packer = MessagePackLibrary.defaultFactory.packer(ctx, extraArgs);
-      packer.write(ctx, args[0]);
-      return packer.toS(ctx);
-    }
-
-    @JRubyMethod(module = true, required = 1, optional = 1, alias = {"load"})
-    public static IRubyObject unpack(ThreadContext ctx, IRubyObject recv, IRubyObject[] args) {
-      ExtensionRegistry registry = MessagePackLibrary.defaultFactory.extensionRegistry();
-
-      boolean symbolizeKeys = false;
-      boolean allowUnknownExt = false;
-      if (args.length > 1 && !args[args.length - 1].isNil()) {
-        RubyHash hash = args[args.length - 1].convertToHash();
-        IRubyObject symbolizeKeysVal = hash.fastARef(ctx.getRuntime().newSymbol("symbolize_keys"));
-        symbolizeKeys = symbolizeKeysVal != null && symbolizeKeysVal.isTrue();
-        IRubyObject allowUnknownExtVal = hash.fastARef(ctx.getRuntime().newSymbol("allow_unknown_ext"));
-        allowUnknownExt = (allowUnknownExtVal != null && allowUnknownExtVal.isTrue());
-      }
-      byte[] bytes = args[0].asString().getBytes();
-      Decoder decoder = new Decoder(ctx.getRuntime(), registry, bytes, 0, bytes.length, symbolizeKeys, allowUnknownExt);
-
-      return decoder.next();
-    }
   }
 }

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

@@ -18,6 +18,8 @@ import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.util.ByteList;
+import org.jruby.util.TypeConverter;
+import org.msgpack.jruby.ExtensionValue;
 
 import static org.jruby.runtime.Visibility.PRIVATE;
 
@@ -121,6 +123,62 @@ public class Packer extends RubyObject {
     return this;
   }
 
+  @JRubyMethod(name = "write_float")
+  public IRubyObject writeFloat(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyFloat.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_array")
+  public IRubyObject writeArray(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyArray.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_string")
+  public IRubyObject writeString(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyString.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_hash")
+  public IRubyObject writeHash(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubyHash.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_symbol")
+  public IRubyObject writeSymbol(ThreadContext ctx, IRubyObject obj) {
+    checkType(ctx, obj, org.jruby.RubySymbol.class);
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_int")
+  public IRubyObject writeInt(ThreadContext ctx, IRubyObject obj) {
+    if (!(obj instanceof RubyFixnum)) {
+      checkType(ctx, obj, org.jruby.RubyBignum.class);
+    }
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_extension")
+  public IRubyObject writeExtension(ThreadContext ctx, IRubyObject obj) {
+    if (!(obj instanceof ExtensionValue)) {
+      throw ctx.runtime.newTypeError("Expected extension");
+    }
+    return write(ctx, obj);
+  }
+
+  @JRubyMethod(name = "write_true")
+  public IRubyObject writeTrue(ThreadContext ctx) {
+    return write(ctx, ctx.getRuntime().getTrue());
+  }
+
+  @JRubyMethod(name = "write_false")
+  public IRubyObject writeFalse(ThreadContext ctx) {
+    return write(ctx, ctx.getRuntime().getFalse());
+  }
+
   @JRubyMethod(name = "write_nil")
   public IRubyObject writeNil(ThreadContext ctx) {
     write(ctx, null);
@@ -151,6 +209,11 @@ public class Packer extends RubyObject {
     return this;
   }
 
+  @JRubyMethod(name = "full_pack")
+  public IRubyObject fullPack(ThreadContext ctx) {
+    return toS(ctx);
+  }
+
   @JRubyMethod(name = "to_s", alias = { "to_str" })
   public IRubyObject toS(ThreadContext ctx) {
     return buffer.toS(ctx);
@@ -175,4 +238,11 @@ public class Packer extends RubyObject {
   public IRubyObject clear(ThreadContext ctx) {
     return buffer.clear(ctx);
   }
+
+  private void checkType(ThreadContext ctx, IRubyObject obj, Class<? extends IRubyObject> expectedType) {
+    if (!expectedType.isInstance(obj)) {
+      String expectedName = expectedType.getName().substring("org.jruby.Ruby".length());
+      throw ctx.runtime.newTypeError(String.format("wrong argument type %s (expected %s)", obj.getMetaClass().toString(), expectedName));
+    }
+  }
 }

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

@@ -68,7 +68,7 @@ public class Unpacker extends RubyObject {
           allowUnknownExt = au.isTrue();
         }
       }
-      if (!(args[0] instanceof RubyHash)) {
+      if (args[0] != ctx.getRuntime().getNil() && !(args[0] instanceof RubyHash)) {
         setStream(ctx, args[0]);
       }
     }
@@ -181,6 +181,11 @@ public class Unpacker extends RubyObject {
     return this;
   }
 
+  @JRubyMethod(name = "full_unpack")
+  public IRubyObject fullUnpack(ThreadContext ctx) {
+    return decoder.next();
+  }
+
   @JRubyMethod(name = "feed_each", required = 1)
   public IRubyObject feedEach(ThreadContext ctx, IRubyObject data, Block block) {
     feed(ctx, data);

data/ext/msgpack/factory_class.c

@@ -24,7 +24,6 @@
 #include "unpacker_class.h"
 
 VALUE cMessagePack_Factory;
-VALUE cMessagePack_DefaultFactory;
 
 struct msgpack_factory_t;
 typedef struct msgpack_factory_t msgpack_factory_t;
@@ -146,6 +145,10 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
     VALUE packer_arg, unpacker_arg;
     VALUE packer_proc, unpacker_proc;
 
+    if (OBJ_FROZEN(self)) {
+        rb_raise(rb_eRuntimeError, "can't modify frozen Factory");
+    }
+
     switch (argc) {
     case 2:
         /* register_type(0x7f, Time) */
@@ -214,8 +217,4 @@ void MessagePack_Factory_module_init(VALUE mMessagePack)
 
     rb_define_private_method(cMessagePack_Factory, "registered_types_internal", Factory_registered_types_internal, 0);
     rb_define_method(cMessagePack_Factory, "register_type", Factory_register_type, -1);
-
-    cMessagePack_DefaultFactory = Factory_alloc(cMessagePack_Factory);
-    Factory_initialize(0, NULL, cMessagePack_DefaultFactory);
-    rb_define_const(mMessagePack, "DefaultFactory", cMessagePack_DefaultFactory);
 }

data/ext/msgpack/factory_class.h

@@ -23,8 +23,6 @@
 
 extern VALUE cMessagePack_Factory;
 
-extern VALUE cMessagePack_DefaultFactory;
-
 extern VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self);
 
 extern VALUE MessagePack_Factory_unpacker(int argc, VALUE* argv, VALUE self);

data/ext/msgpack/packer_class.c

@@ -135,6 +135,88 @@ static VALUE Packer_write_nil(VALUE self)
     return self;
 }
 
+static VALUE Packer_write_true(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_true(pk);
+    return self;
+}
+
+static VALUE Packer_write_false(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_false(pk);
+    return self;
+}
+
+static VALUE Packer_write_float(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_float_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_string(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_STRING);
+    msgpack_packer_write_string_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_array(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_ARRAY);
+    msgpack_packer_write_array_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_hash(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_HASH);
+    msgpack_packer_write_hash_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_symbol(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_SYMBOL);
+    msgpack_packer_write_symbol_value(pk, obj);
+    return self;
+}
+
+static VALUE Packer_write_int(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+
+    if (FIXNUM_P(obj)) {
+        msgpack_packer_write_fixnum_value(pk, obj);
+    } else {
+        Check_Type(obj, T_BIGNUM);
+        msgpack_packer_write_bignum_value(pk, obj);
+    }
+    return self;
+}
+
+static VALUE Packer_write_extension(VALUE self, VALUE obj)
+{
+    PACKER(self, pk);
+    Check_Type(obj, T_STRUCT);
+
+    int ext_type = FIX2INT(RSTRUCT_GET(obj, 0));
+    if(ext_type < -128 || ext_type > 127) {
+        rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
+    }
+    VALUE payload = RSTRUCT_GET(obj, 1);
+    StringValue(payload);
+    msgpack_packer_write_ext(pk, ext_type, payload);
+
+    return self;
+}
+
 static VALUE Packer_write_array_header(VALUE self, VALUE n)
 {
     PACKER(self, pk);
@@ -293,21 +375,12 @@ static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
     return Qnil;
 }
 
-VALUE MessagePack_pack(int argc, VALUE* argv)
+VALUE Packer_full_pack(VALUE self)
 {
-    VALUE v;
-
-    if (argc < 0 || argc > 3) {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
-    }
-    v = argv[0];
+    VALUE retval;
 
-    VALUE self = MessagePack_Factory_packer(argc - 1, argv + 1, cMessagePack_DefaultFactory);
     PACKER(self, pk);
 
-    msgpack_packer_write_value(pk, v);
-
-    VALUE retval;
     if(msgpack_buffer_has_io(PACKER_BUFFER_(pk))) {
         msgpack_buffer_flush(PACKER_BUFFER_(pk));
         retval = Qnil;
@@ -317,27 +390,9 @@ VALUE MessagePack_pack(int argc, VALUE* argv)
 
     msgpack_buffer_clear(PACKER_BUFFER_(pk)); /* to free rmem before GC */
 
-#ifdef RB_GC_GUARD
-    /* This prevents compilers from optimizing out the `self` variable
-     * from stack. Otherwise GC free()s it. */
-    RB_GC_GUARD(self);
-#endif
-
     return retval;
 }
 
-static VALUE MessagePack_dump_module_method(int argc, VALUE* argv, VALUE mod)
-{
-    UNUSED(mod);
-    return MessagePack_pack(argc, argv);
-}
-
-static VALUE MessagePack_pack_module_method(int argc, VALUE* argv, VALUE mod)
-{
-    UNUSED(mod);
-    return MessagePack_pack(argc, argv);
-}
-
 void MessagePack_Packer_module_init(VALUE mMessagePack)
 {
     s_to_msgpack = rb_intern("to_msgpack");
@@ -356,6 +411,15 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Packer, "write", Packer_write, 1);
     rb_define_alias(cMessagePack_Packer, "pack", "write");
     rb_define_method(cMessagePack_Packer, "write_nil", Packer_write_nil, 0);
+    rb_define_method(cMessagePack_Packer, "write_true", Packer_write_true, 0);
+    rb_define_method(cMessagePack_Packer, "write_false", Packer_write_false, 0);
+    rb_define_method(cMessagePack_Packer, "write_float", Packer_write_float, 1);
+    rb_define_method(cMessagePack_Packer, "write_string", Packer_write_string, 1);
+    rb_define_method(cMessagePack_Packer, "write_array", Packer_write_array, 1);
+    rb_define_method(cMessagePack_Packer, "write_hash", Packer_write_hash, 1);
+    rb_define_method(cMessagePack_Packer, "write_symbol", Packer_write_symbol, 1);
+    rb_define_method(cMessagePack_Packer, "write_int", Packer_write_int, 1);
+    rb_define_method(cMessagePack_Packer, "write_extension", Packer_write_extension, 1);
     rb_define_method(cMessagePack_Packer, "write_array_header", Packer_write_array_header, 1);
     rb_define_method(cMessagePack_Packer, "write_map_header", Packer_write_map_header, 1);
     rb_define_method(cMessagePack_Packer, "write_ext", Packer_write_ext, 2);
@@ -380,8 +444,5 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     //rb_gc_register_address(&s_packer_value);
     //Data_Get_Struct(s_packer_value, msgpack_packer_t, s_packer);
 
-    /* MessagePack.pack(x) */
-    rb_define_module_function(mMessagePack, "pack", MessagePack_pack_module_method, -1);
-    rb_define_module_function(mMessagePack, "dump", MessagePack_dump_module_method, -1);
+    rb_define_method(cMessagePack_Packer, "full_pack", Packer_full_pack, 0);
 }
-

data/ext/msgpack/packer_class.h

@@ -28,7 +28,5 @@ VALUE MessagePack_Packer_alloc(VALUE klass);
 
 VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self);
 
-VALUE MessagePack_pack(int argc, VALUE* argv);
-
 #endif
 

data/ext/msgpack/rbinit.c

@@ -21,7 +21,6 @@
 #include "unpacker_class.h"
 #include "factory_class.h"
 #include "extension_value_class.h"
-#include "core_ext.h"
 
 void Init_msgpack(void)
 {
@@ -32,6 +31,5 @@ void Init_msgpack(void)
     MessagePack_Unpacker_module_init(mMessagePack);
     MessagePack_Factory_module_init(mMessagePack);
     MessagePack_ExtensionValue_module_init(mMessagePack);
-    MessagePack_core_ext_module_init();
 }
 

data/ext/msgpack/unpacker_class.c

@@ -383,23 +383,8 @@ static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
     return Qnil;
 }
 
-VALUE MessagePack_unpack(int argc, VALUE* argv)
+static VALUE Unpacker_full_unpack(VALUE self)
 {
-    VALUE src;
-    VALUE self;
-
-    if (argc < 0 || argc > 2) {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
-    }
-    src = argv[0];
-
-    if(rb_type(src) == T_STRING) {
-        self = MessagePack_Factory_unpacker(argc - 1, argv + 1, cMessagePack_DefaultFactory);
-        UNPACKER(self, uk);
-        msgpack_buffer_append_string(UNPACKER_BUFFER_(uk), src);
-    } else {
-        self = MessagePack_Factory_unpacker(argc, argv, cMessagePack_DefaultFactory);
-    }
     UNPACKER(self, uk);
 
     /* prefer reference than copying; see MessagePack_Unpacker_module_init */
@@ -416,27 +401,9 @@ VALUE MessagePack_unpack(int argc, VALUE* argv)
         rb_raise(eMalformedFormatError, "%zd extra bytes after the deserialized object", extra);
     }
 
-#ifdef RB_GC_GUARD
-    /* This prevents compilers from optimizing out the `self` variable
-     * from stack. Otherwise GC free()s it. */
-    RB_GC_GUARD(self);
-#endif
-
     return msgpack_unpacker_get_last_object(uk);
 }
 
-static VALUE MessagePack_load_module_method(int argc, VALUE* argv, VALUE mod)
-{
-    UNUSED(mod);
-    return MessagePack_unpack(argc, argv);
-}
-
-static VALUE MessagePack_unpack_module_method(int argc, VALUE* argv, VALUE mod)
-{
-    UNUSED(mod);
-    return MessagePack_unpack(argc, argv);
-}
-
 VALUE MessagePack_Unpacker_new(int argc, VALUE* argv)
 {
     VALUE self = MessagePack_Unpacker_alloc(cMessagePack_Unpacker);
@@ -491,8 +458,6 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     /* prefer reference than copying */
     //msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(s_unpacker), 0);
 
-    /* MessagePack.unpack(x) */
-    rb_define_module_function(mMessagePack, "load", MessagePack_load_module_method, -1);
-    rb_define_module_function(mMessagePack, "unpack", MessagePack_unpack_module_method, -1);
+    rb_define_method(cMessagePack_Unpacker, "full_unpack", Unpacker_full_unpack, 0);
 }
 

data/ext/msgpack/unpacker_class.h

@@ -28,7 +28,5 @@ VALUE MessagePack_Unpacker_alloc(VALUE klass);
 
 VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self);
 
-VALUE MessagePack_unpack(int argc, VALUE* argv);
-
 #endif
 

data/lib/msgpack.rb

@@ -16,3 +16,35 @@ require "msgpack/packer"
 require "msgpack/unpacker"
 require "msgpack/factory"
 require "msgpack/symbol"
+require "msgpack/core_ext"
+
+module MessagePack
+  DefaultFactory = MessagePack::Factory.new
+
+  def load(src, param = nil)
+    unpacker = nil
+
+    if src.is_a? String
+      unpacker = DefaultFactory.unpacker param
+      unpacker.feed src
+    else
+      unpacker = DefaultFactory.unpacker src, param
+    end
+
+    unpacker.full_unpack
+  end
+  alias :unpack :load
+
+  module_function :load
+  module_function :unpack
+
+  def pack(v, *rest)
+    packer = DefaultFactory.packer(*rest)
+    packer.write v
+    packer.full_pack
+  end
+  alias :dump :pack
+
+  module_function :pack
+  module_function :dump
+end

data/lib/msgpack/core_ext.rb

@@ -0,0 +1,139 @@
+module MessagePack
+  module CoreExt
+    def to_msgpack(packer_or_io = nil)
+      if packer_or_io
+        if packer_or_io.is_a?(MessagePack::Packer)
+          to_msgpack_with_packer packer_or_io
+        else
+          MessagePack.pack(self, packer_or_io)
+        end
+      else
+        MessagePack.pack(self)
+      end
+    end
+  end
+end
+
+class NilClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_nil
+    packer
+  end
+end
+
+class TrueClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_true
+    packer
+  end
+end
+
+class FalseClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_false
+    packer
+  end
+end
+
+class Float
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_float self
+    packer
+  end
+end
+
+class String
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_string self
+    packer
+  end
+end
+
+class Array
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_array self
+    packer
+  end
+end
+
+class Hash
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_hash self
+    packer
+  end
+end
+
+class Symbol
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_symbol self
+    packer
+  end
+end
+
+if 1.class.name == "Integer"
+  class Integer
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+else
+  class Fixnum
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+
+  class Bignum
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+end
+
+module MessagePack
+  class ExtensionValue
+    include CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_extension self
+      packer
+    end
+  end
+end

data/lib/msgpack/factory.rb

@@ -56,5 +56,26 @@ module MessagePack
         raise ArgumentError, "class or type id"
       end
     end
+
+    def load(src, param = nil)
+      unpacker = nil
+
+      if src.is_a? String
+        unpacker = unpacker(param)
+        unpacker.feed(src)
+      else
+        unpacker = unpacker(src, param)
+      end
+
+      unpacker.full_unpack
+    end
+    alias :unpack :load
+
+    def dump(v, *rest)
+      packer = packer(*rest)
+      packer.write(v)
+      packer.full_pack
+    end
+    alias :pack :dump
   end
 end

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/msgpack.gemspec

@@ -23,12 +23,12 @@ Gem::Specification.new do |s|
   s.test_files = `git ls-files -- {test,spec}/*`.split("\n")
 
   s.add_development_dependency 'bundler', ['~> 1.0']
-  s.add_development_dependency 'rake', ['~> 0.9.2']
+  s.add_development_dependency 'rake'
   s.add_development_dependency 'rake-compiler', ['~> 1.0']
   if /java/ !~ RUBY_PLATFORM
     s.add_development_dependency 'rake-compiler-dock', ['~> 0.6.0']
   end
   s.add_development_dependency 'rspec', ['~> 3.3']
-  s.add_development_dependency 'yard', ['~> 0.8.2']
+  s.add_development_dependency 'yard'
   s.add_development_dependency 'json'
 end

data/spec/factory_spec.rb

@@ -44,6 +44,32 @@ describe MessagePack::Factory do
     end
   end
 
+  describe '#dump and #load' do
+    it 'can be used like a standard coder' do
+      subject.register_type(0x00, Symbol)
+      expect(subject.load(subject.dump(:symbol))).to be == :symbol
+    end
+
+    it 'is alias as pack and unpack' do
+      subject.register_type(0x00, Symbol)
+      expect(subject.unpack(subject.pack(:symbol))).to be == :symbol
+    end
+
+    it 'accept options' do
+      hash = subject.unpack(MessagePack.pack('k' => 'v'), symbolize_keys: true)
+      expect(hash).to be == { k: 'v' }
+    end
+  end
+
+  describe '#freeze' do
+    it 'can freeze factory instance to deny new registrations anymore' do
+      subject.register_type(0x00, Symbol)
+      subject.freeze
+      expect(subject.frozen?).to be_truthy
+      expect{ subject.register_type(0x01, Array) }.to raise_error(RuntimeError, "can't modify frozen Factory")
+    end
+  end
+
   class MyType
     def initialize(a, b)
       @a = a

data/spec/packer_spec.rb

@@ -178,6 +178,28 @@ describe MessagePack::Packer do
     Array.new.to_msgpack.class.should == String
   end
 
+  it 'to_msgpack with packer equals to_msgpack' do
+    nil.to_msgpack(MessagePack::Packer.new).to_str.should == nil.to_msgpack
+    true.to_msgpack(MessagePack::Packer.new).to_str.should == true.to_msgpack
+    false.to_msgpack(MessagePack::Packer.new).to_str.should == false.to_msgpack
+    1.to_msgpack(MessagePack::Packer.new).to_str.should == 1.to_msgpack
+    1.0.to_msgpack(MessagePack::Packer.new).to_str.should == 1.0.to_msgpack
+    "".to_msgpack(MessagePack::Packer.new).to_str.should == "".to_msgpack
+    Hash.new.to_msgpack(MessagePack::Packer.new).to_str.should == Hash.new.to_msgpack
+    Array.new.to_msgpack(MessagePack::Packer.new).to_str.should == Array.new.to_msgpack
+  end
+
+  it 'raises type error on wrong type' do
+    packer = MessagePack::Packer.new
+    expect { packer.write_float "hello" }.to raise_error(TypeError)
+    expect { packer.write_string 1 }.to raise_error(TypeError)
+    expect { packer.write_array "hello" }.to raise_error(TypeError)
+    expect { packer.write_hash "hello" }.to raise_error(TypeError)
+    expect { packer.write_symbol "hello" }.to raise_error(TypeError)
+    expect { packer.write_int "hello" }.to raise_error(TypeError)
+    expect { packer.write_extension "hello" }.to raise_error(TypeError)
+  end
+
   class CustomPack01
     def to_msgpack(pk=nil)
       return MessagePack.pack(self, pk) unless pk.class == MessagePack::Packer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msgpack
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: x86-mingw32
 authors:
 - Sadayuki Furuhashi
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-28 00:00:00.000000000 Z
+date: 2017-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,16 +30,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -86,16 +86,16 @@ dependencies:
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -163,8 +163,6 @@ files:
 - ext/msgpack/buffer_class.c
 - ext/msgpack/buffer_class.h
 - ext/msgpack/compat.h
-- ext/msgpack/core_ext.c
-- ext/msgpack/core_ext.h
 - ext/msgpack/extconf.rb
 - ext/msgpack/extension_value_class.c
 - ext/msgpack/extension_value_class.h
@@ -194,6 +192,7 @@ files:
 - lib/msgpack/2.2/msgpack.so
 - lib/msgpack/2.3/msgpack.so
 - lib/msgpack/2.4/msgpack.so
+- lib/msgpack/core_ext.rb
 - lib/msgpack/factory.rb
 - lib/msgpack/packer.rb
 - lib/msgpack/symbol.rb
@@ -247,7 +246,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: msgpack
-rubygems_version: 2.6.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: MessagePack, a binary-based efficient data interchange format.

data/ext/msgpack/core_ext.c

@@ -1,159 +0,0 @@
-/*
- * MessagePack for Ruby
- *
- * Copyright (C) 2008-2013 Sadayuki Furuhashi
- *
- *    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
- *
- *    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.
- */
-
-#include "core_ext.h"
-#include "packer.h"
-#include "packer_class.h"
-#include "extension_value_class.h"
-
-static inline VALUE delegete_to_pack(int argc, VALUE* argv, VALUE self)
-{
-    if(argc == 0) {
-        return MessagePack_pack(1, &self);
-    } else if(argc == 1) {
-        /* write to io */
-        VALUE argv2[2];
-        argv2[0] = self;
-        argv2[1] = argv[0];
-        return MessagePack_pack(2, argv2);
-    } else {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
-    }
-}
-
-#define ENSURE_PACKER(argc, argv, packer, pk) \
-    if(argc != 1 || rb_class_of(argv[0]) != cMessagePack_Packer) { \
-        return delegete_to_pack(argc, argv, self); \
-    } \
-    VALUE packer = argv[0]; \
-    msgpack_packer_t *pk; \
-    Data_Get_Struct(packer, msgpack_packer_t, pk);
-
-static VALUE NilClass_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_nil(pk);
-    return packer;
-}
-
-static VALUE TrueClass_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_true(pk);
-    return packer;
-}
-
-static VALUE FalseClass_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_false(pk);
-    return packer;
-}
-
-static VALUE Integer_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    if (FIXNUM_P(self)) {
-        msgpack_packer_write_fixnum_value(pk, self);
-    } else {
-        msgpack_packer_write_bignum_value(pk, self);
-    }
-    return packer;
-}
-
-static VALUE Fixnum_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_fixnum_value(pk, self);
-    return packer;
-}
-
-static VALUE Bignum_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_bignum_value(pk, self);
-    return packer;
-}
-
-static VALUE Float_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_float_value(pk, self);
-    return packer;
-}
-
-static VALUE String_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_string_value(pk, self);
-    return packer;
-}
-
-static VALUE Array_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_array_value(pk, self);
-    return packer;
-}
-
-static VALUE Hash_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_hash_value(pk, self);
-    return packer;
-}
-
-static VALUE Symbol_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    msgpack_packer_write_symbol_value(pk, self);
-    return packer;
-}
-
-static VALUE ExtensionValue_to_msgpack(int argc, VALUE* argv, VALUE self)
-{
-    ENSURE_PACKER(argc, argv, packer, pk);
-    int ext_type = FIX2INT(RSTRUCT_GET(self, 0));
-    if(ext_type < -128 || ext_type > 127) {
-        rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
-    }
-    VALUE payload = RSTRUCT_GET(self, 1);
-    StringValue(payload);
-    msgpack_packer_write_ext(pk, ext_type, payload);
-    return packer;
-}
-
-void MessagePack_core_ext_module_init()
-{
-    rb_define_method(rb_cNilClass,   "to_msgpack", NilClass_to_msgpack, -1);
-    rb_define_method(rb_cTrueClass,  "to_msgpack", TrueClass_to_msgpack, -1);
-    rb_define_method(rb_cFalseClass, "to_msgpack", FalseClass_to_msgpack, -1);
-#ifdef RUBY_INTEGER_UNIFICATION
-    rb_define_method(rb_cInteger, "to_msgpack", Integer_to_msgpack, -1);
-#else
-    rb_define_method(rb_cFixnum, "to_msgpack", Fixnum_to_msgpack, -1);
-    rb_define_method(rb_cBignum, "to_msgpack", Bignum_to_msgpack, -1);
-#endif
-    rb_define_method(rb_cFloat,  "to_msgpack", Float_to_msgpack, -1);
-    rb_define_method(rb_cString, "to_msgpack", String_to_msgpack, -1);
-    rb_define_method(rb_cArray,  "to_msgpack", Array_to_msgpack, -1);
-    rb_define_method(rb_cHash,   "to_msgpack", Hash_to_msgpack, -1);
-    rb_define_method(rb_cSymbol, "to_msgpack", Symbol_to_msgpack, -1);
-    rb_define_method(cMessagePack_ExtensionValue, "to_msgpack", ExtensionValue_to_msgpack, -1);
-}
-

data/ext/msgpack/core_ext.h

@@ -1,26 +0,0 @@
-/*
- * MessagePack for Ruby
- *
- * Copyright (C) 2008-2013 Sadayuki Furuhashi
- *
- *    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
- *
- *    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.
- */
-#ifndef MSGPACK_RUBY_CORE_EXT_H__
-#define MSGPACK_RUBY_CORE_EXT_H__
-
-#include "compat.h"
-
-void MessagePack_core_ext_module_init();
-
-#endif
-