paquito 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: beedd98334166781382fbe4d773b19f27e58ea8cfe8c83fa211c745c7c752deb
-  data.tar.gz: 2912c724ee66b3b9547477e56aeb2bc1a0622128c41bf06b0be221c54eb0e8b0
+  metadata.gz: 0724a150e6626e863f78a24b665cd7cc8284ff612539ccbd3c58efc2117974f7
+  data.tar.gz: a2e2d693ed46a3fdb2c57f07fa0e60c11ce1a838eb262bcf19c0c95744b6ad4a
 SHA512:
-  metadata.gz: ba2c02fa73d7b1a27577e36c8f8e2a2ea73a57446939e0519ea3d1fbd1ababf6af4c0bdda47bfba074ce0af60ae0269c8ea838abcb5ad0cba75a5d2f81848297
-  data.tar.gz: fb527d860bfd14dd71c42c75320fd694ad1335ca4e21b7edacf798612b55125bd19d1a5bf7126f8e4770ad0b68c448d003fe8fad450b7686d7e8a97ad4921dbb
+  metadata.gz: 95b0aa7760f86aa056ff07d909dd3b4c03a2f4016b00dbdc7ceb0e31e5619c7aea822b20946ee8ded630111670211b95ff47e1a799944946bc4d9e7df18563bb
+  data.tar.gz: 4fa26995582cde6675e79c81382ef72fe981d2d335daabb33a44e280c76f69df5fd95171bd2dff4c5070296ab95151393470685f6d43ea3afe7571ae51272a8d

data/.rubocop.yml

@@ -6,3 +6,6 @@ AllCops:
 
 Style/ClassMethodsDefinitions:
   Enabled: false
+
+Style/DateTime:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Unreleased
 
+# 0.10.0
+
+* Introduce a new version `1` format that better handles `Time` and `DateTime` objects. It can be enabled by setting `Paquito.format_version = 1`.
+  *IMPORTANT*: If you are upgrading from previous versions, you MUST first fully deploy the new version of the gem prior to enabling the new format.
+  If you don't you may notice some `UnpackError` during the code rollout, which may be fine if you only use Paquito for ephemeral cache data.
+
+  *This new format will be the default in paquito 1.0.*
 
 # 0.9.2
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    paquito (0.9.2)
+    paquito (0.10.0)
       msgpack (>= 1.5.2)
 
 GEM

data/README.md

@@ -18,6 +18,25 @@ Or install it yourself as:
 
     $ gem install paquito
 
+## Upgrade process
+
+`Paquito` being a serialization library, takes extra care in always being able to deserialize payloads serialized from previous versions.
+
+However the inverse may not always be true, so when upgrading `Paquito` it is essential to first upgrade the gem without any applicative code change, so
+that all Ruby processes in production are able to read the new format.
+
+Additionally format changes can be controlled through `Paquito.format_version` that directly maps with the gem major version.
+
+For example, `paquito 0.10.0` introduce a new serialization format for `Time` and `DateTime` objects, but retain `Paquito.format_version = 0`.
+
+The upgrade process is as follows:
+
+  - Upgrade to `paquito ~> 0.10`.
+  - Fully deploy that upgrade (if multiple applications are sharing Paquito payloads it means upgrading all the applications).
+  - Set `Paquito.format_version = 1` or upgrade to `paquito ~> 1.0`.
+
+Generally speaking it's heavily recommended to carefully read the CHANGELOG and not to skip intermediary versions.
+
 ## Usage
 
 ### `chain`
@@ -75,7 +94,7 @@ Additionally, you can pass a distinct serializer for strings only:
 Example:
 
 ```ruby
-coder = Paquito::SingleBytePrefixVersion.new(
+coder = Paquito::SingleBytePrefixVersionWithStringBypass.new(
   1,
   { 0 => YAML, 1 => JSON },
   Paquito::ConditionalCompressor.new(Zlib, 1024), # Large strings will be compressed but not serialized in JSON.

data/lib/paquito/codec_factory.rb

@@ -5,14 +5,14 @@ require "paquito/coder_chain"
 
 module Paquito
   class CodecFactory
-    def self.build(types = [], freeze: false, serializable_type: false, pool: 1)
+    def self.build(types = [], freeze: false, serializable_type: false, pool: 1, format_version: Paquito.format_version)
       factory = if types.empty? && !serializable_type
         MessagePack::DefaultFactory
       else
         MessagePack::Factory.new
       end
 
-      Types.register(factory, types) unless types.empty?
+      Types.register(factory, types, format_version: format_version) unless types.empty?
       Types.register_serializable_type(factory) if serializable_type
 
       if pool && pool > 0 && factory.respond_to?(:pool)

data/lib/paquito/types.rb

@@ -12,6 +12,9 @@ module Paquito
     DATE_TIME_FORMAT = "s< C C C C q< L< c C"
     DATE_FORMAT = "s< C C"
 
+    MAX_UINT32 = (2**32) - 1
+    MAX_INT64 = (2**63) - 1
+
     SERIALIZE_METHOD = :as_pack
     SERIALIZE_PROC = SERIALIZE_METHOD.to_proc
     DESERIALIZE_METHOD = :from_pack
@@ -72,29 +75,53 @@ module Paquito
 
     # Do not change any #code, this would break current codecs.
     # New types can be added as long as they have unique #code.
-    TYPES = {
-      "Symbol" => {
+    TYPES = [
+      {
         code: 0,
+        class: "Symbol",
+        version: 0,
         packer: Symbol.method_defined?(:name) ? :name.to_proc : :to_s.to_proc,
         unpacker: :to_sym.to_proc,
         optimized_symbols_parsing: true,
       }.freeze,
-      "Time" => {
+      {
         code: 1,
+        class: "Time",
+        version: 0,
         packer: ->(value) do
-          rational = value.utc.to_r
+          rational = value.to_r
+          if rational.numerator > MAX_INT64 || rational.denominator > MAX_UINT32
+            raise PackError, "Time instance out of bounds (#{rational.inspect}), see: https://github.com/Shopify/paquito/issues/26"
+          end
+
           [rational.numerator, rational.denominator].pack(TIME_FORMAT)
         end,
         unpacker: ->(value) do
           numerator, denominator = value.unpack(TIME_FORMAT)
-          Time.at(Rational(numerator, denominator)).utc
+          at = begin
+            Rational(numerator, denominator)
+          rescue ZeroDivisionError
+            raise UnpackError, "Corrupted Time object, see: https://github.com/Shopify/paquito/issues/26"
+          end
+          Time.at(at).utc
         end,
       }.freeze,
-      "DateTime" => {
+      {
         code: 2,
+        class: "DateTime",
+        version: 0,
         packer: ->(value) do
           sec = value.sec + value.sec_fraction
           offset = value.offset
+
+          if sec.numerator > MAX_INT64 || sec.denominator > MAX_UINT32
+            raise PackError, "DateTime#sec_fraction out of bounds (#{sec.inspect}), see: https://github.com/Shopify/paquito/issues/26"
+          end
+
+          if offset.numerator > MAX_INT64 || offset.denominator > MAX_UINT32
+            raise PackError, "DateTime#offset out of bounds (#{offset.inspect}), see: https://github.com/Shopify/paquito/issues/26"
+          end
+
           [
             value.year,
             value.month,
@@ -119,40 +146,53 @@ module Paquito
             offset_numerator,
             offset_denominator,
           ) = value.unpack(DATE_TIME_FORMAT)
-          DateTime.new( # rubocop:disable Style/DateTime
-            year,
-            month,
-            day,
-            hour,
-            minute,
-            Rational(sec_numerator, sec_denominator),
-            Rational(offset_numerator, offset_denominator),
-          )
+
+          begin
+            ::DateTime.new(
+              year,
+              month,
+              day,
+              hour,
+              minute,
+              Rational(sec_numerator, sec_denominator),
+              Rational(offset_numerator, offset_denominator),
+            )
+          rescue ZeroDivisionError
+            raise UnpackError, "Corrupted DateTime object, see: https://github.com/Shopify/paquito/issues/26"
+          end
         end,
       }.freeze,
-      "Date" => {
+      {
         code: 3,
+        class: "Date",
+        version: 0,
         packer: ->(value) do
           [value.year, value.month, value.day].pack(DATE_FORMAT)
         end,
         unpacker: ->(value) do
           year, month, day = value.unpack(DATE_FORMAT)
-          Date.new(year, month, day)
+          ::Date.new(year, month, day)
         end,
       }.freeze,
-      "BigDecimal" => {
+      {
         code: 4,
+        class: "BigDecimal",
+        version: 0,
         packer: :_dump,
-        unpacker: BigDecimal.method(:_load),
+        unpacker: ::BigDecimal.method(:_load),
       }.freeze,
-      # Range => { code: 0x05 }, do not recycle that code
-      "ActiveRecord::Base" => {
+      # { code: 5, class: "Range" }, do not recycle that code
+      {
         code: 6,
+        class: "ActiveRecord::Base",
+        version: 0,
         packer: ->(value) { ActiveRecordPacker.dump(value) },
         unpacker: ->(value) { ActiveRecordPacker.load(value) },
       }.freeze,
-      "ActiveSupport::HashWithIndifferentAccess" => {
+      {
         code: 7,
+        class: "ActiveSupport::HashWithIndifferentAccess",
+        version: 0,
         packer: ->(value, packer) do
           unless value.instance_of?(ActiveSupport::HashWithIndifferentAccess)
             raise PackError.new("cannot pack HashWithIndifferentClass subclass", value)
@@ -162,9 +202,11 @@ module Paquito
         end,
         unpacker: ->(unpacker) { ActiveSupport::HashWithIndifferentAccess.new(unpacker.read) },
         recursive: true,
-      },
-      "ActiveSupport::TimeWithZone" => {
+      }.freeze,
+      {
         code: 8,
+        class: "ActiveSupport::TimeWithZone",
+        version: 0,
         packer: ->(value) do
           [
             value.utc.to_i,
@@ -178,21 +220,88 @@ module Paquito
           time_zone = ::Time.find_zone(time_zone_name)
           ActiveSupport::TimeWithZone.new(time, time_zone)
         end,
-      },
-      "Set" => {
+      }.freeze,
+      {
         code: 9,
+        class: "Set",
+        version: 0,
         packer: ->(value, packer) { packer.write(value.to_a) },
         unpacker: ->(unpacker) { unpacker.read.to_set },
         recursive: true,
-      },
-      # Integer => { code: 10 }, reserved for oversized Integer
-      # Object => { code: 127 }, reserved for serializable Object type
-    }
+      }.freeze,
+      # { code: 10, class: "Integer" }, reserved for oversized Integer
+      {
+        code: 11,
+        class: "Time",
+        version: 1,
+        recursive: true,
+        packer: ->(value, packer) do
+          packer.write(value.tv_sec)
+          packer.write(value.tv_nsec)
+          packer.write(value.utc_offset)
+        end,
+        unpacker: ->(unpacker) do
+          ::Time.at(unpacker.read, unpacker.read, :nanosecond, in: unpacker.read)
+        end,
+      }.freeze,
+      {
+        code: 12,
+        class: "DateTime",
+        version: 1,
+        recursive: true,
+        packer: ->(value, packer) do
+          packer.write(value.year)
+          packer.write(value.month)
+          packer.write(value.day)
+          packer.write(value.hour)
+          packer.write(value.minute)
+
+          sec = value.sec + value.sec_fraction
+          packer.write(sec.numerator)
+          packer.write(sec.denominator)
+
+          offset = value.offset
+          packer.write(offset.numerator)
+          packer.write(offset.denominator)
+        end,
+        unpacker: ->(unpacker) do
+          ::DateTime.new(
+            unpacker.read, # year
+            unpacker.read, # month
+            unpacker.read, # day
+            unpacker.read, # hour
+            unpacker.read, # minute
+            Rational(unpacker.read, unpacker.read), # sec fraction
+            Rational(unpacker.read, unpacker.read), # offset fraction
+          )
+        end,
+      }.freeze,
+      {
+        code: 13,
+        class: "ActiveSupport::TimeWithZone",
+        version: 1,
+        recursive: true,
+        packer: ->(value, packer) do
+          time = value.utc
+          packer.write(time.tv_sec)
+          packer.write(time.tv_nsec)
+          packer.write(value.time_zone.name)
+        end,
+        unpacker: ->(unpacker) do
+          utc = ::Time.at(unpacker.read, unpacker.read, :nanosecond, in: "UTC")
+          time_zone = ::Time.find_zone(unpacker.read)
+          ActiveSupport::TimeWithZone.new(utc, time_zone)
+        end,
+      }.freeze,
+      # { code: 127, class: "Object" }, reserved for serializable Object type
+    ]
     begin
       require "msgpack/bigint"
 
-      TYPES["Integer"] = {
+      TYPES << {
         code: 10,
+        class: "Integer",
+        version: 0,
         packer: MessagePack::Bigint.method(:to_msgpack_ext),
         unpacker: MessagePack::Bigint.method(:from_msgpack_ext),
         oversized_integer_extension: true,
@@ -204,7 +313,7 @@ module Paquito
     TYPES.freeze
 
     class << self
-      def register(factory, types)
+      def register(factory, types, format_version: Paquito.format_version)
         types.each do |type|
           # Up to Rails 7 ActiveSupport::TimeWithZone#name returns "Time"
           name = if defined?(ActiveSupport::TimeWithZone) && type == ActiveSupport::TimeWithZone
@@ -213,18 +322,29 @@ module Paquito
             type.name
           end
 
-          type_attributes = TYPES.fetch(name)
-          factory.register_type(
-            type_attributes.fetch(:code),
-            type,
-            type_attributes,
-          )
+          matching_types = TYPES.select { |t| t[:class] == name }
+
+          # If multiple types are registered for the same class, the last one will be used for
+          # packing. So we sort all matching types so that the active one is registered last.
+          past_types, future_types = matching_types.partition { |t| t.fetch(:version) <= format_version }
+          if past_types.empty?
+            raise KeyError, "No type found for #{name.inspect} with format_version=#{format_version}"
+          end
+
+          past_types.sort_by! { |t| t.fetch(:version) }
+          (future_types + past_types).each do |type_attributes|
+            factory.register_type(
+              type_attributes.fetch(:code),
+              type,
+              type_attributes,
+            )
+          end
         end
       end
 
       def register_serializable_type(factory)
         factory.register_type(
-          0x7f,
+          127,
           Object,
           packer: ->(value) do
             packer = CustomTypesRegistry.packer(value)

data/lib/paquito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Paquito
-  VERSION = "0.9.2"
+  VERSION = "0.10.0"
 end

data/lib/paquito.rb

@@ -29,7 +29,12 @@ module Paquito
   autoload :FlatCacheEntryCoder, "paquito/flat_cache_entry_coder"
   autoload :ActiveRecordCoder, "paquito/active_record_coder"
 
+  DEFAULT_FORMAT_VERSION = 0
+  @format_version = DEFAULT_FORMAT_VERSION
+
   class << self
+    attr_accessor :format_version
+
     def cast(coder)
       if coder.respond_to?(:load) && coder.respond_to?(:dump)
         coder

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paquito
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-12-09 00:00:00.000000000 Z
+date: 2023-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack