universalid 0.0.1 → 0.1.0

data/Rakefile

@@ -6,9 +6,5 @@ require "minitest/test_task"
 task default: :test
 
 Minitest::TestTask.create(:test) do |t|
-  t.test_globs = if ARGV.size > 1
-    ARGV[1..]
-  else
-    ["test/**/*_test.rb"]
-  end
+  t.test_globs = ENV["GLOBS"] ? ENV["GLOBS"].split(",") : ["test/**/*_test.rb"]
 end

data/config/default.yml

@@ -0,0 +1,12 @@
+---
+prepack:
+  exclude: []
+  include: []
+  include_blank: true
+
+  database:
+    include_keys: true
+    include_timestamps: true
+    include_unsaved_changes: false
+    include_descendants: false
+    descendant_depth: 0

data/config/example.yml

@@ -0,0 +1,45 @@
+---
+##############################################################################################################
+# Prepack options applied before packing with MessagePack
+##############################################################################################################
+prepack:
+  # ..........................................................................................................
+  # A list of attributes to exclude (for objects like Hash, OpenStruct, Struct, etc.)
+  # Takes prescedence over the`include` list
+  exclude: []
+
+  # ..........................................................................................................
+  # A list of attributes to include (for objects like Hash, OpenStruct, Struct, etc.)
+  include: []
+
+  # ..........................................................................................................
+  # Whether or not to omit blank values when packing (nil, {}, [], "", etc.)
+  include_blank: true
+
+  # ==========================================================================================================
+  # Database records
+  database:
+    # ......................................................................................................
+    # Whether or not to include primary/foreign keys
+    # Setting this to `false` can be used to make a copy of an existing record
+    include_keys: true
+
+    # ......................................................................................................
+    # Whether or not to include date/time timestamps (created_at, updated_at, etc.)
+    # Setting this to `false` can be used to make a copy of an existing record
+    include_timestamps: true
+
+    # ......................................................................................................
+    # Whether or not to include unsaved changes
+    # Assign to `true` when packing new records
+    include_unsaved_changes: false
+
+    # ......................................................................................................
+    # Whether or not to include loaded in-memory descendants (i.e. child associations)
+    include_descendants: false
+
+    # ......................................................................................................
+    # The max depth (number) of loaded in-memory descendants to include when `include_descendants == true`
+    # For example, a value of (2) would include the following:
+    #   Parent > Child > Grandchild
+    descendant_depth: 0

data/contrib/active_record/base_message_pack_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "base_packer"
+require_relative "base_unpacker"
+
+UniversalID::MessagePackFactory.register(
+  type: ActiveRecord::Base,
+  recreate_pool: false,
+  packer: ->(obj, packer) { UniversalID::Contrib::ActiveRecordBasePacker.new(obj).pack_with packer },
+  unpacker: ->(unpacker) { UniversalID::Contrib::ActiveRecordBaseUnpacker.unpack_with unpacker }
+)

data/contrib/active_record/base_packer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+class UniversalID::Contrib::ActiveRecordBasePacker
+  using UniversalID::Refinements::HashRefinement
+
+  # TODO: implement support for has_one
+  #       ActiveRecord::Reflection::HasOneReflection
+  #
+  # TODO: implement support for has_and_belongs_to_many
+  #       ActiveRecord::Reflection::HasAndBelongsToManyReflection
+  #
+  HAS_MANY_ASSOCIATIONS = [
+    ActiveRecord::Reflection::HasManyReflection
+  ]
+
+  DESCENDANTS_KEY = "uid:descendants"
+
+  attr_reader :record
+
+  def initialize(record)
+    @record = record
+  end
+
+  def pack_with(packer)
+    packer.write record.class.name
+    packer.write packable_attributes
+  end
+
+  def prepack_options
+    options = record.instance_variable_get(:@_uid_prepack_options)
+    options = UniversalID::PrepackOptions.new unless options.is_a?(UniversalID::PrepackOptions)
+    options
+  end
+
+  def prepack_database_options
+    prepack_options.database_options
+  end
+
+  private
+
+  def packable_attributes
+    return record.attributes.slice(record.class.primary_key) if id_only?(prepack_database_options)
+
+    hash = record.attributes
+    reject_keys! hash if prepack_database_options.exclude_keys?
+    reject_timestamps! hash if prepack_database_options.exclude_timestamps?
+    reject_unsaved_changes! hash if prepack_database_options.exclude_unsaved_changes?
+    add_descendants! hash if include_descendants?
+
+    hash.prepack prepack_options
+  end
+
+  # helpers ..................................................................................................
+  def id_only?(prepack_database_options)
+    return false if record.new_record?
+    return false if prepack_database_options.include_descendants?
+    prepack_database_options.exclude_unsaved_changes?
+  end
+
+  def include_descendants?
+    return false unless prepack_database_options.include_descendants?
+
+    max_depth = prepack_database_options.descendant_depth.to_i
+    record_depth = record.instance_variable_get(:@_uid_depth).to_i
+    record_depth < max_depth
+  end
+
+  # attribute mutators .......................................................................................
+
+  def reject_keys!(hash)
+    hash.delete record.class.primary_key
+    foreign_key_column_names.each { |key| hash.delete key }
+  end
+
+  def reject_timestamps!(hash)
+    timestamp_column_names.each { |key| hash.delete key }
+  end
+
+  def reject_unsaved_changes!(hash)
+    record.changes_to_save.each do |key, (original_value, _)|
+      hash[key] = original_value
+    end
+  end
+
+  def add_descendants!(hash)
+    hash[DESCENDANTS_KEY] ||= {}
+
+    loaded_has_many_relations_by_name.each do |name, relation|
+      descendants = relation.map do |descendant|
+        descendant.instance_variable_set(:@_uid_depth, prepack_database_options.current_depth + 1)
+        UniversalID::Encoder.encode descendant, prepack_options
+      ensure
+        prepack_database_options.decrement_current_depth!
+        descendant.remove_instance_variable :@_uid_depth
+      end
+      hash[DESCENDANTS_KEY][name] = descendants
+    end
+
+    prepack_database_options.increment_current_depth!
+  end
+
+  # active record helpers ....................................................................................
+
+  def timestamp_column_names
+    record.class.all_timestamp_attributes_in_model
+  end
+
+  def foreign_key_column_names
+    record.class.reflections
+      .each_with_object([]) do |(name, reflection), memo|
+        memo << reflection.foreign_key if reflection.macro == :belongs_to
+      end
+  end
+
+  def associations
+    record.class.reflect_on_all_associations
+  end
+
+  def has_many_associations
+    associations.select { |a| HAS_MANY_ASSOCIATIONS.include? a.class }
+  end
+
+  def loaded_has_many_relations_by_name
+    has_many_associations.each_with_object({}) do |association, memo|
+      relation = record.public_send(association.name)
+      next unless relation.loaded?
+      memo[association.name] = relation
+    end
+  end
+end

data/contrib/active_record/base_unpacker.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class UniversalID::Contrib::ActiveRecordBaseUnpacker
+  using UniversalID::Refinements::KernelRefinement
+
+  class << self
+    def unpack_with(unpacker)
+      class_name = unpacker.read
+      attributes = unpacker.read || {}
+      create_instance class_name, attributes
+    end
+
+    private
+
+    def create_instance(class_name, attributes)
+      klass = const_find(class_name)
+      return nil unless klass
+
+      record = if attributes[klass.primary_key]
+        klass.find_by(klass.primary_key => attributes[klass.primary_key])
+      else
+        klass.new
+      end
+
+      assign_attributes record, attributes
+      assign_descendants record, attributes
+
+      record
+    end
+
+    def assign_attributes(record, attributes)
+      attributes.each do |key, value|
+        record.public_send "#{key}=", value if record.respond_to? "#{key}="
+      end
+    end
+
+    def assign_descendants(record, attributes)
+      descendants = attributes[UniversalID::Contrib::ActiveRecordBasePacker::DESCENDANTS_KEY] || {}
+      descendants.each do |name, list|
+        next unless record.respond_to?(name) && record.respond_to?("#{name}=")
+
+        models = list.map { |encoded| UniversalID::Encoder.decode encoded }
+        models.compact!
+        next unless models.any?
+
+        # NOTE: ActiveRecord is smart enough to not re-create or re-add
+        #       existing records for has_many associations
+        record.public_send "#{name}=", models
+      end
+    end
+  end
+end

data/contrib/active_record/relation_message_pack_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# TODO: Revisit ActiveRecord::Relation serialization strategy,
+#       and attempt to optimize without falling back to Marshal.dump/load
+UniversalID::MessagePackFactory.register(
+  type: ActiveRecord::Relation,
+  recreate_pool: false,
+  packer: ->(obj, packer) do
+    # NOTE: packing a relation will reset the loaded state and internal cache of the relation
+    #       this ensures minimal payload size
+    obj = obj.dup # clear internal cached state (loaded results, etc.)
+    obj.reset # dup should clear any internal caching, but we call reset just in case
+    packer.write Marshal.dump(obj)
+  end,
+  unpacker: ->(unpacker) { Marshal.load unpacker.read }
+)

data/contrib/active_record.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && defined?(ActiveRecord::Relation)
+
+  require_relative "active_record/base_message_pack_type"
+  require_relative "active_record/relation_message_pack_type"
+
+end

data/contrib/active_support/time_with_zone_message_pack_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: ActiveSupport::TimeWithZone,
+  packer: ->(obj, packer) do
+    packer.write obj.iso8601(9)
+    packer.write obj.zone
+  end,
+  unpacker: ->(unpacker) do
+    time = Time.parse(unpacker.read)
+    zone = unpacker.read
+    ActiveSupport::TimeWithZone.new time, ActiveSupport::TimeZone[zone]
+  end
+)

data/contrib/active_support.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined?(ActiveSupport) && defined?(ActiveSupport::TimeWithZone)
+
+  require_relative "active_support/time_with_zone_message_pack_type"
+
+end

data/contrib/global_id/global_id_model.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class UniversalID::Contrib::GlobalIDModel
+  include GlobalID::Identification
+
+  def self.find(value)
+    new value
+  end
+
+  attr_reader :id, :uid
+
+  def initialize(universal_id)
+    @uid = case universal_id
+    when URI::UID then universal_id
+    when String
+      case universal_id
+      when /\A#{URI::UID::SCHEME}/o then URI::UID.parse(universal_id)
+      else URI::UID.parse(URI::UID.build_string(universal_id))
+      end
+    end
+
+    @id = @uid&.payload
+  end
+end

data/contrib/global_id/global_id_uid_extension.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module UniversalID::Contrib::GlobalIDUIDExtension
+  extend Forwardable
+
+  def self.included(mixer)
+    mixer.extend ClassMethods
+  end
+
+  # Adds all GlobalID::Identification methods
+  def_delegators(:to_global_id_model, *GlobalID::Identification.instance_methods(false))
+
+  # Returns a UniversalID::Contrib::GlobalIDModel instance
+  # which implements the GlobalID::Identification interface/protocol
+  def to_global_id_model
+    UniversalID::Contrib::GlobalIDModel.new self
+  end
+
+  module ClassMethods
+    def from_global_id_record(gid_record)
+      gid_record&.find&.uid
+    end
+
+    def from_global_id(gid, options = {})
+      from_global_id_record GlobalID.parse(gid, options)
+    end
+
+    alias_method :from_gid, :from_global_id
+
+    def from_signed_global_id(sgid, options = {})
+      from_global_id_record SignedGlobalID.parse(sgid, options)
+    end
+
+    alias_method :from_sgid, :from_signed_global_id
+  end
+end

data/contrib/global_id/message_pack_type.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module UniversalID::Contrib::GlobalID; end
+
+require_relative "global_id_model"
+require_relative "global_id_uid_extension"
+
+URI::UID.include UniversalID::Contrib::GlobalIDUIDExtension
+
+UniversalID::MessagePackFactory.register(
+  type: GlobalID,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.to_param },
+  unpacker: ->(unpacker) { GlobalID.parse unpacker.read }
+)

data/contrib/global_id.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined?(GlobalID) && defined?(GlobalID::Identification)
+
+  require_relative "global_id/message_pack_type"
+
+end

data/contrib/signed_global_id/message_pack_type.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: SignedGlobalID,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.to_param },
+  unpacker: ->(unpacker) { SignedGlobalID.parse unpacker.read }
+)

data/contrib/signed_global_id.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined? SignedGlobalID
+
+  require_relative "signed_global_id/message_pack_type"
+
+end

data/contrib/tags

@@ -0,0 +1,75 @@
+!_TAG_EXTRA_DESCRIPTION	anonymous	/Include tags for non-named objects like lambda/
+!_TAG_EXTRA_DESCRIPTION	fileScope	/Include tags of file scope/
+!_TAG_EXTRA_DESCRIPTION	pseudo	/Include pseudo tags/
+!_TAG_EXTRA_DESCRIPTION	subparser	/Include tags generated by subparsers/
+!_TAG_FIELD_DESCRIPTION	epoch	/the last modified time of the input file (only for F\/file kind tag)/
+!_TAG_FIELD_DESCRIPTION	file	/File-restricted scoping/
+!_TAG_FIELD_DESCRIPTION	input	/input file/
+!_TAG_FIELD_DESCRIPTION	name	/tag name/
+!_TAG_FIELD_DESCRIPTION	pattern	/pattern/
+!_TAG_FIELD_DESCRIPTION	typeref	/Type and name of a variable or typedef/
+!_TAG_FIELD_DESCRIPTION!Ruby	mixin	/how the class or module is mixed in (mixin:HOW:MODULE)/
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_KIND_DESCRIPTION!Ruby	A,accessor	/accessors/
+!_TAG_KIND_DESCRIPTION!Ruby	C,constant	/constants/
+!_TAG_KIND_DESCRIPTION!Ruby	L,library	/libraries/
+!_TAG_KIND_DESCRIPTION!Ruby	S,singletonMethod	/singleton methods/
+!_TAG_KIND_DESCRIPTION!Ruby	a,alias	/aliases/
+!_TAG_KIND_DESCRIPTION!Ruby	c,class	/classes/
+!_TAG_KIND_DESCRIPTION!Ruby	f,method	/methods/
+!_TAG_KIND_DESCRIPTION!Ruby	m,module	/modules/
+!_TAG_OUTPUT_EXCMD	mixed	/number, pattern, mixed, or combineV2/
+!_TAG_OUTPUT_FILESEP	slash	/slash or backslash/
+!_TAG_OUTPUT_MODE	u-ctags	/u-ctags or e-ctags/
+!_TAG_OUTPUT_VERSION	0.0	/current.age/
+!_TAG_PARSER_VERSION!Ruby	0.0	/current.age/
+!_TAG_PATTERN_LENGTH_LIMIT	96	/0 for no limit/
+!_TAG_PROC_CWD	/Users/nathan/work/hopsoft/universalid/contrib/	//
+!_TAG_PROGRAM_AUTHOR	Universal Ctags Team	//
+!_TAG_PROGRAM_NAME	Universal Ctags	/Derived from Exuberant Ctags/
+!_TAG_PROGRAM_URL	https://ctags.io/	/official site/
+!_TAG_PROGRAM_VERSION	6.0.0	//
+!_TAG_ROLE_DESCRIPTION!Ruby!library	loaded	/loaded by "load" method/
+!_TAG_ROLE_DESCRIPTION!Ruby!library	required	/loaded by "require" method/
+!_TAG_ROLE_DESCRIPTION!Ruby!library	requiredRel	/loaded by "require_relative" method/
+ActiveRecordPacker	active_record/active_record_packer.rb	/^class UniversalID::Contrib::ActiveRecordPacker$/;"	c	module:UniversalID.Contrib
+ActiveRecordUnpacker	active_record/active_record_unpacker.rb	/^class UniversalID::Contrib::ActiveRecordUnpacker$/;"	c	module:UniversalID.Contrib
+ClassMethods	global_id/global_id_uid_extension.rb	/^  module ClassMethods$/;"	m	module:GlobalIDUIDExtension
+DESCENDANTS_KEY	active_record/active_record_packer.rb	/^  DESCENDANTS_KEY = "uid:descendants"$/;"	C	class:ActiveRecordPacker
+GlobalID	global_id/message_pack_type.rb	/^module UniversalID::Contrib::GlobalID; end$/;"	m	module:UniversalID.Contrib
+GlobalIDModel	global_id/global_id_model.rb	/^class UniversalID::Contrib::GlobalIDModel$/;"	c	module:UniversalID.Contrib	mixin:include:GlobalID.Identification
+GlobalIDUIDExtension	global_id/global_id_uid_extension.rb	/^module UniversalID::Contrib::GlobalIDUIDExtension$/;"	m	module:UniversalID.Contrib	mixin:extend:Forwardable
+HAS_MANY_ASSOCIATIONS	active_record/active_record_packer.rb	/^  HAS_MANY_ASSOCIATIONS = [$/;"	C	class:ActiveRecordPacker
+add_descendants!	active_record/active_record_packer.rb	/^  def add_descendants!(hash)$/;"	f	class:ActiveRecordPacker
+assign_attributes	active_record/active_record_unpacker.rb	/^    def assign_attributes(record, attributes)$/;"	S	class:ActiveRecordUnpacker
+assign_descendants	active_record/active_record_unpacker.rb	/^    def assign_descendants(record, attributes)$/;"	S	class:ActiveRecordUnpacker
+associations	active_record/active_record_packer.rb	/^  def associations$/;"	f	class:ActiveRecordPacker
+create_instance	active_record/active_record_unpacker.rb	/^    def create_instance(class_name, attributes)$/;"	S	class:ActiveRecordUnpacker
+find	global_id/global_id_model.rb	/^  def self.find(value)$/;"	S	class:GlobalIDModel
+foreign_key_column_names	active_record/active_record_packer.rb	/^  def foreign_key_column_names$/;"	f	class:ActiveRecordPacker
+from_gid	global_id/global_id_uid_extension.rb	/^    alias_method :from_gid, :from_global_id$/;"	a	module:GlobalIDUIDExtension.ClassMethods
+from_global_id	global_id/global_id_uid_extension.rb	/^    def from_global_id(gid, options = {})$/;"	f	module:GlobalIDUIDExtension.ClassMethods
+from_global_id_record	global_id/global_id_uid_extension.rb	/^    def from_global_id_record(gid_record)$/;"	f	module:GlobalIDUIDExtension.ClassMethods
+from_sgid	global_id/global_id_uid_extension.rb	/^    alias_method :from_sgid, :from_signed_global_id$/;"	a	module:GlobalIDUIDExtension.ClassMethods
+from_signed_global_id	global_id/global_id_uid_extension.rb	/^    def from_signed_global_id(sgid, options = {})$/;"	f	module:GlobalIDUIDExtension.ClassMethods
+has_many_associations	active_record/active_record_packer.rb	/^  def has_many_associations$/;"	f	class:ActiveRecordPacker
+id	global_id/global_id_model.rb	/^  attr_reader :id, :uid$/;"	A	class:GlobalIDModel
+id_only?	active_record/active_record_packer.rb	/^  def id_only?(prepack_database_options)$/;"	f	class:ActiveRecordPacker
+include_descendants?	active_record/active_record_packer.rb	/^  def include_descendants?$/;"	f	class:ActiveRecordPacker
+included	global_id/global_id_uid_extension.rb	/^  def self.included(mixer)$/;"	S	module:GlobalIDUIDExtension
+initialize	active_record/active_record_packer.rb	/^  def initialize(record)$/;"	f	class:ActiveRecordPacker
+initialize	global_id/global_id_model.rb	/^  def initialize(universal_id)$/;"	f	class:GlobalIDModel
+loaded_has_many_relations_by_name	active_record/active_record_packer.rb	/^  def loaded_has_many_relations_by_name$/;"	f	class:ActiveRecordPacker
+pack_with	active_record/active_record_packer.rb	/^  def pack_with(packer)$/;"	f	class:ActiveRecordPacker
+packable_attributes	active_record/active_record_packer.rb	/^  def packable_attributes$/;"	f	class:ActiveRecordPacker
+prepack_database_options	active_record/active_record_packer.rb	/^  def prepack_database_options$/;"	f	class:ActiveRecordPacker
+prepack_options	active_record/active_record_packer.rb	/^  def prepack_options$/;"	f	class:ActiveRecordPacker
+record	active_record/active_record_packer.rb	/^  attr_reader :record$/;"	A	class:ActiveRecordPacker
+reject_keys!	active_record/active_record_packer.rb	/^  def reject_keys!(hash)$/;"	f	class:ActiveRecordPacker
+reject_timestamps!	active_record/active_record_packer.rb	/^  def reject_timestamps!(hash)$/;"	f	class:ActiveRecordPacker
+reject_unsaved_changes!	active_record/active_record_packer.rb	/^  def reject_unsaved_changes!(hash)$/;"	f	class:ActiveRecordPacker
+timestamp_column_names	active_record/active_record_packer.rb	/^  def timestamp_column_names$/;"	f	class:ActiveRecordPacker
+to_global_id_model	global_id/global_id_uid_extension.rb	/^  def to_global_id_model$/;"	f	module:GlobalIDUIDExtension
+uid	global_id/global_id_model.rb	/^  attr_reader :id, :uid$/;"	A	class:GlobalIDModel
+unpack_with	active_record/active_record_unpacker.rb	/^    def unpack_with(unpacker)$/;"	S	class:ActiveRecordUnpacker

data/lib/universal_id/contrib.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module UniversalID::Contrib; end
+
+# A list of all MessagePack types in the preferred registration order
+#
+# IMPORTANT: More specific types should be registered before more general types
+#            because MessagePack will use the first registered type that matches
+#            MessagePack scans registered type in linear order and first match wins
+
+require_relative "../../contrib/signed_global_id"
+require_relative "../../contrib/global_id"
+require_relative "../../contrib/active_support"
+require_relative "../../contrib/active_record"

data/lib/universal_id/encoder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "base64"
+require "brotli"
+
+# This module provides the ability to encode and decode objects into a compressed, URL-safe string
+module UniversalID::Encoder
+  class << self
+    def encode(object, options = {})
+      object = UniversalID::Prepacker.prepack(object, options)
+
+      # This is basically the same call as UniversalID::MessagePackFactory.pack(object),
+      # but it uses a pool of pre-initialized packers/unpackers instead of creating a new one each time
+      packed = UniversalID::MessagePackFactory.msgpack_pool.dump(object)
+      deflated = Brotli.deflate(packed)
+      Base64.urlsafe_encode64 deflated, padding: false
+    end
+
+    def decode(string)
+      decoded = Base64.urlsafe_decode64(string)
+      inflated = Brotli.inflate(decoded)
+      # This is basically the same call as UniversalID::MessagePackFactory.unpack(object),
+      # but it uses a pool of pre-initialized packers/unpackers instead of creating a new one each time
+      UniversalID::MessagePackFactory.msgpack_pool.load inflated
+    end
+  end
+end

data/lib/universal_id/message_pack_factory.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "etc"
+require "msgpack"
+
+UniversalID::MessagePackFactory = MessagePack::Factory.new.tap do |factory|
+  class << factory
+    attr_reader :msgpack_pool
+
+    def create_msgpack_pool
+      @msgpack_pool = UniversalID::MessagePackFactory.pool([Etc.nprocessors.to_i, 1].max)
+    end
+
+    def register(type:, type_id: nil, recreate_pool: true, **options)
+      id = type_id || next_type_id
+      options[:recursive] = true unless options.key?(:recursive)
+      register_type(id, type, options)
+      create_msgpack_pool if recreate_pool
+    end
+
+    def next_type_id
+      max_type_id = registered_types.map { |type| type[:type].to_i }.max
+      max_type_id.nil? ? 0 : max_type_id + 1
+    end
+  end
+end
+
+# Register MessagePack built-in types
+UniversalID::MessagePackFactory.register_type MessagePack::Timestamp::TYPE, ::Time,
+  packer: MessagePack::Time::Packer,
+  unpacker: MessagePack::Time::Unpacker
+
+# Register MessagePack built-in extensions
+UniversalID::MessagePackFactory.register_type 0x00, ::Symbol
+
+# Register UniversalID types/extensions
+require_relative "message_pack_types"

data/lib/universal_id/message_pack_types/ruby/composites/open_struct.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: OpenStruct,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.to_h },
+  unpacker: ->(unpacker) { OpenStruct.new unpacker.read }
+)

data/lib/universal_id/message_pack_types/ruby/composites/set.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: Set,
+  recusive: true,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.to_a },
+  unpacker: ->(unpacker) { Set.new unpacker.read }
+)

data/lib/universal_id/message_pack_types/ruby/composites/struct.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+using UniversalID::Refinements::KernelRefinement
+
+UniversalID::MessagePackFactory.register(
+  type: Struct,
+  recreate_pool: false,
+  packer: ->(obj, packer) do
+    packer.write obj.class.name
+    packer.write obj.to_h
+  end,
+
+  unpacker: ->(unpacker) do
+    class_name = unpacker.read
+    hash = unpacker.read
+    klass = const_find(class_name)
+
+    # shenanigans to support ::Ruby 3.0.X and 3.1.X
+    RUBY_VERSION.start_with?("3.0", "3.1") ?
+      klass.new.tap { |struct| hash.each { |key, val| struct[key] = hash[key] } } :
+      klass.new(**hash)
+  end
+)

data/lib/universal_id/message_pack_types/ruby/scalars/complex.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: Complex,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.to_s },
+  unpacker: ->(unpacker) { Kernel.Complex unpacker.read }
+)

data/lib/universal_id/message_pack_types/ruby/scalars/date.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: Date,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.iso8601 },
+  unpacker: ->(unpacker) { Date.parse unpacker.read }
+)

data/lib/universal_id/message_pack_types/ruby/scalars/date_time.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: DateTime,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.iso8601(9) },
+  unpacker: ->(unpacker) { DateTime.parse unpacker.read }
+)