Hello community,
here is the log from the commit of package rubygem-msgpack for openSUSE:Factory checked in at 2017-12-19 10:58:34
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/rubygem-msgpack (Old)
and /work/SRC/openSUSE:Factory/.rubygem-msgpack.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-msgpack"
Tue Dec 19 10:58:34 2017 rev:3 rq:558051 version:1.2.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/rubygem-msgpack/rubygem-msgpack.changes 2017-03-09 02:01:25.539961941 +0100
+++ /work/SRC/openSUSE:Factory/.rubygem-msgpack.new/rubygem-msgpack.changes 2017-12-19 10:58:36.041022481 +0100
@@ -1,0 +2,12 @@
+Thu Dec 14 14:24:14 UTC 2017 - coolo@suse.com
+
+- updated to version 1.2.0
+ see installed ChangeLog
+
+ 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
+
+-------------------------------------------------------------------
Old:
----
msgpack-1.1.0.gem
New:
----
msgpack-1.2.0.gem
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ rubygem-msgpack.spec ++++++
--- /var/tmp/diff_new_pack.7pXC5j/_old 2017-12-19 10:58:36.808985408 +0100
+++ /var/tmp/diff_new_pack.7pXC5j/_new 2017-12-19 10:58:36.808985408 +0100
@@ -24,7 +24,7 @@
#
Name: rubygem-msgpack
-Version: 1.1.0
+Version: 1.2.0
Release: 0
%define mod_name msgpack
%define mod_full_name %{mod_name}-%{version}
@@ -33,7 +33,7 @@
BuildRequires: %{rubygem gem2rpm}
BuildRequires: ruby-macros >= 5
Url: http://msgpack.org/
-Source: http://rubygems.org/gems/%{mod_full_name}.gem
+Source: https://rubygems.org/gems/%{mod_full_name}.gem
Source1: gem2rpm.yml
Source2: rubygem-msgpack-rpmlintrc
Source3: gem2rpm.yml
++++++ msgpack-1.1.0.gem -> msgpack-1.2.0.gem ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ChangeLog new/ChangeLog
--- old/ChangeLog 2017-02-28 05:17:49.000000000 +0100
+++ new/ChangeLog 2017-12-07 04:21:29.000000000 +0100
@@ -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
Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/doclib/msgpack/factory.rb new/doclib/msgpack/factory.rb
--- old/doclib/msgpack/factory.rb 2017-02-28 05:17:49.000000000 +0100
+++ new/doclib/msgpack/factory.rb 2017-12-07 04:21:29.000000000 +0100
@@ -20,6 +20,22 @@
end
#
+ # Serialize the passed value
+ #
+ # If it could not serialize the object, it raises
+ # NoMethodError: undefined method `to_msgpack' for #.
+ #
+ # @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.
#
@@ -29,6 +45,23 @@
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
# :from_msgpack_ext for unpacker.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Factory.java new/ext/java/org/msgpack/jruby/Factory.java
--- old/ext/java/org/msgpack/jruby/Factory.java 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/java/org/msgpack/jruby/Factory.java 2017-12-07 04:21:29.000000000 +0100
@@ -75,6 +75,11 @@
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");
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/MessagePackLibrary.java new/ext/java/org/msgpack/jruby/MessagePackLibrary.java
--- old/ext/java/org/msgpack/jruby/MessagePackLibrary.java 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/java/org/msgpack/jruby/MessagePackLibrary.java 2017-12-07 04:21:29.000000000 +0100
@@ -20,11 +20,8 @@
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 @@
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();
- }
}
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Packer.java new/ext/java/org/msgpack/jruby/Packer.java
--- old/ext/java/org/msgpack/jruby/Packer.java 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/java/org/msgpack/jruby/Packer.java 2017-12-07 04:21:29.000000000 +0100
@@ -18,6 +18,8 @@
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 @@
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 @@
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 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));
+ }
+ }
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/java/org/msgpack/jruby/Unpacker.java new/ext/java/org/msgpack/jruby/Unpacker.java
--- old/ext/java/org/msgpack/jruby/Unpacker.java 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/java/org/msgpack/jruby/Unpacker.java 2017-12-07 04:21:29.000000000 +0100
@@ -68,7 +68,7 @@
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 @@
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);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/core_ext.c new/ext/msgpack/core_ext.c
--- old/ext/msgpack/core_ext.c 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/core_ext.c 1970-01-01 01:00:00.000000000 +0100
@@ -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);
-}
-
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/core_ext.h new/ext/msgpack/core_ext.h
--- old/ext/msgpack/core_ext.h 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/core_ext.h 1970-01-01 01:00:00.000000000 +0100
@@ -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
-
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/factory_class.c new/ext/msgpack/factory_class.c
--- old/ext/msgpack/factory_class.c 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/factory_class.c 2017-12-07 04:21:29.000000000 +0100
@@ -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 @@
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 @@
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);
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/factory_class.h new/ext/msgpack/factory_class.h
--- old/ext/msgpack/factory_class.h 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/factory_class.h 2017-12-07 04:21:29.000000000 +0100
@@ -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);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/packer_class.c new/ext/msgpack/packer_class.c
--- old/ext/msgpack/packer_class.c 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/packer_class.c 2017-12-07 04:21:29.000000000 +0100
@@ -135,6 +135,88 @@
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 @@
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 @@
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 @@
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 @@
//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);
}
-
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/packer_class.h new/ext/msgpack/packer_class.h
--- old/ext/msgpack/packer_class.h 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/packer_class.h 2017-12-07 04:21:29.000000000 +0100
@@ -28,7 +28,5 @@
VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self);
-VALUE MessagePack_pack(int argc, VALUE* argv);
-
#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/rbinit.c new/ext/msgpack/rbinit.c
--- old/ext/msgpack/rbinit.c 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/rbinit.c 2017-12-07 04:21:29.000000000 +0100
@@ -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 @@
MessagePack_Unpacker_module_init(mMessagePack);
MessagePack_Factory_module_init(mMessagePack);
MessagePack_ExtensionValue_module_init(mMessagePack);
- MessagePack_core_ext_module_init();
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/unpacker_class.c new/ext/msgpack/unpacker_class.c
--- old/ext/msgpack/unpacker_class.c 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/unpacker_class.c 2017-12-07 04:21:29.000000000 +0100
@@ -383,23 +383,8 @@
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 @@
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 @@
/* 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);
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ext/msgpack/unpacker_class.h new/ext/msgpack/unpacker_class.h
--- old/ext/msgpack/unpacker_class.h 2017-02-28 05:17:49.000000000 +0100
+++ new/ext/msgpack/unpacker_class.h 2017-12-07 04:21:29.000000000 +0100
@@ -28,7 +28,5 @@
VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self);
-VALUE MessagePack_unpack(int argc, VALUE* argv);
-
#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/msgpack/core_ext.rb new/lib/msgpack/core_ext.rb
--- old/lib/msgpack/core_ext.rb 1970-01-01 01:00:00.000000000 +0100
+++ new/lib/msgpack/core_ext.rb 2017-12-07 04:21:29.000000000 +0100
@@ -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
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/msgpack/factory.rb new/lib/msgpack/factory.rb
--- old/lib/msgpack/factory.rb 2017-02-28 05:17:49.000000000 +0100
+++ new/lib/msgpack/factory.rb 2017-12-07 04:21:29.000000000 +0100
@@ -56,5 +56,26 @@
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
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/msgpack/version.rb new/lib/msgpack/version.rb
--- old/lib/msgpack/version.rb 2017-02-28 05:17:49.000000000 +0100
+++ new/lib/msgpack/version.rb 2017-12-07 04:21:29.000000000 +0100
@@ -1,3 +1,3 @@
module MessagePack
- VERSION = "1.1.0"
+ VERSION = "1.2.0"
end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/msgpack.rb new/lib/msgpack.rb
--- old/lib/msgpack.rb 2017-02-28 05:17:49.000000000 +0100
+++ new/lib/msgpack.rb 2017-12-07 04:21:29.000000000 +0100
@@ -16,3 +16,35 @@
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
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata
--- old/metadata 2017-02-28 05:17:49.000000000 +0100
+++ new/metadata 2017-12-07 04:21:29.000000000 +0100
@@ -1,7 +1,7 @@
--- !ruby/object:Gem::Specification
name: msgpack
version: !ruby/object:Gem::Version
- version: 1.1.0
+ version: 1.2.0
platform: ruby
authors:
- Sadayuki Furuhashi
@@ -10,7 +10,7 @@
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 @@
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 @@
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
@@ -164,8 +164,6 @@
- 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
@@ -190,6 +188,7 @@
- ext/msgpack/unpacker_ext_registry.c
- ext/msgpack/unpacker_ext_registry.h
- lib/msgpack.rb
+- lib/msgpack/core_ext.rb
- lib/msgpack/factory.rb
- lib/msgpack/packer.rb
- lib/msgpack/symbol.rb
@@ -240,7 +239,7 @@
version: '0'
requirements: []
rubyforge_project: msgpack
-rubygems_version: 2.6.8
+rubygems_version: 2.6.13
signing_key:
specification_version: 4
summary: MessagePack, a binary-based efficient data interchange format.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/msgpack.gemspec new/msgpack.gemspec
--- old/msgpack.gemspec 2017-02-28 05:17:49.000000000 +0100
+++ new/msgpack.gemspec 2017-12-07 04:21:29.000000000 +0100
@@ -23,12 +23,12 @@
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
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/factory_spec.rb new/spec/factory_spec.rb
--- old/spec/factory_spec.rb 2017-02-28 05:17:49.000000000 +0100
+++ new/spec/factory_spec.rb 2017-12-07 04:21:29.000000000 +0100
@@ -44,6 +44,32 @@
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
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/packer_spec.rb new/spec/packer_spec.rb
--- old/spec/packer_spec.rb 2017-02-28 05:17:49.000000000 +0100
+++ new/spec/packer_spec.rb 2017-12-07 04:21:29.000000000 +0100
@@ -178,6 +178,28 @@
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