evil_events 0.3.1 → 0.4.0

data/lib/evil_events/core/events/serializers/base/abstract_engine.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::Base
+  # @api private
+  # @since 0.4.0
+  class AbstractEngine
+    # @param config [GenericConfig]
+    #
+    # @api private
+    # @since 0.4.0
+    def initialize(config); end
+
+    # @param data [EventSerializationState]
+    # @return [Object]
+    #
+    # @api private
+    # @since 0.4.0
+    def dump(serialization_state); end
+
+    # @param data [Object]
+    # @return [EventSerializationState]
+    #
+    # @api private
+    # @since 0.4.0
+    def load(data); end
+
+    private
+
+    # @option id [String,Integer,Object]
+    # @option type [String]
+    # @option payload [::Hash]
+    # @option metadata [::Hash]
+    #
+    # @return [EventSerializationState]
+    #
+    # @api private
+    # @since 0.4.0
+    def restore_serialization_state(id:, type:, payload:, metadata:)
+      EventSerializationState.build_from_options(
+        id:       id,
+        type:     type,
+        payload:  payload,
+        metadata: metadata
+      )
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/base/abstract_factory.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::Base
+  # @api private
+  # @since 0.4.0
+  class AbstractFactory
+    # @return [Base]
+    #
+    # @api private
+    # @since 0.4.0
+    def create!
+      config = build_config
+      engine = build_engine(config)
+
+      packer   = build_packer(engine, config)
+      unpacker = build_unpacker(engine, config)
+
+      create_adapter(engine, config, packer, unpacker)
+    end
+
+    # @return [Base::GenericConfig]
+    #
+    # @api private
+    # @since 0.4.0
+    def build_config; end
+
+    # @param config [Base::GenericConfig]
+    # @return [Base::Engines::Abstract]
+    #
+    # @api private
+    # @since 0.4.0
+    def build_engine(config); end
+
+    # @param engine [Base::Engines::Abstract]
+    # @param config [Base::GenericConfig]
+    # @return [Base::Dumper]
+    #
+    # @api private
+    # @since 0.4.0
+    def build_packer(engine, config); end
+
+    # @param engine [Base::Engines::Abstract]
+    # @param config [Base::GenericConfig]
+    # @return [Base::Dumper]
+    #
+    # @api private
+    # @since 0.4.0
+    def build_unpacker(engine, config); end
+
+    # @param engine [Base::AbstractEngine]
+    # @param config [Base::GenericConfig]
+    # @param packer [Base::DataTransformer]
+    # @param unpacker [Base::DataTransformer]
+    # @return [Base]
+    #
+    # @api private
+    # @since 0.4.0
+    def create_adapter(engine, config, packer, unpacker); end
+  end
+end

data/lib/evil_events/core/events/serializers/base/data_transformer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::Base
+  # @api private
+  # @since 0.4.0
+  class DataTransformer
+    # @param engine [Base::Engine::Abstract]
+    #
+    # @api private
+    # @since 0.4.0
+    def initialize(engine)
+      @engine = engine
+    end
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return [Object]
+    #
+    # @api private
+    # @since 0.4.0
+    def call(event); end
+
+    private
+
+    # @return [Base::Engine::Abstract]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :engine
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return [EventSerializationState]
+    #
+    # @api private
+    # @since 0.4.0
+    def build_serialization_state(event)
+      EventSerializationState.build_from_event(event)
+    end
+
+    # @param serialization_state [EventSerializationState]
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @api private
+    # @since 0.4.0
+    def restore_event_instance(serialization_state)
+      event_class = EvilEvents::Core::Bootstrap[:event_system].resolve_event_class(
+        serialization_state.type
+      )
+
+      EvilEvents::Core::Events::EventFactory.restore_instance(
+        event_class,
+        id: serialization_state.id,
+        payload: serialization_state.payload,
+        metadata: serialization_state.metadata
+      )
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/base/event_serialization_state.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::Base
+  # @api private
+  # @since 0.4.0
+  class EventSerializationState
+    class << self
+      # @param event [EvilEvents::Core::Event::AbstractEvent]
+      # @return [EventSerializationState]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_from_event(event)
+        new(id: event.id, type: event.type, payload: event.payload, metadata: event.metadata)
+      end
+
+      # @option id [String,Integer,Object]
+      # @option type [String]
+      # @option payload [::Hash]
+      # @option metadata [::Hash]
+      # @return [EventSerializationState]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_from_options(**options)
+        new(**options)
+      end
+    end
+
+    # @return [String, Integer, Object]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :id
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :type
+
+    # @return [::Hash]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :payload
+
+    # @return [::Hash]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :metadata
+
+    # @option id [String,Integer,Object]
+    # @option type [String]
+    # @option payload [::Hash]
+    # @option metadata [::Hash]
+    #
+    # @api private
+    # @since 0.4.0
+    def initialize(id:, type:, payload:, metadata:)
+      @id       = id
+      @type     = type
+      @payload  = payload
+      @metadata = metadata
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.4.0
+    def valid?
+      return false unless type && payload && metadata
+      return false unless payload.is_a?(::Hash)
+      return false unless metadata.is_a?(::Hash)
+      return false unless type.is_a?(String)
+      true
+    end
+  end
+end

data/lib/evil_events/core/events/serializers/base/generic_config.rb

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

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

@@ -1,77 +1,7 @@
 # frozen_string_literal: true
 
 class EvilEvents::Core::Events::Serializers
-  # @api public
-  # @since 0.1.0
-  module Hash
-    # @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
-
-        {
-          id:       event.id,
-          type:     event.type,
-          payload:  event.payload,
-          metadata: event.metadata
-        }
-      end
-
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-
-      # @param hash [::Hash]
-      # @raise [EvilEvents::DeserializationError]
-      # @return [EvilEvents::Core::Events::AbstractEvent]
-      #
-      # @since 0.1.0
-      def deserialize(hash)
-        raise EvilEvents::DeserializationError unless hash.is_a?(::Hash)
-
-        event_id       = hash[:id]       || hash['id']
-        event_type     = hash[:type]     || hash['type']
-        event_payload  = hash[:payload]  || hash['payload']
-        event_metadata = hash[:metadata] || hash['metadata']
-
-        raise EvilEvents::DeserializationError unless event_type && event_payload && event_metadata
-        raise EvilEvents::DeserializationError unless event_payload.is_a?(::Hash)
-        raise EvilEvents::DeserializationError unless event_metadata.is_a?(::Hash)
-
-        restore_event_instance(
-          type:     event_type,
-          id:       event_id,
-          payload:  symbolized_event_data(event_payload),
-          metadata: symbolized_event_data(event_metadata)
-        )
-      end
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
-
-      private
-
-      # @param payload_hash [::Hash]
-      # @return [::Hash]
-      #
-      # @since 0.1.0
-      def symbolized_event_data(payload_hash)
-        payload_hash.each_pair.each_with_object({}) do |(key, value), result_hash|
-          result_hash[key.to_sym] = value
-        end
-      end
-    end
-  end
-
-  # @since 0.1.0
-  register(:hash) { Hash }
+  # @api private
+  # @since 0.4.0
+  Hash = Class.new(Base)
 end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class Hash
+    # @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/hash/engines.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::Hash
+  # @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/hash/engines/native.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::Hash::Engines
+  # @api private
+  # @since 0.4.0
+  class Native < EvilEvents::Core::Events::Serializers::Base::AbstractEngine
+    # @param serialization_state [Base::EventSerializationState]
+    # @return [::Hash]
+    #
+    # @since 0.4.0
+    # @api private
+    def dump(serialization_state)
+      {
+        id:       serialization_state.id,
+        type:     serialization_state.type,
+        payload:  serialization_state.payload,
+        metadata: serialization_state.metadata
+      }
+    end
+
+    # @param hash [::Hash]
+    # @raise [EvilEvents::SerializationEngineError]
+    # @return [EventSerializationState]
+    #
+    # @since 0.4.0
+    # @api private
+    def load(hash)
+      begin
+        event_id       = hash[:id]       || hash['id']
+        event_type     = hash[:type]     || hash['type']
+        event_payload  = hash[:payload]  || hash['payload']
+        event_metadata = hash[:metadata] || hash['metadata']
+      rescue NoMethodError, TypeError, ArgumentError
+        raise EvilEvents::SerializationEngineError
+      end
+
+      restore_serialization_state(
+        id:       event_id,
+        type:     event_type,
+        payload:  (symbolized_hash(event_payload)  if event_payload),
+        metadata: (symbolized_hash(event_metadata) if event_metadata)
+      )
+    end
+
+    private
+
+    # @param hash [::Hash]
+    # @return [::Hash]
+    #
+    # @since 0.1.0
+    def symbolized_hash(hash)
+      hash.each_pair.each_with_object({}) do |(key, value), result_hash|
+        result_hash[key.to_sym] = value
+      end
+    end
+  end
+
+  # @since 0.4.0
+  register(:native, Native)
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  class Hash
+    # @api private
+    # @since 0.4.0
+    class Factory < AbstractFactory
+      # @return [Hash::Config]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_config
+        settings = EvilEvents::Core::Bootstrap[:config].serializers.hashing
+
+        Config.new do |config|
+          config.engine = settings.engine
+        end
+      end
+
+      # @param config [Hash::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 [Hash::Config]
+      # @return [Hash::Packer]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_packer(engine, _config)
+        Packer.new(engine)
+      end
+
+      # @param engine [Base::AbstractEngine]
+      # @param config [Hash::Config]
+      # @return [Hash::Unpacker]
+      #
+      # @api private
+      # @since 0.4.0
+      def build_unpacker(engine, _config)
+        Unpacker.new(engine)
+      end
+
+      # @param engine [Base::AbstractEngine]
+      # @param config [Hash::Config]
+      # @param packer [Hash::Packer]
+      # @param unpacker [Hash::Unpacker]
+      # @return [Hash]
+      #
+      # @api private
+      # @since 0.4.0
+      def create_adapter(engine, config, packer, unpacker)
+        Hash.new(engine, config, packer, unpacker)
+      end
+    end
+  end
+end