paquito 0.9.2 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: beedd98334166781382fbe4d773b19f27e58ea8cfe8c83fa211c745c7c752deb
-  data.tar.gz: 2912c724ee66b3b9547477e56aeb2bc1a0622128c41bf06b0be221c54eb0e8b0
+  metadata.gz: caa49c77308b2c81f81faa1308ab462dd0bcc15f91244ab080800ffe0e2ebd9f
+  data.tar.gz: 8909a37d22acd65c197c2c38dbc2e8f2e8e717d61f848996058e1c764cdadba7
 SHA512:
-  metadata.gz: ba2c02fa73d7b1a27577e36c8f8e2a2ea73a57446939e0519ea3d1fbd1ababf6af4c0bdda47bfba074ce0af60ae0269c8ea838abcb5ad0cba75a5d2f81848297
-  data.tar.gz: fb527d860bfd14dd71c42c75320fd694ad1335ca4e21b7edacf798612b55125bd19d1a5bf7126f8e4770ad0b68c448d003fe8fad450b7686d7e8a97ad4921dbb
+  metadata.gz: 25f2d1f9e05ddf14b7edbb798acd253e0590089a6d70296c493d8f8cbb63a2abdbe2b4fcfee7e72d201226b1a729b31c8b3cd1cf240d000abd3db21a4e0ff2d4
+  data.tar.gz: 034dea4d9c9e276af49d5aa892e2231eeda24d275a32f846da246334fec167a8a3568972908ac75d8c413f794edfb418253732e903d5e7073e0625a9cff8019d

data/.github/workflows/ci.yml

@@ -23,7 +23,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ ruby-head, '3.1', '3.0', '2.7' ]
+        ruby: [ ruby-head, '3.2', '3.1', '3.0', '2.7' ]
     steps:
       - name: Checkout
         uses: actions/checkout@v3

data/.github/workflows/cla.yml

@@ -0,0 +1,22 @@
+name: Contributor License Agreement (CLA)
+
+on:
+  pull_request_target:
+    types: [opened, synchronize]
+  issue_comment:
+    types: [created]
+
+jobs:
+  cla:
+    runs-on: ubuntu-latest
+    if: |
+      (github.event.issue.pull_request
+        && !github.event.issue.pull_request.merged_at
+        && contains(github.event.comment.body, 'signed')
+      )
+      || (github.event.pull_request && !github.event.pull_request.merged)
+    steps:
+      - uses: Shopify/shopify-cla-action@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cla-token: ${{ secrets.CLA_TOKEN }}

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Unreleased
 
+# 0.11.0
+
+* Convert some lambdas into proper methods to make them more discoverable by profilers.
+* Optimize `Time` and `ActiveSupport::TimeWithZone` serializers when `active_support/core_ext/time/calculations` is loaded.
+
+# 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

@@ -6,8 +6,8 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake", "~> 13.0"
-gem "activesupport"
-gem "activerecord"
+gem "activesupport", ">= 7"
+gem "activerecord", ">= 7"
 gem "sqlite3"
 gem "benchmark-ips"
 

data/Gemfile.lock

@@ -1,71 +1,67 @@
 PATH
   remote: .
   specs:
-    paquito (0.9.2)
+    paquito (0.11.0)
       msgpack (>= 1.5.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (7.0.4)
-      activesupport (= 7.0.4)
-    activerecord (7.0.4)
-      activemodel (= 7.0.4)
-      activesupport (= 7.0.4)
-    activesupport (7.0.4)
+    activemodel (7.0.7.1)
+      activesupport (= 7.0.7.1)
+    activerecord (7.0.7.1)
+      activemodel (= 7.0.7.1)
+      activesupport (= 7.0.7.1)
+    activesupport (7.0.7.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
     ast (2.4.2)
-    benchmark-ips (2.10.0)
+    benchmark-ips (2.12.0)
     byebug (11.1.3)
-    concurrent-ruby (1.1.10)
-    i18n (1.12.0)
+    concurrent-ruby (1.2.2)
+    i18n (1.14.1)
       concurrent-ruby (~> 1.0)
     json (2.6.3)
-    mini_portile2 (2.8.0)
-    minitest (5.16.3)
-    msgpack (1.6.0)
+    minitest (5.18.0)
+    msgpack (1.7.2)
     parallel (1.22.1)
-    parser (3.1.3.0)
+    parser (3.2.1.1)
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.6.1)
+    regexp_parser (2.7.0)
     rexml (3.2.5)
-    rubocop (1.40.0)
+    rubocop (1.48.1)
       json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 3.1.2.1)
+      parser (>= 3.2.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.23.0, < 2.0)
+      rubocop-ast (>= 1.26.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.24.0)
-      parser (>= 3.1.1.0)
-    rubocop-shopify (2.10.1)
-      rubocop (~> 1.35)
-    ruby-progressbar (1.11.0)
-    sorbet-runtime (0.5.10577)
-    sqlite3 (1.5.4)
-      mini_portile2 (~> 2.8.0)
-    sqlite3 (1.5.4-x86_64-darwin)
-    sqlite3 (1.5.4-x86_64-linux)
-    tzinfo (2.0.5)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.27.0)
+      parser (>= 3.2.1.0)
+    rubocop-shopify (2.12.0)
+      rubocop (~> 1.44)
+    ruby-progressbar (1.13.0)
+    sorbet-runtime (0.5.10712)
+    sqlite3 (1.6.1-arm64-darwin)
+    sqlite3 (1.6.1-x86_64-linux)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (2.3.0)
+    unicode-display_width (2.4.2)
 
 PLATFORMS
-  ruby
-  x86_64-darwin-20
+  arm64-darwin
   x86_64-linux
 
 DEPENDENCIES
-  activerecord
-  activesupport
+  activerecord (>= 7)
+  activesupport (>= 7)
   benchmark-ips
   byebug
   minitest (~> 5.0)
@@ -77,4 +73,4 @@ DEPENDENCIES
   sqlite3
 
 BUNDLED WITH
-   2.3.8
+   2.3.22

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/dev.yml

@@ -2,7 +2,7 @@ name: paquito
 
 up:
   - ruby:
-      version: 2.7.5
+      version: 2.7.8
   - bundler
 
 commands:

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/coder_chain.rb

@@ -4,6 +4,7 @@ module Paquito
   class CoderChain
     def initialize(*coders)
       @coders = coders.flatten.map { |c| Paquito.cast(c) }
+      @reverse_coders = @coders.reverse
     end
 
     def dump(object)
@@ -14,7 +15,7 @@ module Paquito
 
     def load(payload)
       object = payload
-      @coders.reverse_each { |c| object = c.load(object) }
+      @reverse_coders.each { |c| object = c.load(object) }
       object
     end
   end

data/lib/paquito/safe_yaml.rb

@@ -3,8 +3,17 @@
 module Paquito
   class SafeYAML
     ALL_SYMBOLS = [].freeze # Restricting symbols isn't really useful since symbols are no longer immortal
-    BASE_PERMITTED_CLASSNAMES = ["TrueClass", "FalseClass", "NilClass", "Numeric", "String", "Array", "Hash",
-                                 "Integer", "Float",].freeze
+    BASE_PERMITTED_CLASSNAMES = [
+      "TrueClass",
+      "FalseClass",
+      "NilClass",
+      "Numeric",
+      "String",
+      "Array",
+      "Hash",
+      "Integer",
+      "Float",
+    ].freeze
 
     def initialize(permitted_classes: [], deprecated_classes: [], aliases: false)
       permitted_classes += BASE_PERMITTED_CLASSNAMES

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,54 +75,66 @@ 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" => {
-        code: 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,
-        packer: ->(value) do
-          rational = value.utc.to_r
-          [rational.numerator, rational.denominator].pack(TIME_FORMAT)
-        end,
-        unpacker: ->(value) do
-          numerator, denominator = value.unpack(TIME_FORMAT)
-          Time.at(Rational(numerator, denominator)).utc
-        end,
-      }.freeze,
-      "DateTime" => {
-        code: 2,
-        packer: ->(value) do
-          sec = value.sec + value.sec_fraction
-          offset = value.offset
-          [
-            value.year,
-            value.month,
-            value.day,
-            value.hour,
-            value.minute,
-            sec.numerator,
-            sec.denominator,
-            offset.numerator,
-            offset.denominator,
-          ].pack(DATE_TIME_FORMAT)
-        end,
-        unpacker: ->(value) do
-          (
-            year,
-            month,
-            day,
-            hour,
-            minute,
-            sec_numerator,
-            sec_denominator,
-            offset_numerator,
-            offset_denominator,
-          ) = value.unpack(DATE_TIME_FORMAT)
-          DateTime.new( # rubocop:disable Style/DateTime
+    class << self
+      def time_pack_deprecated(value)
+        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
+
+      def time_unpack_deprecated(payload)
+        numerator, denominator = payload.unpack(TIME_FORMAT)
+        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
+
+      def datetime_pack_deprecated(value)
+        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,
+          value.day,
+          value.hour,
+          value.minute,
+          sec.numerator,
+          sec.denominator,
+          offset.numerator,
+          offset.denominator,
+        ].pack(DATE_TIME_FORMAT)
+      end
+
+      def datetime_unpack_deprecated(payload)
+        (
+          year,
+          month,
+          day,
+          hour,
+          minute,
+          sec_numerator,
+          sec_denominator,
+          offset_numerator,
+          offset_denominator,
+        ) = payload.unpack(DATE_TIME_FORMAT)
+
+        begin
+          ::DateTime.new(
             year,
             month,
             day,
@@ -128,71 +143,215 @@ module Paquito
             Rational(sec_numerator, sec_denominator),
             Rational(offset_numerator, offset_denominator),
           )
-        end,
+        rescue ZeroDivisionError
+          raise UnpackError, "Corrupted DateTime object, see: https://github.com/Shopify/paquito/issues/26"
+        end
+      end
+
+      def date_pack(value)
+        [value.year, value.month, value.day].pack(DATE_FORMAT)
+      end
+
+      def date_unpack(payload)
+        year, month, day = payload.unpack(DATE_FORMAT)
+        ::Date.new(year, month, day)
+      end
+
+      def hash_with_indifferent_access_pack(value, packer)
+        unless value.instance_of?(ActiveSupport::HashWithIndifferentAccess)
+          raise PackError.new("cannot pack HashWithIndifferentClass subclass", value)
+        end
+
+        packer.write(value.to_h)
+      end
+
+      def hash_with_indifferent_access_unpack(unpacker)
+        ActiveSupport::HashWithIndifferentAccess.new(unpacker.read)
+      end
+
+      def time_with_zone_deprecated_pack(value)
+        [
+          value.utc.to_i,
+          (value.time.sec_fraction * 1_000_000_000).to_i,
+          value.time_zone.name,
+        ].pack(TIME_WITH_ZONE_FORMAT)
+      end
+
+      def time_with_zone_deprecated_unpack(payload)
+        sec, nsec, time_zone_name = payload.unpack(TIME_WITH_ZONE_FORMAT)
+        time = Time.at(sec, nsec, :nsec, in: 0).utc
+        time_zone = ::Time.find_zone(time_zone_name)
+        ActiveSupport::TimeWithZone.new(time, time_zone)
+      end
+
+      def time_pack(value, packer)
+        packer.write(value.tv_sec)
+        packer.write(value.tv_nsec)
+        packer.write(value.utc_offset)
+      end
+
+      if ::Time.respond_to?(:at_without_coercion) # Ref: https://github.com/rails/rails/pull/50268
+        def time_unpack(unpacker)
+          ::Time.at_without_coercion(unpacker.read, unpacker.read, :nanosecond, in: unpacker.read)
+        end
+      else
+        def time_unpack(unpacker)
+          ::Time.at(unpacker.read, unpacker.read, :nanosecond, in: unpacker.read)
+        end
+      end
+
+      def datetime_pack(value, packer)
+        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
+
+      def datetime_unpack(unpacker)
+        ::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
+
+      def time_with_zone_pack(value, packer)
+        time = value.utc
+        packer.write(time.tv_sec)
+        packer.write(time.tv_nsec)
+        packer.write(value.time_zone.name)
+      end
+
+      if ::Time.respond_to?(:at_without_coercion) # Ref: https://github.com/rails/rails/pull/50268
+        def time_with_zone_unpack(unpacker)
+          utc = ::Time.at_without_coercion(unpacker.read, unpacker.read, :nanosecond, in: "UTC")
+          time_zone = ::Time.find_zone(unpacker.read)
+          ActiveSupport::TimeWithZone.new(utc, time_zone)
+        end
+      else
+        def time_with_zone_unpack(unpacker)
+          utc = ::Time.at(unpacker.read, unpacker.read, :nanosecond, in: "UTC")
+          time_zone = ::Time.find_zone(unpacker.read)
+          ActiveSupport::TimeWithZone.new(utc, time_zone)
+        end
+      end
+    end
+
+    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,
+      {
+        code: 1,
+        class: "Time",
+        version: 0,
+        packer: method(:time_pack_deprecated),
+        unpacker: method(:time_unpack_deprecated),
+      }.freeze,
+      {
+        code: 2,
+        class: "DateTime",
+        version: 0,
+        packer: method(:datetime_pack_deprecated),
+        unpacker: method(:datetime_unpack_deprecated),
       }.freeze,
-      "Date" => {
+      {
         code: 3,
-        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)
-        end,
+        class: "Date",
+        version: 0,
+        packer: method(:date_pack),
+        unpacker: method(:date_unpack),
       }.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,
-        packer: ->(value, packer) do
-          unless value.instance_of?(ActiveSupport::HashWithIndifferentAccess)
-            raise PackError.new("cannot pack HashWithIndifferentClass subclass", value)
-          end
-
-          packer.write(value.to_h)
-        end,
-        unpacker: ->(unpacker) { ActiveSupport::HashWithIndifferentAccess.new(unpacker.read) },
+        class: "ActiveSupport::HashWithIndifferentAccess",
+        version: 0,
+        packer: method(:hash_with_indifferent_access_pack),
+        unpacker: method(:hash_with_indifferent_access_unpack),
         recursive: true,
-      },
-      "ActiveSupport::TimeWithZone" => {
+      }.freeze,
+      {
         code: 8,
-        packer: ->(value) do
-          [
-            value.utc.to_i,
-            (value.time.sec_fraction * 1_000_000_000).to_i,
-            value.time_zone.name,
-          ].pack(TIME_WITH_ZONE_FORMAT)
-        end,
-        unpacker: ->(value) do
-          sec, nsec, time_zone_name = value.unpack(TIME_WITH_ZONE_FORMAT)
-          time = Time.at(sec, nsec, :nsec, in: 0).utc
-          time_zone = ::Time.find_zone(time_zone_name)
-          ActiveSupport::TimeWithZone.new(time, time_zone)
-        end,
-      },
-      "Set" => {
+        class: "ActiveSupport::TimeWithZone",
+        version: 0,
+        packer: method(:time_with_zone_deprecated_pack),
+        unpacker: method(:time_with_zone_deprecated_unpack),
+      }.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: method(:time_pack),
+        unpacker: method(:time_unpack),
+      }.freeze,
+      {
+        code: 12,
+        class: "DateTime",
+        version: 1,
+        recursive: true,
+        packer: method(:datetime_pack),
+        unpacker: method(:datetime_unpack),
+      }.freeze,
+      {
+        code: 13,
+        class: "ActiveSupport::TimeWithZone",
+        version: 1,
+        recursive: true,
+        packer: method(:time_with_zone_pack),
+        unpacker: method(:time_with_zone_unpack),
+      }.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 +363,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 +372,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.11.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.11.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-12-09 00:00:00.000000000 Z
+date: 2023-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -32,6 +32,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
+- ".github/workflows/cla.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - CHANGELOG.md
@@ -91,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.22
 signing_key: 
 specification_version: 4
 summary: Framework for defining efficient and extendable serializers