Hello community,
here is the log from the commit of package rubygem-msgpack for openSUSE:Factory
checked in at 2019-07-08 15:12:44
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/rubygem-msgpack (Old)
and /work/SRC/openSUSE:Factory/.rubygem-msgpack.new.4615 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-msgpack"
Mon Jul 8 15:12:44 2019 rev:10 rq:714009 version:1.3.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/rubygem-msgpack/rubygem-msgpack.changes
2019-06-19 21:00:40.614102033 +0200
+++
/work/SRC/openSUSE:Factory/.rubygem-msgpack.new.4615/rubygem-msgpack.changes
2019-07-08 16:41:03.924963363 +0200
@@ -1,0 +2,7 @@
+Mon Jul 8 08:32:18 UTC 2019 - Manuel Schnitzer <[email protected]>
+
+- updated to version 1.3.0
+
+ * Add timestamp ext type (id:-1) support
+
+-------------------------------------------------------------------
Old:
----
msgpack-1.2.10.gem
New:
----
msgpack-1.3.0.gem
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ rubygem-msgpack.spec ++++++
--- /var/tmp/diff_new_pack.CSI420/_old 2019-07-08 16:41:04.492964169 +0200
+++ /var/tmp/diff_new_pack.CSI420/_new 2019-07-08 16:41:04.496964174 +0200
@@ -24,7 +24,7 @@
#
Name: rubygem-msgpack
-Version: 1.2.10
+Version: 1.3.0
Release: 0
%define mod_name msgpack
%define mod_full_name %{mod_name}-%{version}
++++++ msgpack-1.2.10.gem -> msgpack-1.3.0.gem ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/.rubocop.yml new/.rubocop.yml
--- old/.rubocop.yml 2019-04-19 03:15:28.000000000 +0200
+++ new/.rubocop.yml 2019-06-20 09:16:11.000000000 +0200
@@ -5,6 +5,9 @@
# Note that changes in the inspected code, or installation of new
# versions of RuboCop, may require this file to be generated again.
+AllCops:
+ TargetRubyVersion: 2.3
+
# Offense count: 3
Lint/AmbiguousOperator:
Enabled: false
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/ChangeLog new/ChangeLog
--- old/ChangeLog 2019-04-19 03:15:28.000000000 +0200
+++ new/ChangeLog 2019-06-20 09:16:11.000000000 +0200
@@ -1,3 +1,7 @@
+2019-06-20 verison 1.3.0:
+
+* Add timestamp ext type (id:-1) support
+
2019-04-19 version 1.2.10:
* Optimze MessagePack.unpack not to copy source string
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/README.rdoc new/README.rdoc
--- old/README.rdoc 2019-04-19 03:15:28.000000000 +0200
+++ new/README.rdoc 2019-06-20 09:16:11.000000000 +0200
@@ -121,6 +121,22 @@
[1, :symbol, 'string'].to_msgpack # => RuntimeError: Serialization of
symbols prohibited
+= Serializing and deserializing Time instances
+
+There are the timestamp extension type in MessagePack,
+but it is not registered by default.
+
+To map Ruby's Time to MessagePack's timestamp for the default factory:
+
+ MessagePack::DefaultFactory.register_type(
+ MessagePack::Timestamp::TYPE, # or just -1
+ Time,
+ packer: MessagePack::Time::Packer,
+ unpacker: MessagePack::Time::Unpacker
+ )
+
+See {API reference}[http://ruby.msgpack.org/] for details.
+
= Extension Types
Packer and Unpacker support {Extension types of
MessagePack}[https://github.com/msgpack/msgpack/blob/master/spec.md#types-extension-type].
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/time.rb new/doclib/msgpack/time.rb
--- old/doclib/msgpack/time.rb 1970-01-01 01:00:00.000000000 +0100
+++ new/doclib/msgpack/time.rb 2019-06-20 09:16:11.000000000 +0200
@@ -0,0 +1,22 @@
+module MessagePack
+
+ # MessagePack::Time provides packer and unpacker functions for a timestamp
type.
+ # @example Setup for DefaultFactory
+ # MessagePack::DefaultFactory.register_type(
+ # MessagePack::Timestamp::TYPE,
+ # Time,
+ # packer: MessagePack::Time::Packer,
+ # unpacker: MessagePack::Time::Unpacker
+ # )
+ class Time
+ # A packer function that packs a Time instance to a MessagePack timestamp.
+ Packer = lambda { |payload|
+ # ...
+ }
+
+ # An unpacker function that unpacks a MessagePack timestamp to a Time
instance.
+ Unpcker = lambda { |time|
+ # ...
+ }
+ end
+end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/doclib/msgpack/timestamp.rb
new/doclib/msgpack/timestamp.rb
--- old/doclib/msgpack/timestamp.rb 1970-01-01 01:00:00.000000000 +0100
+++ new/doclib/msgpack/timestamp.rb 2019-06-20 09:16:11.000000000 +0200
@@ -0,0 +1,44 @@
+module MessagePack
+ # A utility class for MessagePack timestamp type
+ class Timestamp
+ #
+ # The timestamp extension type defined in the MessagePack spec.
+ #
+ # See
https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
for details.
+ #
+ TYPE = -1
+
+ # @return [Integer] Second part of the timestamp.
+ attr_reader :sec
+
+ # @return [Integer] Nanosecond part of the timestamp.
+ attr_reader :nsec
+
+ # @param [Integer] sec
+ # @param [Integer] nsec
+ def initialize(sec, nsec)
+ end
+
+ # @example An unpacker implementation for the Time class
+ # lambda do |payload|
+ # tv = MessagePack::Timestamp.from_msgpack_ext(payload)
+ # Time.at(tv.sec, tv.nsec, :nanosecond)
+ # end
+ #
+ # @param [String] data
+ # @return [MessagePack::Timestamp]
+ def self.from_msgpack_ext(data)
+ end
+
+ # @example A packer implementation for the Time class
+ # unpacker = lambda do |time|
+ # MessagePack::Timestamp.to_msgpack_ext(time.tv_sec, time.tv_nsec)
+ # end
+ #
+ # @param [Integer] sec
+ # @param [Integer] nsec
+ # @return [String]
+ def self.to_msgpack_ext(sec, nsec)
+ end
+ end
+end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/msgpack/time.rb new/lib/msgpack/time.rb
--- old/lib/msgpack/time.rb 1970-01-01 01:00:00.000000000 +0100
+++ new/lib/msgpack/time.rb 2019-06-20 09:16:11.000000000 +0200
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# MessagePack extention packer and unpacker for built-in Time class
+module MessagePack
+ module Time
+ # 3-arg Time.at is available Ruby >= 2.5
+ TIME_AT_3_AVAILABLE = begin
+ !!::Time.at(0, 0, :nanosecond)
+ rescue ArgumentError
+ false
+ end
+
+ Unpacker = if TIME_AT_3_AVAILABLE
+ lambda do |payload|
+ tv = MessagePack::Timestamp.from_msgpack_ext(payload)
+ ::Time.at(tv.sec, tv.nsec, :nanosecond)
+ end
+ else
+ lambda do |payload|
+ tv = MessagePack::Timestamp.from_msgpack_ext(payload)
+ ::Time.at(tv.sec, tv.nsec / 1000.0)
+ end
+ end
+
+ Packer = lambda { |time|
+ MessagePack::Timestamp.to_msgpack_ext(time.tv_sec, time.tv_nsec)
+ }
+ end
+end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/msgpack/timestamp.rb new/lib/msgpack/timestamp.rb
--- old/lib/msgpack/timestamp.rb 1970-01-01 01:00:00.000000000 +0100
+++ new/lib/msgpack/timestamp.rb 2019-06-20 09:16:11.000000000 +0200
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module MessagePack
+ class Timestamp # a.k.a. "TimeSpec"
+ # Because the byte-order of MessagePack is big-endian in,
+ # pack() and unpack() specifies ">".
+ # See https://docs.ruby-lang.org/en/trunk/Array.html#method-i-pack for
details.
+
+ # The timestamp extension type defined in the MessagePack spec.
+ # See
https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
for details.
+ TYPE = -1
+
+ TIMESTAMP32_MAX_SEC = (1 << 32) - 1
+ TIMESTAMP64_MAX_SEC = (1 << 34) - 1
+
+ # @return [Integer]
+ attr_reader :sec
+
+ # @return [Integer]
+ attr_reader :nsec
+
+ # @param [Integer] sec
+ # @param [Integer] nsec
+ def initialize(sec, nsec)
+ @sec = sec
+ @nsec = nsec
+ end
+
+ def self.from_msgpack_ext(data)
+ case data.length
+ when 4
+ # timestamp32 (sec: uint32be)
+ sec, = data.unpack('L>')
+ new(sec, 0)
+ when 8
+ # timestamp64 (nsec: uint30be, sec: uint34be)
+ n, s = data.unpack('L>2')
+ sec = ((n & 0b11) << 32) | s
+ nsec = n >> 2
+ new(sec, nsec)
+ when 12
+ # timestam96 (nsec: uint32be, sec: int64be)
+ nsec, sec = data.unpack('L>q>')
+ new(sec, nsec)
+ else
+ raise MalformedFormatError, "Invalid timestamp data size:
#{data.length}"
+ end
+ end
+
+ def self.to_msgpack_ext(sec, nsec)
+ if sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC
+ if nsec === 0 && sec <= TIMESTAMP32_MAX_SEC
+ # timestamp32 = (sec: uint32be)
+ [sec].pack('L>')
+ else
+ # timestamp64 (nsec: uint30be, sec: uint34be)
+ nsec30 = nsec << 2
+ sec_high2 = sec << 32 # high 2 bits (`x & 0b11` is redandunt)
+ sec_low32 = sec & 0xffffffff # low 32 bits
+ [nsec30 | sec_high2, sec_low32].pack('L>2')
+ end
+ else
+ # timestamp96 (nsec: uint32be, sec: int64be)
+ [nsec, sec].pack('L>q>')
+ end
+ end
+
+ def to_msgpack_ext
+ self.class.to_msgpack_ext(sec, nsec)
+ end
+
+ def ==(other)
+ other.class == self.class && sec == other.sec && nsec == other.nsec
+ end
+ 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 2019-04-19 03:15:28.000000000 +0200
+++ new/lib/msgpack/version.rb 2019-06-20 09:16:11.000000000 +0200
@@ -1,5 +1,5 @@
module MessagePack
- VERSION = "1.2.10"
+ VERSION = "1.3.0"
# NOTE for msgpack-ruby maintainer:
# Check these things to release new binaryes for new Ruby versions
(especially for Windows):
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/msgpack.rb new/lib/msgpack.rb
--- old/lib/msgpack.rb 2019-04-19 03:15:28.000000000 +0200
+++ new/lib/msgpack.rb 2019-06-20 09:16:11.000000000 +0200
@@ -17,6 +17,8 @@
require "msgpack/factory"
require "msgpack/symbol"
require "msgpack/core_ext"
+require "msgpack/timestamp"
+require "msgpack/time"
module MessagePack
DefaultFactory = MessagePack::Factory.new
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/metadata new/metadata
--- old/metadata 2019-04-19 03:15:28.000000000 +0200
+++ new/metadata 2019-06-20 09:16:11.000000000 +0200
@@ -1,7 +1,7 @@
--- !ruby/object:Gem::Specification
name: msgpack
version: !ruby/object:Gem::Version
- version: 1.2.10
+ version: 1.3.0
platform: ruby
authors:
- Sadayuki Furuhashi
@@ -10,7 +10,7 @@
autorequire:
bindir: bin
cert_chain: []
-date: 2019-04-19 00:00:00.000000000 Z
+date: 2019-06-20 00:00:00.000000000 Z
dependencies:
- !ruby/object:Gem::Dependency
name: bundler
@@ -148,6 +148,8 @@
- doclib/msgpack/extension_value.rb
- doclib/msgpack/factory.rb
- doclib/msgpack/packer.rb
+- doclib/msgpack/time.rb
+- doclib/msgpack/timestamp.rb
- doclib/msgpack/unpacker.rb
- ext/java/org/msgpack/jruby/Buffer.java
- ext/java/org/msgpack/jruby/Decoder.java
@@ -192,6 +194,8 @@
- lib/msgpack/factory.rb
- lib/msgpack/packer.rb
- lib/msgpack/symbol.rb
+- lib/msgpack/time.rb
+- lib/msgpack/timestamp.rb
- lib/msgpack/unpacker.rb
- lib/msgpack/version.rb
- msgpack.gemspec
@@ -217,6 +221,7 @@
- spec/packer_spec.rb
- spec/random_compat.rb
- spec/spec_helper.rb
+- spec/timestamp_spec.rb
- spec/unpack_spec.rb
- spec/unpacker_spec.rb
homepage: http://msgpack.org/
@@ -264,5 +269,6 @@
- spec/packer_spec.rb
- spec/random_compat.rb
- spec/spec_helper.rb
+- spec/timestamp_spec.rb
- spec/unpack_spec.rb
- spec/unpacker_spec.rb
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/spec/timestamp_spec.rb new/spec/timestamp_spec.rb
--- old/spec/timestamp_spec.rb 1970-01-01 01:00:00.000000000 +0100
+++ new/spec/timestamp_spec.rb 2019-06-20 09:16:11.000000000 +0200
@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MessagePack::Timestamp do
+ describe 'malformed format' do
+ it do
+ expect do
+ MessagePack::Timestamp.from_msgpack_ext([0xd4, 0x00].pack("C*"))
+ end.to raise_error(MessagePack::MalformedFormatError)
+ end
+ end
+
+ describe 'register_type with Time' do
+ let(:factory) do
+ factory = MessagePack::Factory.new
+ factory.register_type(
+ MessagePack::Timestamp::TYPE,
+ Time,
+ packer: MessagePack::Time::Packer,
+ unpacker: MessagePack::Time::Unpacker
+ )
+ factory
+ end
+
+ let(:time) { Time.local(2019, 6, 17, 1, 2, 3, 123_456_789 / 1000.0) }
+ it 'serializes and deserializes Time' do
+ prefix_fixext8_with_type_id = [0xd7, -1].pack("c*")
+
+ packed = factory.pack(time)
+ expect(packed).to start_with(prefix_fixext8_with_type_id)
+ expect(packed.size).to eq(10)
+ unpacked = factory.unpack(packed)
+ expect(unpacked.to_i).to eq(time.to_i)
+ expect(unpacked.to_f).to eq(time.to_f)
+ # expect(unpacked).to eq(time) # we can't do it because of nsec
(rational vs float?)
+ end
+
+ let(:time_without_nsec) { Time.local(2019, 6, 17, 1, 2, 3, 0) }
+ it 'serializes time without nanosec as fixext4' do
+ prefix_fixext4_with_type_id = [0xd6, -1].pack("c*")
+
+ packed = factory.pack(time_without_nsec)
+ expect(packed).to start_with(prefix_fixext4_with_type_id)
+ expect(packed.size).to eq(6)
+ unpacked = factory.unpack(packed)
+ expect(unpacked).to eq(time_without_nsec)
+ end
+
+ let(:time_after_2514) { Time.at(1 << 34) } # the max num of 34bit int
means 2514-05-30 01:53:04 UTC
+ it 'serializes time after 2038 as ext8' do
+ prefix_ext8_with_12bytes_payload_and_type_id = [0xc7, 12, -1].pack("c*")
+
+ expect(time_after_2514.to_i).to be > 0xffffffff
+ packed = factory.pack(time_after_2514)
+ expect(packed).to
start_with(prefix_ext8_with_12bytes_payload_and_type_id)
+ expect(packed.size).to eq(15)
+ end
+ end
+
+ describe 'register_type with MessagePack::Timestamp' do
+ let(:factory) do
+ factory = MessagePack::Factory.new
+ factory.register_type(MessagePack::Timestamp::TYPE,
MessagePack::Timestamp)
+ factory
+ end
+
+ let(:timestamp) { MessagePack::Timestamp.new(Time.now.tv_sec, 123_456_789)
}
+ it 'serializes and deserializes MessagePack::Timestamp' do
+ packed = factory.pack(timestamp)
+ unpacked = factory.unpack(packed)
+ expect(unpacked).to eq(timestamp)
+ end
+ end
+
+ describe 'timestamp32' do
+ it 'handles [1, 0]' do
+ t = MessagePack::Timestamp.new(1, 0)
+
+ payload = t.to_msgpack_ext
+ unpacked = MessagePack::Timestamp.from_msgpack_ext(payload)
+
+ expect(unpacked).to eq(t)
+ end
+ end
+
+ describe 'timestamp64' do
+ it 'handles [1, 1]' do
+ t = MessagePack::Timestamp.new(1, 1)
+
+ payload = t.to_msgpack_ext
+ unpacked = MessagePack::Timestamp.from_msgpack_ext(payload)
+
+ expect(unpacked).to eq(t)
+ end
+ end
+
+ describe 'timestamp96' do
+ it 'handles [-1, 0]' do
+ t = MessagePack::Timestamp.new(-1, 0)
+
+ payload = t.to_msgpack_ext
+ unpacked = MessagePack::Timestamp.from_msgpack_ext(payload)
+
+ expect(unpacked).to eq(t)
+ end
+
+ it 'handles [-1, 999_999_999]' do
+ t = MessagePack::Timestamp.new(-1, 999_999_999)
+
+ payload = t.to_msgpack_ext
+ unpacked = MessagePack::Timestamp.from_msgpack_ext(payload)
+
+ expect(unpacked).to eq(t)
+ end
+ end
+end
