evil_events 0.3.1 → 0.4.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers::XML::Engines
+  # @api private
+  # @since 0.4.0
+  class Ox < EvilEvents::Core::Events::Serializers::Base::AbstractEngine
+    # @param serialization_state [Base::EventSerializationState]
+    # @return [String]
+    #
+    # @since 0.4.0
+    # @api private
+    def dump(serialization_state)
+      ::Ox.dump(serialization_state)
+    end
+
+    # @param xml [String]
+    # @raise [EvilEvents::SerializationEngineError]
+    # @return [EventSerializationState]
+    #
+    # @since 0.4.0
+    # @api private
+    def load(xml)
+      ::Ox.parse_obj(xml)
+    rescue ::Ox::Error, NoMethodError, TypeError, ArgumentError
+      raise EvilEvents::SerializationEngineError
+    end
+  end
+
+  # @since 0.4.0
+  register(:ox, Ox)
+end

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

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

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

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

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

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

data/lib/evil_events/core/events/subscriber/mixin.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 class EvilEvents::Core::Events::Subscriber
+  # rubocop:disable Metrics/BlockLength
+
   # @api public
   # @since 0.1.0
   Mixin = EvilEvents::Shared::ClonableModuleBuilder.build do
-    # @param event_type [Array<String, Class{EvilEvents::Core::Events::AbstractEvent}, Regexp>]
-    # @param delegator [String, Symbol, NilClass]
+    # @param event_types [Array<String, Class{EvilEvents::Core::Events::AbstractEvent}, Regexp>]
+    # @option delegator [String, Symbol, NilClass]
     # @raise [EvilEvents::ArgumentError]
+    # @return [void]
     #
     # @since 0.2.0
     def subscribe_to(*event_types, delegator: nil)
       raise EvilEvents::ArgumentError unless event_types.all? do |event_type|
-        event_type.is_a?(Class) ||
+        event_type.is_a?(Class)  ||
         event_type.is_a?(String) ||
         event_type.is_a?(Regexp) ||
         event_type.is_a?(Proc)
@@ -28,5 +31,25 @@ class EvilEvents::Core::Events::Subscriber
         end
       end
     end
+
+    # @param event_scopes [Array<String>]
+    # @option delegator [String,Symbol,NilClass]
+    # @raise [EvilEvents::ArgumentError]
+    # @return [void]
+    #
+    # @api public
+    # @since 0.4.0
+    def subscribe_to_scope(*event_scopes, delegator: nil)
+      raise EvilEvents::ArgumentError unless event_scopes.all? do |event_scope|
+        event_scope.is_a?(String)
+      end
+
+      event_system = EvilEvents::Core::Bootstrap[:event_system]
+
+      event_scopes.each do |event_scope|
+        event_system.scoped_observe(event_scope, self, delegator)
+      end
+    end
   end
+  # rubocop:enable Metrics/BlockLength
 end

data/lib/evil_events/core/system.rb

@@ -17,6 +17,8 @@ module EvilEvents::Core
     include Mocking
 
     # @see EvilEvents::Core::System::Broadcaster
+    #
+    # @api private
     # @since 0.1.0
     def_delegators :broadcaster,
                    :emit,
@@ -27,12 +29,15 @@ module EvilEvents::Core
                    :restart_event_notifier
 
     # @see EvilEvents::Core::System::EventManager
+    #
+    # @api private
     # @since 0.1.0
     def_delegators :event_manager,
                    :observe,
                    :raw_observe,
                    :observe_list,
                    :conditional_observe,
+                   :scoped_observe,
                    :observers,
                    :register_event_class,
                    :unregister_event_class,
@@ -44,14 +49,24 @@ module EvilEvents::Core
                    :managed_event?
 
     # @see EvilEvents::Core::System::EventBuilder
+    #
+    # @api private
     # @since 0.1.0
-    def_delegators 'EvilEvents::Core::System::EventBuilder',
+    def_delegators :event_builder,
                    :define_event_class,
                    :define_abstract_event_class,
                    :deserialize_from_json,
-                   :deserialize_from_hash
+                   :deserialize_from_hash,
+                   :deserialize_from_xml,
+                   :deserialize_from_msgpack,
+                   :serialize_to_json,
+                   :serialize_to_hash,
+                   :serialize_to_msgpack,
+                   :serialize_to_xml
 
     # @see EvilEvents::Core::System::TypeManager
+    #
+    # @api private
     # @since 0.2.0
     def_delegators :type_manager,
                    :register_converter,
@@ -59,21 +74,32 @@ module EvilEvents::Core
 
     # @return [EvilEvents::Core::System::Broadcaster]
     #
+    # @api private
     # @since 0.1.0
     attr_reader :broadcaster
 
     # @return [EvilEvents::Core::System::EventManager]
     #
+    # @api private
     # @since 0.1.0
     attr_reader :event_manager
 
     # @return [EvilEvents::Core::System::TypeManager]
     #
+    # @api private
     # @since 0.2.0
     attr_reader :type_manager
 
+    # @return [EvilEvents::Core::System::EventBuilder]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :event_builder
+
+    # @api private
     # @since 0.1.0
     def initialize
+      @event_builder = EventBuilder.new
       @broadcaster   = Broadcaster.new
       @event_manager = EventManager.new
       @type_manager  = TypeManager.new

data/lib/evil_events/core/system/broadcaster.rb

@@ -29,20 +29,26 @@ class EvilEvents::Core::System
     end
 
     # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @option adapter [Symbol,NilClass]
     # @return void
     #
     # @since 0.1.0
-    def emit(event)
-      event_emitter.emit(event)
+    def emit(event, adapter: nil)
+      event_emitter.emit(event, adapter: adapter)
     end
 
     # @param event_type [String]
-    # @param event_attributes [Hash]
+    # @option id [NilClass,String]
+    # @option payload [Hash]
+    # @option metadata [Hash]
+    # @option adapter [Symbol,NilClass]
     # @return void
     #
     # @since 0.1.0
-    def raw_emit(event_type, **event_attributes)
-      event_emitter.raw_emit(event_type, **event_attributes)
+    def raw_emit(event_type, id: nil, payload: {}, metadata: {}, adapter: nil)
+      event_emitter.raw_emit(
+        event_type, id: id, payload: payload, metadata: metadata, adapter: adapter
+      )
     end
 
     # @param adapter_name [Symbol, String]

data/lib/evil_events/core/system/event_builder.rb

@@ -3,40 +3,104 @@
 class EvilEvents::Core::System
   # @api private
   # @since 0.1.0
-  module EventBuilder
-    class << self
-      # @param event_type [String]
-      # @param event_class_definitions [Proc]
-      # @return [Class{EvilEvents::Core::Events::AbstractEvent}]
-      #
-      # @since 0.1.0
-      def define_event_class(event_type, &event_class_definitions)
-        EvilEvents::Core::Events::EventFactory.create_class(event_type, &event_class_definitions)
-      end
-
-      # @param event_type [String]
-      # @return [Class{EvilEvents::Core::Events::AbstractEvent}]
-      #
-      # @since 0.1.0
-      def define_abstract_event_class(event_type)
-        EvilEvents::Core::Events::EventFactory.create_abstract_class(event_type)
-      end
-
-      # @param serialized_event [String]
-      # @return [EvilEvents::Core::Events::AbstractEvent]
-      #
-      # @since 0.1.0
-      def deserialize_from_json(serialized_event)
-        EvilEvents::Core::Events::Serializers[:json].deserialize(serialized_event)
-      end
-
-      # @param serialized_event [Hash]
-      # @return [EvilEvents::Core::Events::AbstractEvent]
-      #
-      # @since 0.1.0
-      def deserialize_from_hash(serialized_event)
-        EvilEvents::Core::Events::Serializers[:hash].deserialize(serialized_event)
-      end
+  class EventBuilder
+    # @return [EvilEvents::Core::Events::Serializers]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :serializers_container
+
+    # @api private
+    # @since 0.4.0
+    def initialize
+      @serializers_container = EvilEvents::Core::Events::Serializers.new
+
+      @serializers_container.register_core_serializers!
+    end
+
+    # @param event_type [String]
+    # @param event_class_definitions [Proc]
+    # @return [Class{EvilEvents::Core::Events::AbstractEvent}]
+    #
+    # @since 0.1.0
+    def define_event_class(event_type, &event_class_definitions)
+      EvilEvents::Core::Events::EventFactory.create_class(event_type, &event_class_definitions)
+    end
+
+    # @param event_type [String]
+    # @return [Class{EvilEvents::Core::Events::AbstractEvent}]
+    #
+    # @since 0.1.0
+    def define_abstract_event_class(event_type)
+      EvilEvents::Core::Events::EventFactory.create_abstract_class(event_type)
+    end
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return [::Hash]
+    #
+    # @api private
+    # @since 0.4.0
+    def serialize_to_hash(event)
+      serializers_container.resolve(:hash).serialize(event)
+    end
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return [::String]
+    #
+    # @api private
+    # @since 0.4.0
+    def serialize_to_json(event)
+      serializers_container.resolve(:json).serialize(event)
+    end
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return [::String]
+    #
+    # @api private
+    # @since 0.4.0
+    def serialize_to_xml(event)
+      serializers_container.resolve(:xml).serialize(event)
+    end
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return [::String]
+    #
+    # @api private
+    # @since 0.4.0
+    def serialize_to_msgpack(event)
+      serializers_container.resolve(:msgpack).serialize(event)
+    end
+
+    # @param serialized_event [String]
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @since 0.1.0
+    def deserialize_from_json(serialized_event)
+      serializers_container.resolve(:json).deserialize(serialized_event)
+    end
+
+    # @param serialized_event [Hash]
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @since 0.1.0
+    def deserialize_from_hash(serialized_event)
+      serializers_container.resolve(:hash).deserialize(serialized_event)
+    end
+
+    # @param serialized_event [String]
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @since 0.4.0
+    def deserialize_from_xml(serialized_event)
+      serializers_container.resolve(:xml).deserialize(serialized_event)
+    end
+
+    # @param serialized_event [String]
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @since 0.4.0
+    def deserialize_from_msgpack(serialized_event)
+      serializers_container.resolve(:msgpack).deserialize(serialized_event)
     end
   end
 end