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 - [email protected] + +- 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 #<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. # @@ -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
