evil_events 0.1.1 → 0.2.0

data/lib/evil_events/core/events/event_extensions/class_signature/signature.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions::ClassSignature
+  # @api private
+  # @since 0.2.0
+  class Signature
+    # @return [Class{EvilEvents::Core::Events::AbstractEvent}]
+    #
+    # @since 0.2.0
+    attr_reader :event_class
+
+    # @param event_calass [Class{EvilEvents::Core::Events::AbstractEvent}]
+    #
+    # @since 0.2.0
+    def initialize(event_class)
+      @event_class = event_class
+    end
+
+    # @return [Hash]
+    #
+    # @since 0.2.0
+    def payload_stamp
+      event_class::Payload.schema
+    end
+
+    # @return [Hash]
+    #
+    # @since 0.2.0
+    def metadata_stamp
+      event_class::Metadata.schema
+    end
+
+    # @return [Hash]
+    #
+    # @since 0.2.0
+    def class_stamp
+      { name: event_class.name, creation_strategy: event_class.__creation_strategy }
+    end
+
+    # @return [String]
+    #
+    # @since 0.2.0
+    def type_alias_stamp
+      event_class.type
+    end
+
+    # @return [Symbol,String]
+    #
+    # @since 0.2.0
+    def delegator_stamp
+      event_class.default_delegator
+    end
+
+    # @return [Hash]
+    #
+    # @since 0.2.0
+    def adapter_stamp
+      { event_class.adapter_name => event_class.adapter }
+    end
+
+    # @param other [Signature]
+    # @return [Boolean]
+    #
+    # @since 0.2.0
+    def ==(other)
+      Equalizer.new(self, other).similar_signatures?
+    end
+    alias_method :eql?, :==
+  end
+end

data/lib/evil_events/core/events/event_extensions/metadata_extendable.rb

@@ -19,7 +19,7 @@ module EvilEvents::Core::Events::EventExtensions
     #
     # @since 0.1.0
     def build_metadata(**metadata_attributes)
-      self.class.const_get(:Metadata).new(**metadata_attributes)
+      self.class.metadata_class.new(**metadata_attributes)
     end
 
     # @since 0.1.0
@@ -32,20 +32,32 @@ module EvilEvents::Core::Events::EventExtensions
         super
       end
 
+      # @return [Class{AbstractMetadata}]
+      #
+      # @since 0.2.0
+      def metadata_class
+        const_get(:Metadata)
+      end
+
       # @param key [Symbol]
       # @param type [EvilEvents::Shared::Types::Any]
+      # @param options [Hash]
       # @return void
       #
       # @since 0.1.0
-      def metadata(key, type = EvilEvents::Types::Any)
-        const_get(:Metadata).attribute(key, type)
+      def metadata(key, type = EvilEvents::Types::Any, **options)
+        if type.is_a?(Symbol)
+          type = EvilEvents::Core::Bootstrap[:event_system].resolve_type(type, **options)
+        end
+
+        metadata_class.attribute(key, type)
       end
 
       # @return [Array<Symbol>]
       #
       # @since 0.1.0
       def metadata_fields
-        const_get(:Metadata).attribute_names
+        metadata_class.attribute_names
       end
     end
   end

data/lib/evil_events/core/events/event_extensions/payloadable.rb

@@ -19,7 +19,7 @@ module EvilEvents::Core::Events::EventExtensions
     #
     # @since 0.1.0
     def build_payload(**payload_attributes)
-      self.class.const_get(:Payload).new(**payload_attributes)
+      self.class.payload_class.new(**payload_attributes)
     end
 
     # @since 0.1.0
@@ -32,20 +32,32 @@ module EvilEvents::Core::Events::EventExtensions
         super
       end
 
+      # @return [Class{AbstractPayload}]
+      #
+      # @since 0.2.0
+      def payload_class
+        const_get(:Payload)
+      end
+
       # @param key [Symbol]
       # @param type [EvilEvents::Shared::Types::Any]
+      # @param options [Hash]
       # @return void
       #
       # @since 0.1.0
-      def payload(key, type = EvilEvents::Types::Any)
-        const_get(:Payload).attribute(key, type)
+      def payload(key, type = EvilEvents::Types::Any, **options)
+        if type.is_a?(Symbol)
+          type = EvilEvents::Core::Bootstrap[:event_system].resolve_type(type, **options)
+        end
+
+        payload_class.attribute(key, type)
       end
 
       # @return [Array<Symbol>]
       #
       # @since 0.1.0
       def payload_fields
-        const_get(:Payload).attribute_names
+        payload_class.attribute_names
       end
     end
   end

data/lib/evil_events/core/events/event_extensions/type_aliasing.rb

@@ -5,7 +5,7 @@ module EvilEvents::Core::Events::EventExtensions
   # @since 0.1.0
   module TypeAliasing
     # @since 0.1.0
-    TypeAliasingError = Class.new(StandardError)
+    TypeAliasingError = Class.new(EvilEvents::Core::Error)
     # @since 0.1.0
     IncopatibleEventTypeError = Class.new(TypeAliasingError)
     # @since 0.1.0

data/lib/evil_events/core/events/event_factory.rb

@@ -5,7 +5,9 @@ module EvilEvents::Core::Events
   # @since 0.1.1
   module EventFactory
     # @since 0.1.1
-    UNDEFINED_EVENT_ID = 'unknown'
+    UNDEFINED_EVENT_ID         = 'unknown'
+    CLASS_INHERITANCE_STRATEGY = :class_inheritance
+    PROC_EVAL_STRATEGY         = :proc_eval
 
     module_function
 
@@ -17,10 +19,12 @@ module EvilEvents::Core::Events
     def create_abstract_class(event_type)
       Class.new(AbstractEvent).tap do |klass|
         klass.type(event_type)
+        klass.__creation_strategy = CLASS_INHERITANCE_STRATEGY
 
         class << klass
           def inherited(child_class)
             child_class.type(type)
+            child_class.__creation_strategy = CLASS_INHERITANCE_STRATEGY
             child_class.manage!
           rescue EvilEvents::Core::Events::ManagerRegistry::AlreadyManagedEventClassError
             EvilEvents::Core::Bootstrap[:event_system].unregister_event_class(child_class)
@@ -40,10 +44,11 @@ module EvilEvents::Core::Events
     def create_class(event_type, &event_class_definitions)
       Class.new(AbstractEvent).tap do |klass|
         begin
+          klass.__creation_strategy = PROC_EVAL_STRATEGY
           klass.type(event_type)
           klass.manage!
           klass.evaluate(&event_class_definitions) if block_given?
-        rescue EvilEvents::Core::Events::ManagerRegistry::AlreadyManagedEventClassError
+        rescue StandardError
           EvilEvents::Core::Bootstrap[:event_system].unregister_event_class(klass)
           raise
         end

data/lib/evil_events/core/events/manager.rb

@@ -5,7 +5,7 @@ module EvilEvents::Core::Events
   # @since 0.1.0
   class Manager
     # @since 0.1.0
-    ManagerError = Class.new(StandardError)
+    ManagerError = Class.new(EvilEvents::Core::Error)
     # @since 0.1.0
     InconsistentEventClassError = Class.new(ManagerError)
     # @since 0.1.0

data/lib/evil_events/core/events/manager/notifier.rb

@@ -5,7 +5,7 @@ class EvilEvents::Core::Events::Manager
   # @since 0.1.0
   module Notifier
     # @since 0.1.0
-    NotifierError = Class.new(StandardError)
+    NotifierError = Class.new(EvilEvents::Core::Error)
     # @since 0.1.0
     InconsistentEventClassError = Class.new(NotifierError)
 
@@ -14,6 +14,7 @@ class EvilEvents::Core::Events::Manager
       # @since 0.1.0
       extend Forwardable
 
+      # @since 0.1.0
       def_delegators :errors_stack, :<<, :empty?
 
       # @return [Concurrent::Array]

data/lib/evil_events/core/events/manager_factory.rb

@@ -5,7 +5,7 @@ module EvilEvents::Core::Events
   # @since 0.1.0
   module ManagerFactory
     # @since 0.1.0
-    ManagerFactoryError = Class.new(StandardError)
+    ManagerFactoryError = Class.new(EvilEvents::Core::Error)
     # @since 0.1.0
     IncorrectEventClassError = Class.new(ManagerFactoryError)
 

data/lib/evil_events/core/events/manager_registry.rb

@@ -8,7 +8,7 @@ module EvilEvents::Core::Events
     extend Forwardable
 
     # @since 0.1.0
-    ManagerRegistryError = Class.new(StandardError)
+    ManagerRegistryError = Class.new(EvilEvents::Core::Error)
     # @since 0.1.0
     IncorrectManagerObjectError = Class.new(ManagerRegistryError)
     # @since 0.1.0
@@ -16,6 +16,7 @@ module EvilEvents::Core::Events
     # @since 0.1.0
     AlreadyManagedEventClassError = Class.new(ManagerRegistryError)
 
+    # @since 0.1.0
     def_delegators :managers, :empty?, :size
 
     # @return [Concurrent::Map]
@@ -44,10 +45,37 @@ module EvilEvents::Core::Events
     #
     # @since 0.1.0
     def manager_of_event_type(event_type)
-      event_class = managed_events.find { |managed_event| managed_event.type == event_type }
+      event_class = managed_events.find do |managed_event|
+        managed_event.type == event_type
+      end
+
       manager_of_event(event_class)
     end
 
+    # @param event_pattern [Regexp]
+    # @return [Array<EvilEvents::Core::Events::Manager>]
+    #
+    # @since 0.2.0
+    def managers_of_event_pattern(event_pattern)
+      event_classes = managed_events.select do |managed_event|
+        managed_event.type.match(event_pattern)
+      end
+
+      event_classes.map { |event_class| manager_of_event(event_class) }
+    end
+
+    # @param event_condition [Proc]
+    # @return [Array<EvilEvents::Core::Event::Manager>]
+    #
+    # @since 0.2.0
+    def managers_of_event_condition(event_condition)
+      event_classes = managed_events.select do |managed_event|
+        !!event_condition.call(managed_event.type)
+      end
+
+      event_classes.map { |event_class| manager_of_event(event_class) }
+    end
+
     # @param manager [EvilEvents::Core::Events::Manager]
     # @raise [IncorrectManagerObjectError]
     # @raise [AlreadyManagedEventClassError]
@@ -105,6 +133,15 @@ module EvilEvents::Core::Events
       managers.key?(event_class)
     end
 
+    # @return [Hash]
+    #
+    # @since 0.2.0
+    def managed_events_map
+      managed_events.each_with_object({}) do |event, accumulator|
+        accumulator[event.type] = event
+      end
+    end
+
     private
 
     # @return [Array<EvilEvents::Core::Events::AbstractEvent>]

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

@@ -4,10 +4,11 @@ module EvilEvents::Core::Events
   # @api private
   # @since 0.1.0
   class Serializers
+    # @since 0.1.0
     extend EvilEvents::Shared::DependencyContainer::Mixin
 
     # @since 0.1.0
-    SerializersError = Class.new(StandardError)
+    SerializersError = Class.new(EvilEvents::Core::Error)
     # @since 0.1.0
     SerializationError = Class.new(SerializersError)
     # @since 0.1.0

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

@@ -4,19 +4,28 @@ class EvilEvents::Core::Events::Subscriber
   # @api public
   # @since 0.1.0
   Mixin = EvilEvents::Shared::ClonableModuleBuilder.build do
-    # @param event_type [String, Class{EvilEvents::Core::Events::AbstractEvent}]
+    # @param event_type [Array<String, Class{EvilEvents::Core::Events::AbstractEvent}, Regexp>]
     # @param delegator [String, Symbol, NilClass]
-    # @raise [IncompatibleEventAttrTypeError]
+    # @raise [EvilEvents::Core::ArgumentError]
     #
-    # @since 0.1.0
-    def subscribe_to(event_type, delegator: nil)
-      case event_type
-      when Class
-        EvilEvents::Core::Bootstrap[:event_system].observe(event_type, self, delegator)
-      when String
-        EvilEvents::Core::Bootstrap[:event_system].raw_observe(event_type, self, delegator)
-      else
-        raise ArgumentError
+    # @since 0.2.0
+    def subscribe_to(*event_types, delegator: nil)
+      raise EvilEvents::Core::ArgumentError unless event_types.all? do |event_type|
+        event_type.is_a?(Class) ||
+        event_type.is_a?(String) ||
+        event_type.is_a?(Regexp) ||
+        event_type.is_a?(Proc)
+      end
+
+      event_system = EvilEvents::Core::Bootstrap[:event_system]
+
+      event_types.each do |event_type|
+        case event_type
+        when Class  then event_system.observe(event_type, self, delegator)
+        when String then event_system.raw_observe(event_type, self, delegator)
+        when Regexp then event_system.observe_list(event_type, self, delegator)
+        when Proc   then event_system.conditional_observe(event_type, self, delegator)
+        end
       end
     end
   end

data/lib/evil_events/core/system.rb

@@ -9,6 +9,7 @@ module EvilEvents::Core
     require_relative 'system/broadcaster'
     require_relative 'system/event_builder'
     require_relative 'system/event_manager'
+    require_relative 'system/type_manager'
 
     # @since 0.1.0
     extend Forwardable
@@ -28,11 +29,14 @@ module EvilEvents::Core
     def_delegators :event_manager,
                    :observe,
                    :raw_observe,
+                   :observe_list,
+                   :conditional_observe,
                    :observers,
                    :register_event_class,
                    :unregister_event_class,
                    :manager_of_event,
                    :manager_of_event_type,
+                   :registered_events,
                    :resolve_event_class,
                    :resolve_event_object,
                    :managed_event?
@@ -45,6 +49,12 @@ module EvilEvents::Core
                    :deserialize_from_json,
                    :deserialize_from_hash
 
+    # @see EvilEvents::Core::System::TypeManager
+    # @since 0.2.0
+    def_delegators :type_manager,
+                   :register_converter,
+                   :resolve_type
+
     # @return [EvilEvents::Core::System::Broadcaster]
     #
     # @since 0.1.0
@@ -55,10 +65,16 @@ module EvilEvents::Core
     # @since 0.1.0
     attr_reader :event_manager
 
+    # @return [EvilEvents::Core::System::TypeManager]
+    #
+    # @since 0.2.0
+    attr_reader :type_manager
+
     # @since 0.1.0
     def initialize
       @broadcaster   = Broadcaster.new
       @event_manager = EventManager.new
+      @type_manager  = TypeManager.new
     end
   end
 end

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

@@ -14,7 +14,7 @@ class EvilEvents::Core::System
     end
 
     # @param event_class [Class{Evilevents::Core::Events::AbstractEvent}]
-    # @param raw_subscriber [Object]
+    # @param raw_subscriber [Mixed]
     # @param delegator [String, Symbol, NilClass]
     # @return void
     #
@@ -25,7 +25,7 @@ class EvilEvents::Core::System
     end
 
     # @param event_type [String, Symbol]
-    # @param raw_subscriber [Object]
+    # @param raw_subscriber [Mixed]
     # @param delegator [String, Symbol, NilClass]
     # @return void
     #
@@ -35,6 +35,28 @@ class EvilEvents::Core::System
                       .observe(raw_subscriber, delegator)
     end
 
+    # @param event_pattern [Regexp]
+    # @param raw_subscriber [Mixed]
+    # @param delegator [String, Symbol, NilClass]
+    # @return void
+    #
+    # @since 0.2.0
+    def observe_list(event_pattern, raw_subscriber, delegator)
+      manager_registry.managers_of_event_pattern(event_pattern)
+                      .each { |manager| manager.observe(raw_subscriber, delegator) }
+    end
+
+    # @param event_condition [Proc]
+    # @param raw_subscriber [Mixed]
+    # @param delegator [String, Symbol, NilClass]
+    # @return void
+    #
+    # @since 0.2.0
+    def conditional_observe(event_condition, raw_subscriber, delegator)
+      manager_registry.managers_of_event_condition(event_condition)
+                      .each { |manager| manager.observe(raw_subscriber, delegator) }
+    end
+
     # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
     # @return [Array<EvilEvents::Core::Events::Subscriber>]
     #
@@ -76,11 +98,12 @@ class EvilEvents::Core::System
     end
 
     # @param event_type [String]
+    # @option id [String,NilClass]
     # @option payload [Hash]
     # @option metadata [Hash]
     # @return [EvilEvents::Core::Events::AbstractEvent]
     #
-    # @since 0.1.0
+    # @since 0.1.1
     def resolve_event_object(event_type, id: nil, payload: {}, metadata: {})
       manager_of_event_type(event_type).event_class.new(
         id: id, payload: payload, metadata: metadata
@@ -95,6 +118,13 @@ class EvilEvents::Core::System
       manager_of_event_type(event_type).event_class
     end
 
+    # @return [Hash]
+    #
+    # @since 0.2.0
+    def registered_events
+      manager_registry.managed_events_map
+    end
+
     # @param event_class [EvilEvents::Core::Events::AbstractEvent]
     # @return [Boolean]
     #