paquito 0.1.0

data/lib/paquito/conditional_compressor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Paquito
+  class ConditionalCompressor
+    UNCOMPRESSED = 0
+    COMPRESSED = 1
+
+    def initialize(compressor, compress_threshold)
+      @compressor = Paquito.cast(compressor)
+      @compress_threshold = compress_threshold
+    end
+
+    def dump(uncompressed)
+      uncompressed_size = uncompressed.bytesize
+      version = UNCOMPRESSED
+      value = uncompressed
+
+      if @compress_threshold && uncompressed_size > @compress_threshold
+        compressed = @compressor.dump(uncompressed)
+        if compressed.bytesize < uncompressed_size
+          version = COMPRESSED
+          value = compressed
+        end
+      end
+
+      version.chr(Encoding::BINARY) << value
+    end
+
+    def load(payload)
+      payload_version = payload.getbyte(0)
+      data = payload.byteslice(1..-1)
+      case payload_version
+      when UNCOMPRESSED
+        data
+      when COMPRESSED
+        @compressor.load(data)
+      else
+        raise ArgumentError, "invalid ConditionalCompressor version"
+      end
+    end
+  end
+end

data/lib/paquito/deflater.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Paquito
+  class Deflater
+    def initialize(deflater)
+      @deflater = deflater
+    end
+
+    def dump(serial)
+      @deflater.deflate(serial)
+    end
+
+    def load(payload)
+      @deflater.inflate(payload)
+    end
+  end
+end

data/lib/paquito/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Paquito
+  Error = Class.new(StandardError)
+
+  class PackError < Error
+    attr_reader :receiver
+    def initialize(msg, receiver = nil)
+      super(msg)
+      @receiver = receiver
+    end
+  end
+
+  UnpackError = Class.new(Error)
+  ClassMissingError = Class.new(Error)
+  UnsupportedType = Class.new(Error)
+  UnsupportedCodec = Class.new(Error)
+  VersionMismatchError = Class.new(Error)
+end

data/lib/paquito/safe_yaml.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+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
+
+    def initialize(permitted_classes: [], deprecated_classes: [], aliases: false)
+      permitted_classes += BASE_PERMITTED_CLASSNAMES
+      @dumpable_classes = permitted_classes
+      @loadable_classes = permitted_classes + deprecated_classes
+      @aliases = aliases
+
+      @dump_options = {
+        permitted_classes: permitted_classes,
+        permitted_symbols: ALL_SYMBOLS,
+        aliases: true,
+        line_width: -1, # Disable YAML line-wrapping because it causes extremely obscure issues.
+      }.freeze
+    end
+
+    def load(serial)
+      Psych.safe_load(
+        serial,
+        permitted_classes: @loadable_classes,
+        permitted_symbols: ALL_SYMBOLS,
+        aliases: @aliases,
+      )
+    rescue Psych::DisallowedClass => psych_error
+      raise UnsupportedType, psych_error.message
+    rescue Psych::Exception => psych_error
+      raise UnpackError, psych_error.message
+    end
+
+    def dump(obj)
+      visitor = RestrictedYAMLTree.create(@dump_options)
+      visitor << obj
+      visitor.tree.yaml(nil, @dump_options)
+    rescue Psych::Exception => psych_error
+      raise PackError, psych_error.message
+    end
+
+    class RestrictedYAMLTree < Psych::Visitors::YAMLTree
+      class DispatchCache
+        def initialize(visitor, cache, permitted_classes)
+          @visitor = visitor
+          @cache = cache
+          @permitted_classes = permitted_classes
+
+          @permitted_cache = Hash.new do |h, klass|
+            unless @permitted_classes.include?(klass.name)
+              raise UnsupportedType, "Tried to dump unspecified class: #{klass.name.inspect}"
+            end
+
+            h[klass] = true
+          end.compare_by_identity
+        end
+
+        def [](klass)
+          if @permitted_cache[klass]
+            @cache[klass]
+          end
+        end
+      end
+
+      def initialize(...)
+        super
+        @permitted_classes = Set.new(@options[:permitted_classes])
+        @dispatch_cache = DispatchCache.new(self, @dispatch_cache, @permitted_classes)
+      end
+    end
+  end
+end

data/lib/paquito/serialized_column.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Paquito
+  class SerializedColumn
+    def initialize(coder, type = nil, attribute_name: nil)
+      @coder = coder
+      @type = type
+      @attribute_name = attribute_name || "Attribute"
+      check_arity_of_constructor
+      @default_value = type&.new
+    end
+
+    def object_class
+      @type || Object
+    end
+
+    def load(payload)
+      return @type&.new if payload.nil?
+
+      object = @coder.load(payload)
+      check_type(object)
+      object || @type&.new
+    end
+
+    def dump(object)
+      return if object.nil? || object == @default_value
+
+      check_type(object)
+      @coder.dump(object)
+    end
+
+    private
+
+    def check_arity_of_constructor
+      load(nil)
+    rescue ArgumentError
+      raise ArgumentError,
+        "Cannot serialize #{object_class}. Classes passed to `serialize` must have a 0 argument constructor."
+    end
+
+    def default_value?(object)
+      object == @type&.new
+    end
+
+    def check_type(object)
+      unless @type.nil? || object.is_a?(@type) || object.nil?
+        raise ActiveRecord::SerializationTypeMismatch, "#{@attribute_name} was supposed to be a #{object_class}, " \
+          "but was a #{object.class}. -- #{object.inspect}"
+      end
+    end
+  end
+end

data/lib/paquito/single_byte_prefix_version.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Paquito
+  class SingleBytePrefixVersion
+    def initialize(current_version, coders)
+      @current_version = current_version
+      @coders = coders.transform_values { |c| Paquito.cast(c) }
+      @current_coder = coders.fetch(current_version)
+    end
+
+    def dump(object)
+      @current_version.chr(Encoding::BINARY) << @current_coder.dump(object)
+    end
+
+    def load(payload)
+      payload_version = payload.getbyte(0)
+      unless payload_version
+        raise UnsupportedCodec, "Missing version byte."
+      end
+
+      coder = @coders.fetch(payload_version) do
+        raise UnsupportedCodec, "Unsupported packer version #{payload_version}"
+      end
+      coder.load(payload.byteslice(1..-1))
+    end
+  end
+end

data/lib/paquito/struct.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require "paquito/errors"
+
+module Paquito
+  # To make a Struct class cacheable, include Paquito::Struct:
+  #
+  #   MyStruct = Struct.new(:foo, :bar)
+  #   MyStruct.include(Paquito::Struct)
+  #
+  # Alternatively, declare the struct with Paquito::Struct#new:
+  #
+  #   MyStruct = Paquito::Struct.new(:foo, :bar)
+  #
+  # The struct defines #as_pack and .from_pack methods:
+  #
+  #   my_struct = MyStruct.new("foo", "bar")
+  #   my_struct.as_pack
+  #   => [26450, "foo", "bar"]
+  #
+  #   MyStruct.from_pack([26450, "foo", "bar"])
+  #   => #<struct FooStruct foo="foo", bar="bar">
+  #
+  # The Paquito::Struct module can be used in non-Struct classes, so long
+  # as the class:
+  #
+  # - defines a #values instance method
+  # - defines a .members class method
+  # - has an #initialize method that accepts the values as its arguments
+  #
+  # If the last condition is _not_ met, you can override .from_pack on the
+  # class and initialize the instance however you like, optionally using the
+  # private extract_packed_values method to extract values from the payload.
+  #
+  module Struct
+    class << self
+      def included(base)
+        base.class_eval do
+          @__kw_init__ = inspect.include?("keyword_init: true")
+        end
+        base.extend(ClassMethods)
+      end
+    end
+
+    def as_pack
+      [self.class.pack_digest, *values]
+    end
+
+    class << self
+      def new(*members, keyword_init: false, &block)
+        struct = ::Struct.new(*members, keyword_init: keyword_init, &block)
+        struct.include(Paquito::Struct)
+        struct
+      end
+
+      def digest(attr_names)
+        ::Digest::MD5.digest(attr_names.map(&:to_s).join(",")).unpack1("s")
+      end
+    end
+
+    module ClassMethods
+      def from_pack(packed)
+        values = extract_packed_values(packed, as_hash: @__kw_init__)
+
+        if @__kw_init__
+          new(**values)
+        else
+          new(*values)
+        end
+      end
+
+      def pack_digest
+        @pack_digest ||= ::Paquito::Struct.digest(members)
+      end
+
+      private
+
+      def extract_packed_values(packed, as_hash:)
+        digest, *values = packed
+        if pack_digest != digest
+          raise(VersionMismatchError, "#{self} digests do not match")
+        end
+
+        as_hash ? members.zip(values).to_h : values
+      end
+    end
+  end
+end

data/lib/paquito/translate_errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Paquito
+  class TranslateErrors
+    def initialize(coder)
+      @coder = coder
+    end
+
+    def dump(object)
+      @coder.dump(object)
+    rescue Paquito::Error
+      raise
+    rescue => error
+      raise PackError, error.message
+    end
+
+    def load(payload)
+      @coder.load(payload)
+    rescue Paquito::Error
+      raise
+    rescue => error
+      raise UnpackError, error.message
+    end
+  end
+end

data/lib/paquito/typed_struct.rb

@@ -0,0 +1,53 @@
+# typed: true
+# frozen_string_literal: true
+
+return unless defined?(T::Props)
+
+module Paquito
+  # To make a T::Struct class serializable, include Paquito::TypedStruct:
+  #
+  #   class MyStruct < T::Struct
+  #     include Paquito::TypedStruct
+  #
+  #     prop :foo, String
+  #     prop :bar, Integer
+  #   end
+  #
+  #   my_struct = MyStruct.new(foo: "foo", bar: 1)
+  #   my_struct.as_pack
+  #   => [26450, "foo", 1]
+  #
+  #   MyStruct.from_pack([26450, "foo", 1])
+  #   => <MyStruct bar=1, foo="foo">
+  #
+  module TypedStruct
+    extend T::Sig
+    include T::Props::Plugin
+
+    sig { returns(Array).checked(:never) }
+    def as_pack
+      decorator = self.class.decorator
+      props = decorator.props.keys
+      values = props.map { |prop| decorator.get(self, prop) }
+      [self.class.pack_digest, *values]
+    end
+
+    module ClassMethods
+      extend T::Sig
+
+      sig { params(packed: Array).returns(T.untyped).checked(:never) }
+      def from_pack(packed)
+        digest, *values = packed
+        if pack_digest != digest
+          raise(VersionMismatchError, "#{self} digests do not match")
+        end
+        new(**props.keys.zip(values).to_h)
+      end
+
+      sig { returns(Integer).checked(:never) }
+      def pack_digest
+        @pack_digest ||= Paquito::Struct.digest(props.keys)
+      end
+    end
+  end
+end

data/lib/paquito/types/active_record_packer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "paquito/errors"
+require "paquito/active_record_coder"
+
+module Paquito
+  module Types
+    class ActiveRecordPacker
+      factory = MessagePack::Factory.new
+      # These are the types available when packing/unpacking ActiveRecord::Base instances.
+      Types.register(factory, [Symbol, Time, DateTime, Date, BigDecimal, ActiveSupport::TimeWithZone])
+      FACTORY = factory
+      # Raise on any undeclared type
+      factory.register_type(
+        0x7f,
+        Object,
+        packer: ->(value) { raise PackError.new("undeclared type", value) },
+        unpacker: ->(*) {}
+      )
+
+      core_types = [String, Integer, TrueClass, FalseClass, NilClass, Float, Array, Hash]
+      ext_types = FACTORY.registered_types.map { |t| t[:class] }
+      VALID_CLASSES = core_types + ext_types
+
+      def self.dump(value)
+        coded = ActiveRecordCoder.dump(value)
+        FACTORY.dump(coded)
+      rescue NoMethodError, PackError => e
+        raise unless PackError === e || e.name == :to_msgpack
+
+        class_name = value.class.name
+        receiver_name = e.receiver.class.name
+        error_attrs = coded[1][1].select { |_, attr_value| VALID_CLASSES.exclude?(attr_value.class) }
+
+        Rails.logger.warn(<<~LOG.squish)
+          [MessagePackCodecTypes]
+          Failed to encode record with ActiveRecordCoder
+          class=#{class_name}
+          error_class=#{receiver_name}
+          error_attrs=#{error_attrs.keys.join(", ")}
+        LOG
+
+        raise PackError.new("failed to pack ActiveRecord object", e.receiver)
+      end
+
+      def self.load(value)
+        ActiveRecordCoder.load(FACTORY.load(value))
+      end
+    end
+  end
+end

data/lib/paquito/types.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "paquito/errors"
+
+module Paquito
+  module Types
+    autoload :ActiveRecordPacker, "paquito/types/active_record_packer"
+
+    # Do not change those formats, this would break current codecs.
+    TIME_FORMAT = "q< L<"
+    TIME_WITH_ZONE_FORMAT = "q< L< a*"
+    DATE_TIME_FORMAT = "s< C C C C q< L< c C"
+    DATE_FORMAT = "s< C C"
+
+    SERIALIZE_METHOD = :as_pack
+    SERIALIZE_PROC = SERIALIZE_METHOD.to_proc
+    DESERIALIZE_METHOD = :from_pack
+
+    class CustomTypesRegistry
+      class << self
+        def packer(value)
+          packers.fetch(klass = value.class) do
+            if packable?(value) && unpackable?(klass)
+              @packers[klass] = SERIALIZE_PROC
+            end
+          end
+        end
+
+        def unpacker(klass)
+          unpackers.fetch(klass) do
+            if unpackable?(klass)
+              @unpackers[klass] = klass.method(DESERIALIZE_METHOD).to_proc
+            end
+          end
+        end
+
+        def register(klass, packer: nil, unpacker:)
+          if packer
+            raise ArgumentError, "packer for #{klass} already defined" if packers.key?(klass)
+            packers[klass] = packer
+          end
+
+          raise ArgumentError, "unpacker for #{klass} already defined" if unpackers.key?(klass)
+          unpackers[klass] = unpacker
+
+          self
+        end
+
+        private
+
+        def packable?(value)
+          value.class.method_defined?(SERIALIZE_METHOD) ||
+            raise(PackError.new("#{value.class} is not serializable", value))
+        end
+
+        def unpackable?(klass)
+          klass.respond_to?(DESERIALIZE_METHOD) ||
+            raise(UnpackError, "#{klass} is not deserializable")
+        end
+
+        def packers
+          @packers ||= {}
+        end
+
+        def unpackers
+          @unpackers ||= {}
+        end
+      end
+    end
+
+    # 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: 0x00,
+        packer: :to_s,
+        unpacker: :to_sym,
+      }.freeze,
+      "Time" => {
+        code: 0x01,
+        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: 0x02,
+        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
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            Rational(sec_numerator, sec_denominator),
+            Rational(offset_numerator, offset_denominator),
+          )
+        end,
+      }.freeze,
+      "Date" => {
+        code: 0x03,
+        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,
+      }.freeze,
+      "BigDecimal" => {
+        code: 0x04,
+        packer: :_dump,
+        unpacker: BigDecimal.method(:_load),
+      }.freeze,
+      # Range => { code: 0x05 }, do not recycle that code
+      "ActiveRecord::Base" => {
+        code: 0x6,
+        packer: ->(value) { ActiveRecordPacker.dump(value) },
+        unpacker: ->(value) { ActiveRecordPacker.load(value) },
+      }.freeze,
+      "ActiveSupport::HashWithIndifferentAccess" => {
+        code: 0x7,
+        packer: ->(factory, value) do
+          unless value.instance_of?(ActiveSupport::HashWithIndifferentAccess)
+            raise PackError.new("cannot pack HashWithIndifferentClass subclass", value)
+          end
+          factory.dump(value.to_h)
+        end,
+        unpacker: ->(factory, value) { HashWithIndifferentAccess.new(factory.load(value)) },
+      },
+      "ActiveSupport::TimeWithZone" => {
+        code: 0x8,
+        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" => {
+        code: 0x9,
+        packer: ->(factory, value) { factory.dump(value.to_a) },
+        unpacker: ->(factory, value) { factory.load(value).to_set },
+      },
+      # Object => { code: 0x7f }, reserved for serializable Object type
+    }.freeze
+
+    class << self
+      def register(factory, types)
+        types.each do |type|
+          name = type.name
+
+          # Up to Rails 7 ActiveSupport::TimeWithZone#name returns "Time"
+          if name == "Time" && defined?(ActiveSupport::TimeWithZone)
+            name = "ActiveSupport::TimeWithZone" if type == ActiveSupport::TimeWithZone
+          end
+
+          type_attributes = TYPES.fetch(name)
+          factory.register_type(
+            type_attributes.fetch(:code),
+            type,
+            packer: curry_callback(type_attributes.fetch(:packer), factory),
+            unpacker: curry_callback(type_attributes.fetch(:unpacker), factory),
+          )
+        end
+      end
+
+      def register_serializable_type(factory)
+        factory.register_type(
+          0x7f,
+          Object,
+          packer: ->(value) do
+            packer = CustomTypesRegistry.packer(value)
+            class_name = value.class.to_s
+            factory.dump([packer.call(value), class_name])
+          end,
+          unpacker: ->(value) do
+            payload, class_name = factory.load(value)
+
+            begin
+              klass = Object.const_get(class_name)
+            rescue NameError
+              raise ClassMissingError, "missing #{class_name} class"
+            end
+
+            unpacker = CustomTypesRegistry.unpacker(klass)
+            unpacker.call(payload)
+          end
+        )
+      end
+
+      def define_custom_type(klass, packer: nil, unpacker:)
+        CustomTypesRegistry.register(klass, packer: packer, unpacker: unpacker)
+      end
+
+      private
+
+      def curry_callback(callback, factory)
+        return callback.to_proc if callback.is_a?(Symbol)
+        return callback if callback.arity == 1
+        callback.curry.call(factory)
+      end
+    end
+  end
+end

data/lib/paquito/version.rb

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