evil_events 0.3.1 → 0.4.0

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

@@ -14,19 +14,17 @@ module EvilEvents::Core::Events
     # @since 0.1.0
     include EventExtensions::Observable
     # @since 0.1.0
-    include EventExtensions::AdapterCustomizable
-    # @since 0.1.0
     include EventExtensions::Serializable
     # @since 0.1.0
-    include EventExtensions::Emittable
-    # @since 0.1.0
     include EventExtensions::MetadataExtendable
     # @sicne 0.2.0
     include EventExtensions::ClassSignature
     # @since 0.3.0
     include EventExtensions::Hookable
-    # @since 0.1.0
-    extend EvilEvents::Shared::CombinedContext::Mixin
+    # @since 0.4.0
+    include EventExtensions::Dispatchable
+    # @since 0.4.0
+    extend Symbiont::Context
 
     # @return [String]
     #

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

@@ -17,6 +17,19 @@ module EvilEvents::Core::Events::EventExtensions
       end
     end
 
+    # @param another_event [Object]
+    # @return [Boolean]
+    #
+    # @since 0.4.0
+    def similar_to?(another_event)
+      id       == another_event.id &&
+      type     == another_event.type &&
+      payload  == another_event.payload &&
+      metadata == another_event.metadata
+    rescue NoMethodError
+      false
+    end
+
     # @since 0.2.0
     module ClassMethods
       # @return [Signature]

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

@@ -69,14 +69,12 @@ module EvilEvents::Core::Events::EventExtensions::ClassSignature
     #
     # @since 0.2.0
     def similar_signatures?
-      # rubocop:disable Layout/MultilineOperationIndentation
       equal_type_alias? &&
       equal_class?      &&
       equal_payload?    &&
       equal_metadata?   &&
       equal_delegator?  &&
       equal_adapter?
-      # rubocop:enable Layout/MultilineOperationIndentation
     end
   end
 end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions
+  # @api private
+  # @since 0.4.0
+  module Dispatchable
+    class << self
+      # @param base_class [Class{AbstractEvent}]
+      #
+      # @api private
+      # @since 0.4.0
+      def included(base_class)
+        base_class.extend(ClassMethods)
+      end
+    end
+
+    # @return [EvilEvents::Core::Broadcasting::Dispatcher::Mixin]
+    #
+    # @since 0.4.0
+    def adapter
+      self.class.adapter
+    end
+
+    # @return [EvilEvents::Core::Broadcasting::Dispatcher::Mixin]
+    #
+    # @since 0.4.0
+    def adapter_name
+      self.class.adapter_name
+    end
+
+    # @option adapter [Symbol,NilClass]
+    # @return [void]
+    #
+    # @api public
+    # @since 0.4.0
+    def emit!(adapter: nil)
+      EvilEvents::Core::Bootstrap[:event_system].emit(self, adapter: adapter)
+    end
+
+    # @since 0.4.0
+    module ClassMethods
+      # @param identifier [Symbol,String,NilClass]
+      # @return [EvilEvents::Core::Broadcasting::Dispatcher::Dispatchable]
+      #
+      # @since 0.4.0
+      def adapter(identifier = nil)
+        @adapter_identifier = identifier if identifier
+        EvilEvents::Core::Bootstrap[:event_system].resolve_adapter(adapter_name)
+      end
+
+      # @return [Symbol, String]
+      #
+      # @since 0.4.0
+      def adapter_name
+        @adapter_identifier || EvilEvents::Core::Bootstrap[:config].adapter.default
+      end
+
+      # @option id [NilClass,Object]
+      # @option payload [Hash]
+      # @option metadata [Hash]
+      # @option adapter [Symbol,NilClass]
+      # @return [void]
+      #
+      # @see EvilEvents::Core::Events::AbstractEvent#initialize
+      # @see EvilEvents::Core::Events::EventExtensions::Emittable#emit!
+      #
+      # @api public
+      # @since 0.4.0
+      def emit!(id: nil, payload: {}, metadata: {}, adapter: nil)
+        new(id: id, payload: payload, metadata: metadata).emit!(adapter: adapter)
+      end
+    end
+  end
+end

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

@@ -19,6 +19,7 @@ module EvilEvents::Core::Events::EventExtensions
     def observers
       self.class.observers
     end
+    alias_method :subscribers, :observers
 
     # @since 0.1.0
     module ClassMethods
@@ -44,6 +45,7 @@ module EvilEvents::Core::Events::EventExtensions
       def observers
         EvilEvents::Core::Bootstrap[:event_system].observers(self)
       end
+      alias_method :subscribers, :observers
     end
   end
 end

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

@@ -6,18 +6,38 @@ module EvilEvents::Core::Events::EventExtensions
   module Serializable
     # @return [Hash]
     #
+    # @api private
     # @since 0.1.0
     def serialize_to_hash
-      EvilEvents::Core::Events::Serializers[:hash].serialize(self)
+      EvilEvents::Core::Bootstrap[:event_system].serialize_to_hash(self)
     end
     alias_method :dump_to_hash, :serialize_to_hash
 
     # @return [String]
     #
+    # @api private
     # @since 0.1.0
     def serialize_to_json
-      EvilEvents::Core::Events::Serializers[:json].serialize(self)
+      EvilEvents::Core::Bootstrap[:event_system].serialize_to_json(self)
     end
     alias_method :dump_to_json, :serialize_to_json
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    def serialize_to_xml
+      EvilEvents::Core::Bootstrap[:event_system].serialize_to_xml(self)
+    end
+    alias_method :dump_to_xml, :serialize_to_xml
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    def serialize_to_msgpack
+      EvilEvents::Core::Bootstrap[:event_system].serialize_to_msgpack(self)
+    end
+    alias_method :dump_to_msgpack, :serialize_to_msgpack
   end
 end

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

@@ -39,7 +39,7 @@ module EvilEvents::Core::Events
 
     # @param event [EvilEvents::Core::Events::AbstractEvent]
     # @raise [EvilEvents::InconsistentEventClassError]
-    # @raise [EvilEvents::FailedNotifiedSubscribersError]
+    # @raise [EvilEvents::FailingSubscribersError]
     #
     # @return void
     #

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

@@ -43,6 +43,22 @@ module EvilEvents::Core::Events
       manager_of_event(event_class)
     end
 
+    # @param scoped_event_type [String]
+    # @raise [EvilEvents::NonManagedEventClassError]
+    # @return [Array<EvilEvents::Core::Events::Manager>]
+    #
+    # @api private
+    # @since 0.4.0
+    def managers_of_scoped_event_type(scoped_event_type)
+      scope_matcher = ScopedEventTypeMatcher.new(scoped_event_type)
+
+      event_classes = managed_events.select do |managed_event|
+        scope_matcher.match?(managed_event.type)
+      end
+
+      event_classes.map { |event_class| manager_of_event(event_class) }
+    end
+
     # @param event_pattern [Regexp]
     # @return [Array<EvilEvents::Core::Events::Manager>]
     #

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::ManagerRegistry
+  # @api private
+  # @since 0.4.0
+  class ScopedEventTypeMatcher
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    EVENT_SCOPE_SPLITTER = '.'
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    MATCHER_SCOPE_SPLITTER = '\.'
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    GENERIC_PART_PATTERN = '*'
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    GENERIC_REGEXP_PATTERN = '[^\.]+\.'
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    INFINITE_PART_PATTERN = '#'
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    INFINITE_REGEXP_PATTERN = '\.*.*'
+
+    # @param scope_pattern [String]
+    # @raise [EvilEvents::ArgimentError]
+    #
+    # @api private
+    # @since 0.4.0
+    def initialize(scope_pattern)
+      raise EvilEvents::ArgumentError unless scope_pattern.is_a?(String)
+
+      @scope_pattern      = scope_pattern
+      @scope_pattern_size = count_scope_pattern_size(scope_pattern)
+      @pattern_matcher    = build_pattern_matcher(scope_pattern)
+    end
+
+    # @param event_type [String]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.4.0
+    def match?(event_type)
+      return false unless comparable_event_scopes?(event_type)
+      !!pattern_matcher.match(event_type)
+    end
+
+    private
+
+    # @return [Regexp]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :pattern_matcher
+
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :scope_pattern
+
+    # @return [Integer,Float::INFINITY]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :scope_pattern_size
+
+    # @param scope_pattern [String]
+    # @return [Integer,Float::INFINITY]
+    #
+    # @api private
+    # @since 0.4.0
+    def count_scope_pattern_size(scope_pattern)
+      return Float::INFINITY if scope_pattern == INFINITE_PART_PATTERN
+      return Float::INFINITY if scope_pattern.include?('.#')
+      return Float::INFINITY if scope_pattern.include?('#.')
+      return Float::INFINITY if scope_pattern.include?('.#.')
+
+      scope_pattern.split(EVENT_SCOPE_SPLITTER).size
+    end
+
+    # @param event_type [String]
+    # @return [Integer]
+    #
+    # @api private
+    # @since 0.4.0
+    def count_event_type_size(event_type)
+      event_type.split(EVENT_SCOPE_SPLITTER).size
+    end
+
+    # @param event_type [String]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.4.0
+    def comparable_event_scopes?(event_type)
+      # NOTE: Integer#finite?, Integer#infinite?, Float#finite?, Float#nfinite?
+      #   Cant be used (backward compatability with old ruby versions)
+      return true if scope_pattern_size == Float::INFINITY
+      scope_pattern_size == count_event_type_size(event_type)
+    end
+
+    # @param pattern [String,NilClass]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.4.0
+    def non_generic_pattern?(pattern = nil)
+      return false unless pattern
+      pattern != GENERIC_REGEXP_PATTERN && pattern != INFINITE_REGEXP_PATTERN
+    end
+
+    # "\.test\.created\.today\." => "test\.created\.today"
+    #
+    # @param regexp_string [String]
+    # @option left [Boolean]
+    # @option right [Boolean]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.4.0
+    def strip_regexp_string(regexp_string, left: false, right: false)
+      pattern = regexp_string
+      pattern = pattern[2..-1] if left && pattern[0..1] == MATCHER_SCOPE_SPLITTER
+      pattern = pattern[0..-3] if right && pattern[-2..-1] == MATCHER_SCOPE_SPLITTER
+      pattern
+    end
+
+    # @param scope_pattern [String]
+    # @return [Regexp]
+    #
+    # @api private
+    # @since 0.4.0
+    # rubocop:disable Metrics/AbcSize
+    def build_pattern_matcher(scope_pattern)
+      routing_parts = scope_pattern.split(EVENT_SCOPE_SPLITTER)
+
+      regexp_string = routing_parts.each_with_object([]) do |routing_part, regexp_parts|
+        case routing_part
+        when GENERIC_PART_PATTERN
+          regexp_parts << GENERIC_REGEXP_PATTERN
+        when INFINITE_PART_PATTERN
+          if non_generic_pattern?(regexp_parts.last)
+            regexp_parts[-1] = strip_regexp_string(regexp_parts.last, right: true)
+          end
+
+          regexp_parts << INFINITE_REGEXP_PATTERN
+        else
+          regexp_parts << (Regexp.escape(routing_part) + MATCHER_SCOPE_SPLITTER)
+        end
+      end.join
+
+      regexp_string = strip_regexp_string(regexp_string, left: true, right: true)
+
+      Regexp.new('\A' + regexp_string + '\z')
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

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

@@ -9,13 +9,13 @@ module EvilEvents::Core::Events::Notifier
 
     # @param manager [EvilEvents::Core::Events::Manager]
     # @param event [EvilEvents::Core::Events::AbstractEvent]
-    # @raise [EvilEvents::FailedNotifiedSubscribersError]
+    # @raise [EvilEvents::FailingSubscribersError]
     # @return void
     #
     # @api private
     # @since 0.3.0
     def notify(manager, event)
-      errors_stack = EvilEvents::FailedNotifiedSubscribersError.new
+      errors_stack = EvilEvents::FailingSubscribersError.new
 
       event.__call_before_hooks__
 

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

@@ -4,7 +4,18 @@ module EvilEvents::Core::Events
   # @api private
   # @since 0.1.0
   class Serializers
-    # @since 0.1.0
-    extend EvilEvents::Shared::DependencyContainer::Mixin
+    # @since 0.4.0
+    include EvilEvents::Shared::DependencyContainer::Mixin
+
+    # @return void
+    #
+    # @api private
+    # @since 0.4.0
+    def register_core_serializers!
+      register(:json, memoize: true)    { JSON::Factory.new.create! }
+      register(:hash, memoize: true)    { Hash::Factory.new.create! }
+      register(:msgpack, memoize: true) { MessagePack::Factory.new.create! }
+      register(:xml, memoize: true)     { XML::Factory.new.create! }
+    end
   end
 end

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

@@ -2,21 +2,64 @@
 
 class EvilEvents::Core::Events::Serializers
   # @api private
-  # @since 0.1.1
-  module Base
-    # @option type [String]
-    # @option id [String, Object]
-    # @option payload [Hash]
-    # @option metadata [Hash]
-    # @return [EvilEvents::Core::Events::AbstractEvent]
+  # @since 0.4.0
+  class Base
+    # @param engine [Engines::Abstract]
+    # @param config [GenericConfig]
+    # @param packer [DataTransformer]
+    # @param unpacker [DataTransformer]
+    #
+    # @api private
+    # @since 0.4.0
+    def initialize(engine, config, packer, unpacker)
+      @engine   = engine
+      @config   = config
+      @packer   = packer
+      @unpacker = unpacker
+    end
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return [Object]
     #
-    # @since 0.1.1
-    def restore_event_instance(type:, id:, payload:, metadata:)
-      event_class = EvilEvents::Core::Bootstrap[:event_system].resolve_event_class(type)
+    # @api private
+    # @since 0.4.0
+    def serialize(event)
+      packer.call(event)
+    end
 
-      EvilEvents::Core::Events::EventFactory.restore_instance(
-        event_class, id: id, payload: payload, metadata: metadata
-      )
+    # @param data [Object]
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @api private
+    # @since 0.4.0
+    def deserialize(data)
+      unpacker.call(data)
     end
+
+    private
+
+    # @return [DataTransformer]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :packer
+
+    # @return [DataTransformer]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :unpacker
+
+    # @return [Engines::Abstract]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :engine
+
+    # @return [GenericConfig]
+    #
+    # @api private
+    # @since 0.4.0
+    attr_reader :config
   end
 end