evil_events 0.3.1 → 0.4.0

data/lib/evil_events/core/events/serializers/hash/packer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class Hash
+    # @api private
+    # @since 0.4.0
+    class Packer < Base::DataTransformer
+      # @param event [EvilEvents::Core::Events::AbstractEvent]
+      # @raise [EvilEvents::HashSerializationError]
+      # @return [String]
+      #
+      # @see Base::DataTransformer
+      #
+      # @api private
+      # @since 0.4.0
+      def call(event)
+        unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
+          raise EvilEvents::HashSerializationError
+        end
+
+        serialization_state = build_serialization_state(event)
+        engine.dump(serialization_state)
+      end
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/hash/unpacker.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class Hash
+    # @api private
+    # @since 0.4.0
+    class Unpacker < Base::DataTransformer
+      # @param serialized_event [::Hash]
+      # @raise [EvilEvents::HashDeserializationError]
+      # @return [EvilEvents::Core::Events::AbstractEvent]
+      #
+      # @see Base::DataTransformer
+      #
+      # @api private
+      # @since 0.4.0
+      def call(serialized_event)
+        raise EvilEvents::HashDeserializationError unless serialized_event.is_a?(::Hash)
+        serialization_state = engine.load(serialized_event)
+        raise EvilEvents::HashDeserializationError unless serialization_state.valid?
+        restore_event_instance(serialization_state)
+      end
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/json.rb

@@ -1,63 +1,7 @@
 # frozen_string_literal: true
 
 class EvilEvents::Core::Events::Serializers
-  # @api public
-  # @since 0.1.0
-  module JSON
-    # @since 0.1.1
-    extend Base
-
-    class << self
-      # @param event [EvilEvents::Core::Events::AbstractEvent]
-      # @raise [EvilEvents::SerializationError]
-      # @return [::Hash]
-      #
-      # @since 0.1.0
-      def serialize(event)
-        unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
-          raise EvilEvents::SerializationError
-        end
-
-        ::JSON.generate(
-          id:       event.id,
-          type:     event.type,
-          payload:  event.payload,
-          metadata: event.metadata
-        )
-      end
-
-      # @param json [String]
-      # @raise [EvilEvents::DeserializationError]
-      # @return [EvilEvents::Core::Events::AbstractEvent]
-      #
-      # @since 0.1.0
-      def deserialize(json)
-        raise EvilEvents::DeserializationError unless json.is_a?(String)
-
-        begin
-          json_hash      = ::JSON.parse(json, symbolize_names: true)
-          event_id       = json_hash[:id]
-          event_type     = json_hash[:type]
-          event_payload  = json_hash[:payload]
-          event_metadata = json_hash[:metadata]
-
-          unless event_type && event_payload && event_metadata
-            raise EvilEvents::DeserializationError
-          end
-        rescue ::JSON::ParserError
-          raise EvilEvents::DeserializationError
-        end
-
-        restore_event_instance(
-          type:     event_type,
-          id:       event_id,
-          payload:  event_payload,
-          metadata: event_metadata
-        )
-      end
-    end
-  end
-
-  # @since 0.1.0
-  register(:json) { JSON }
+  # @api private
+  # @since 0.4.0
+  JSON = Class.new(Base)
 end

data/lib/evil_events/core/events/serializers/json/config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class JSON
+    # @api private
+    # @since 0.4.0
+    class Config < Base::GenericConfig
+      configure { setting :engine, reader: true }
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/json/engines.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::JSON
+  # @since 0.4.0
+  # @api private
+  class Engines
+    # @since 0.4.0
+    extend EvilEvents::Shared::DependencyContainer::Mixin
+  end
+end

data/lib/evil_events/core/events/serializers/json/engines/native.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::JSON::Engines
+  # @api private
+  # @since 0.4.0
+  class Native < EvilEvents::Core::Events::Serializers::Base::AbstractEngine
+    # @param serialization_state [Base::EventSerializationState]
+    # @return [String]
+    #
+    # @since 0.4.0
+    # @api private
+    def dump(serialization_state)
+      ::JSON.generate(
+        id:       serialization_state.id,
+        type:     serialization_state.type,
+        payload:  serialization_state.payload,
+        metadata: serialization_state.metadata
+      )
+    end
+
+    # @param json_string [String]
+    # @raise [EvilEvents::SerializationEngineError]
+    # @return [EventSerializationState]
+    #
+    # @since 0.4.0
+    # @api private
+    def load(json_string)
+      json = ::JSON.parse(json_string, symbolize_names: true)
+
+      restore_serialization_state(
+        id:       json[:id],
+        type:     json[:type],
+        payload:  json[:payload],
+        metadata: json[:metadata]
+      )
+    rescue ::JSON::ParserError, TypeError
+      raise EvilEvents::SerializationEngineError
+    end
+  end
+
+  # @since 0.4.0
+  register(:native, Native)
+end

data/lib/evil_events/core/events/serializers/json/factory.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class JSON
+    # @api private
+    # @since 0.4.0
+    class Factory < AbstractFactory
+      # @return [JSON::Config]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_config
+        settings = EvilEvents::Core::Bootstrap[:config].serializers.json
+
+        Config.new do |config|
+          config.engine = settings.engine
+        end
+      end
+
+      # @param config [JSON::Config]
+      # @raise [EvilEvents::UnrecognizedSerializationEngineError]
+      # @return [Base::AbstractEngine]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_engine(config)
+        Engines.resolve(config.engine).new(config)
+      rescue Dry::Container::Error
+        raise EvilEvents::UnrecognizedSerializationEngineError
+      end
+
+      # @param engine [Base::AbstractEngine]
+      # @param config [JSON::Config]
+      # @return [JSON::Packer]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_packer(engine, _config)
+        Packer.new(engine)
+      end
+
+      # @param engine [Base::AbstractEngine]
+      # @param config [JSON::Config]
+      # @return [JSON::Unpacker]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_unpacker(engine, _config)
+        Unpacker.new(engine)
+      end
+
+      # @param engine [Base::AbstractEngine]
+      # @param config [JSON::Config]
+      # @param packer [JSON::Packer]
+      # @param unpacker [JSON::Unpacker]
+      # @return [JSON]
+      #
+      # @api private
+      # @since 0.4.0
+      def create_adapter(engine, config, packer, unpacker)
+        JSON.new(engine, config, packer, unpacker)
+      end
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/json/packer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class JSON
+    # @api private
+    # @since 0.4.0
+    class Packer < Base::DataTransformer
+      # @param event [EvilEvents::Core::Events::AbstractEvent]
+      # @raise [EvilEvents::JSONSerializationError]
+      # @return [String]
+      #
+      # @see Base::DataTransformer
+      #
+      # @api private
+      # @since 0.4.0
+      def call(event)
+        unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
+          raise EvilEvents::JSONSerializationError
+        end
+
+        serialization_state = build_serialization_state(event)
+        engine.dump(serialization_state)
+      end
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/json/unpacker.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class JSON
+    # @api private
+    # @since 0.4.0
+    class Unpacker < Base::DataTransformer
+      # @param serialized_event [String]
+      # @raise [EvilEvents::JSONDeserializationError]
+      # @return [EvilEvents::Core::Events::AbstractEvent]
+      #
+      # @see Base::DataTransformer
+      #
+      # @api private
+      # @since 0.4.0
+      def call(serialized_event)
+        raise EvilEvents::JSONDeserializationError unless serialized_event.is_a?(String)
+
+        begin
+          serialization_state = engine.load(serialized_event)
+        rescue EvilEvents::SerializationEngineError
+          raise EvilEvents::JSONDeserializationError
+        end
+
+        raise EvilEvents::JSONDeserializationError unless serialization_state.valid?
+
+        restore_event_instance(serialization_state)
+      end
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/message_pack.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  # @api private
+  # @since 0.4.0
+  MessagePack = Class.new(Base)
+end

data/lib/evil_events/core/events/serializers/message_pack/config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class MessagePack
+    # @api private
+    # @since 0.4.0
+    class Config < Base::GenericConfig
+      configure do
+        setting :engine, reader: true
+
+        setting :mpacker, reader: true do
+          setting :configurator, ->(engine) {}
+        end
+      end
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/message_pack/engines.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::MessagePack
+  # @since 0.4.0
+  # @api private
+  class Engines
+    # @since 0.4.0
+    extend EvilEvents::Shared::DependencyContainer::Mixin
+  end
+end

data/lib/evil_events/core/events/serializers/message_pack/engines/mpacker.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::MessagePack::Engines
+  # @api private
+  # @since 0.4.0
+  class Mpacker < EvilEvents::Core::Events::Serializers::Base::AbstractEngine
+    # @param config [EvilEvents::Core::Events::Serializers::MessagePack::Config]
+    # @raise [EvilEvents::SerializationEngineError]
+    #
+    # @api private
+    # @since 0.4.0
+    def initialize(config)
+      configurator = config.mpacker.configurator
+      raise EvilEvents::SerializationEngineError unless configurator.is_a?(Proc)
+      @factory = ::MessagePack::Factory.new.tap { |factory| configurator.call(factory) }
+    end
+
+    # @param serialization_state [Base::EventSerializationState]
+    # @return [String]
+    #
+    # @since 0.4.0
+    # @api private
+    def dump(serialization_state)
+      packer.pack(
+        id:       serialization_state.id,
+        type:     serialization_state.type,
+        payload:  serialization_state.payload,
+        metadata: serialization_state.metadata
+      ).to_str
+    end
+
+    # @param message [String]
+    # @raise [EvilEvents::SerializationEngineError]
+    # @return [EventSerializationState]
+    #
+    # @since 0.4.0
+    # @api private
+    def load(message)
+      begin
+        event_data = unpacker.feed(message).unpack
+        raise EvilEvents::SerializationEngineError unless event_data.is_a?(::Hash)
+      rescue ::MessagePack::UnpackError, ArgumentError, TypeError
+        raise EvilEvents::SerializationEngineError
+      end
+
+      restore_serialization_state(
+        id:       event_data[:id],
+        type:     event_data[:type],
+        payload:  event_data[:payload],
+        metadata: event_data[:metadata]
+      )
+    end
+
+    private
+
+    # @return [::MessagePack::Factory]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :factory
+
+    # @return [::MessagePack::Packer]
+    #
+    # @api private
+    # @since 0.4.0
+    def packer
+      factory.packer
+    end
+
+    # @return [::MessagePack::Unpacker]
+    #
+    # @api private
+    # @since 0.4.0
+    def unpacker
+      factory.unpacker(symbolize_keys: true)
+    end
+  end
+
+  # @since 0.4.0
+  register(:mpacker, Mpacker)
+end

data/lib/evil_events/core/events/serializers/message_pack/factory.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class MessagePack
+    # @api private
+    # @since 0.4.0
+    class Factory < AbstractFactory
+      # @return [MessagePack::Config]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_config
+        settings = EvilEvents::Core::Bootstrap[:config].serializers.msgpack
+
+        Config.new do |config|
+          config.engine = settings.engine
+          config.mpacker.configurator = settings.mpacker.configurator
+        end
+      end
+
+      # @param config [MessagePack::Config]
+      # @raise [EvilEvents::UnrecognizedSerializationEngineError]
+      # @return [Base::AbstractEngine]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_engine(config)
+        Engines.resolve(config.engine).new(config)
+      rescue Dry::Container::Error
+        raise EvilEvents::UnrecognizedSerializationEngineError
+      end
+
+      # @param engine [Base::AbstractEngine]
+      # @param config [MessagePack::Config]
+      # @return [MessagePack::Packer]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_packer(engine, _config)
+        Packer.new(engine)
+      end
+
+      # @param engine [Base::AbstractEngine]
+      # @param config [MessagePack::Config]
+      # @return [MessagePack::Unpacker]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_unpacker(engine, _config)
+        Unpacker.new(engine)
+      end
+
+      # @param engine [Base::AbstractEngine]
+      # @param config [MessagePack::Config]
+      # @param packer [MessagePack::Packer]
+      # @param unpacker [MessagePack::Unpacker]
+      #
+      # @api private
+      # @since 0.4.0
+      def create_adapter(engine, config, packer, unpacker)
+        MessagePack.new(engine, config, packer, unpacker)
+      end
+    end
+  end
+end