evil_events 0.1.0rc1

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions
+  # @api private
+  # @since 0.1.0
+  module AdapterCustomizable
+    class << self
+      # @param base_class [Class]
+      #
+      # @since 0.1.0
+      def included(base_class)
+        base_class.extend(ClassMethods)
+      end
+    end
+
+    # @return [EvilEvents::Core::Broadcasting::Dispatcher::Dispatchable]
+    #
+    # @since 0.1.0
+    def adapter
+      self.class.adapter
+    end
+
+    # @return [EvilEvents::Core::Broadcasting::Dispatcher::Dispatchable]
+    #
+    # @since 0.1.0
+    def adapter_name
+      self.class.adapter_name
+    end
+
+    # @since 0.1.0
+    module ClassMethods
+      # @param identifier [Symbol, String]
+      # @return [EvilEvents::Core::Broadcasting::Dispatcher::Dispatchable]
+      #
+      # @since 0.1.0
+      def adapter(identifier = nil)
+        @adapter_identifier = identifier if identifier
+        EvilEvents::BootPoint::System[:event_system].resolve_adapter(adapter_name)
+      end
+
+      # @return [Symbol, String]
+      #
+      # @since 0.1.0
+      def adapter_name
+        @adapter_identifier || EvilEvents::BootPoint::System[:config].adapter.default
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions
+  # @api private
+  # @since 0.1.0
+  module Manageable
+    class << self
+      # @param base_class [Class]
+      #
+      # @since 0.1.0
+      def included(base_class)
+        base_class.extend(ClassMethods)
+      end
+    end
+
+    # @since 0.1.0
+    module ClassMethods
+      # @return void
+      #
+      # @since 0.1.0
+      def manage!
+        EvilEvents::BootPoint::System[:event_system].register_event_class(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions
+  # @api private
+  # @since 0.1.0
+  module Observable
+    class << self
+      # @param base_class [Class]
+      #
+      # @since 0.1.0
+      def included(base_class)
+        base_class.extend(ClassMethods)
+      end
+    end
+
+    # @return [Array<EvilEvents::Core::Events::Subscriber>]
+    #
+    # @since 0.1.0
+    def observers
+      self.class.observers
+    end
+
+    # @since 0.1.0
+    module ClassMethods
+      # @param raw_subscriber [Object]
+      # @param delegator [Symbol, String, NilClass]
+      #
+      # @since 0.1.0
+      def observe(raw_subscriber, delegator: nil)
+        EvilEvents::BootPoint::System[:event_system].observe(self, raw_subscriber, delegator)
+      end
+
+      # @param delegator [Symbol, String, NilClass]
+      #
+      # @since 0.1.0
+      def default_delegator(delegator = nil)
+        @default_delegator = delegator if delegator
+        @default_delegator || EvilEvents::BootPoint::System[:config].subscriber.default_delegator
+      end
+
+      # @return [Array]
+      #
+      # @since 0.1.0
+      def observers
+        EvilEvents::BootPoint::System[:event_system].observers(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions::Payloadable
+  # @abstract
+  # @api private
+  # @since 0.1.0
+  class AbstractPayload < EvilEvents::Shared::Structure
+    class << self
+      # @since 0.1.0
+      alias_method :_native_attribute, :attribute
+
+      # @param key [Symbol]
+      # @param type [EvilEvents::Shared::Types::Any]
+      #
+      # @since 0.1.0
+      def attribute(key, type = EvilEvents::Types::Any)
+        _native_attribute(key, type)
+      end
+    end
+
+    # NOTE: dry-struct API + dry-initializer API
+    constructor_type :strict_with_defaults
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions
+  # @api private
+  # @since 0.1.0
+  module Payloadable
+    class << self
+      # @param base_class [Class]
+      #
+      # @since 0.1.0
+      def included(base_class)
+        base_class.extend(ClassMethods)
+      end
+    end
+
+    private
+
+    # @return [AbstractPayload]
+    #
+    # @since 0.1.0
+    def payload_class
+      self.class.const_get(:Payload)
+    end
+
+    # @since 0.1.0
+    module ClassMethods
+      # @param child_class [Class]
+      #
+      # @since 0.1.0
+      def inherited(child_class)
+        child_class.const_set(:Payload, Class.new(AbstractPayload))
+        super
+      end
+
+      # @param key [Symbol]
+      # @param type [EvilEvents::Shared::Types::Any]
+      # @return void
+      #
+      # @since 0.1.0
+      def attribute(key, type = EvilEvents::Shared::Types::Any)
+        const_get(:Payload).attribute(key, type)
+      end
+
+      # @return [Array<Symbol>]
+      #
+      # @since 0.1.0
+      def attribute_names
+        const_get(:Payload).attribute_names
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions
+  # @api private
+  # @since 0.1.0
+  module Serializable
+    # @return [Hash]
+    #
+    # @since 0.1.0
+    def serialize_to_hash
+      EvilEvents::Core::Events::Serializers[:hash].serialize(self)
+    end
+
+    # @return [String]
+    #
+    # @since 0.1.0
+    def serialize_to_json
+      EvilEvents::Core::Events::Serializers[:json].serialize(self)
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::EventExtensions
+  # @api private
+  # @since 0.1.0
+  module TypeAliasing
+    # @since 0.1.0
+    TypeAliasingError = Class.new(StandardError)
+    # @since 0.1.0
+    IncopatibleEventTypeError = Class.new(TypeAliasingError)
+    # @since 0.1.0
+    EventTypeNotDefinedError = Class.new(TypeAliasingError)
+    # @since 0.1.0
+    EventTypeAlreadyDefinedError = Class.new(TypeAliasingError)
+
+    class << self
+      # @param base_class [Class]
+      #
+      # @since 0.1.0
+      def included(base_class)
+        base_class.extend(ClassMethods)
+      end
+    end
+
+    # @return [String]
+    #
+    # @since 0.1.0
+    def type
+      self.class.type
+    end
+
+    module ClassMethods
+      # @param type_alias [String, NilClass]
+      # @return [String]
+      #
+      # @since 0.1.0
+      def type(type_alias = nil)
+        case
+        when incompatible_type_alias_type?(type_alias)
+          raise IncopatibleEventTypeError
+        when fetching_type_alias_when_type_alias_not_defined?(type_alias)
+          raise EventTypeNotDefinedError
+        when providing_type_alias_when_type_alias_already_defined?(type_alias)
+          raise EventTypeAlreadyDefinedError
+        when tries_to_define_type_alias_first_time?(type_alias)
+          @type = type_alias
+        end
+
+        @type
+      end
+
+      private
+
+      # @param type_alias [String, NilClass]
+      # @return [Boolean]
+      #
+      # @since 0.1.0
+      def incompatible_type_alias_type?(type_alias)
+        !(type_alias.is_a?(NilClass) || type_alias.is_a?(String))
+      end
+
+      # @param type_alias [String, NilClass]
+      # @return [Boolean]
+      #
+      # @since 0.1.0
+      def fetching_type_alias_when_type_alias_not_defined?(type_alias)
+        !instance_variable_defined?(:@type) && type_alias.nil?
+      end
+
+      # @param type_alias [String, NilClass]
+      # @return [Boolean]
+      #
+      # @since 0.1.0
+      def providing_type_alias_when_type_alias_already_defined?(type_alias)
+        instance_variable_defined?(:@type) && type_alias
+      end
+
+      # @param type_alias [String, NilClass]
+      # @return [Boolean]
+      #
+      # @since 0.1.0
+      def tries_to_define_type_alias_first_time?(type_alias)
+        !instance_variable_defined?(:@type) && type_alias
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Manager
+  # @api private
+  # @since 0.1.0
+  class SubscriberList < Concurrent::Array
+    # @param source_subscriber [Object]
+    # @return [Boolean]
+    #
+    # @since 0.1.0
+    def registered?(source_subscriber)
+      any? { |subscriber| subscriber.source_object == source_subscriber }
+    end
+
+    # @param source_subscriber [Object]
+    # @return [EvilEvents::Core::Events::Subscriber]
+    #
+    # @since 0.1.0
+    def wrapper_of(source_subscriber)
+      find { |subscriber| subscriber.source_object == source_subscriber }
+    end
+
+    # @return [Array<Object>]
+    #
+    # @since 0.1.0
+    def sources
+      map(&:source_object)
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events
+  # @api private
+  # @since 0.1.0
+  class Manager
+    # @since 0.1.0
+    ManagerError = Class.new(StandardError)
+    # @since 0.1.0
+    InconsistentEventClassError = Class.new(ManagerError)
+    # @since 0.1.0
+    InvalidDelegatorTypeError = Class.new(ManagerError)
+
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @since 0.1.0
+    attr_reader :event_class
+
+    # @return [Concurrent::Array<EvilEvents::Core::Events::Subscriber>]
+    #
+    # @since 0.1.0
+    attr_reader :subscribers
+
+    # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
+    #
+    # @since 0.1.0
+    def initialize(event_class)
+      @event_class = event_class
+      @subscribers = SubscriberList.new
+    end
+
+    # @param raw_subscriber [Object]
+    # @param delegator [Symbol, String, NilClass]
+    # @raise [InvalidDelegatorTypeError]
+    # @return void
+    #
+    # @since 0.1.0
+    def observe(raw_subscriber, delegator = nil)
+      case delegator
+      when NilClass, Symbol, String # TODO: think about Dry::Types checker
+        subscribers.push(create_event_subscriber(raw_subscriber, delegator))
+      else
+        raise InvalidDelegatorTypeError
+      end
+    end
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @raise [InconsistentEventClassError]
+    # @return void
+    #
+    # @since 0.1.0
+    def notify(event)
+      raise InconsistentEventClassError unless event.is_a?(event_class)
+      # TODO: separate notification logic to worker/jobs
+      subscribers.each { |subscriber| subscriber.notify(event) }
+    end
+
+    # @return [String, Symbol]
+    #
+    # @since 0.1.0
+    def event_type
+      event_class.type
+    end
+
+    private
+
+    # @param raw_subscriber [Object]
+    # @param delegator [Symbol, String, NilClass]
+    # @return [EvilEvents::Core::Events::Subscriber]
+    #
+    # @since 0.1.0
+    def create_event_subscriber(raw_subscriber, delegator)
+      delegation = -> { delegator || event_class.default_delegator }
+      resolver   = EvilEvents::Shared::DelegatorResolver.new(delegation)
+      EvilEvents::Core::Events::Subscriber.new(raw_subscriber, resolver)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events
+  # @api private
+  # @since 0.1.0
+  module ManagerFactory
+    class << self
+      # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
+      # @return [EvilEvents::Core::Events::Manager]
+      #
+      # @since 0.1.0
+      def create(event_class)
+        Manager.new(event_class)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events
+  # @api private
+  # @since 0.1.0
+  class ManagerRegistry
+    # @since 0.1.0
+    extend Forwardable
+
+    # @since 0.1.0
+    ManagerRegistryError = Class.new(StandardError)
+    # @since 0.1.0
+    IncorrectManagerObjectError = Class.new(ManagerRegistryError)
+    # @since 0.1.0
+    NonManagedEventClassError = Class.new(ManagerRegistryError)
+    # @since 0.1.0
+    AlreadyManagedEventClassError = Class.new(ManagerRegistryError)
+
+    def_delegators :managers, :empty?, :size
+
+    # @return [Concurrent::Map]
+    #
+    # @since 0.1.0
+    attr_reader :managers
+
+    # @since 0.1.0
+    def initialize
+      @managers = Concurrent::Map.new
+    end
+
+    # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
+    # @raise [NonManagedEventClassError]
+    # @return [EvilEvents::Core::Events::Manager]
+    #
+    # @since 0.1.0
+    def manager_of_event(event_class)
+      # NOTE: raise exceptions to simplify runtime problems resolving
+      managers[event_class] || (raise NonManagedEventClassError)
+    end
+
+    # @param event_type [String]
+    # @return [EvilEvents::Core::Events::Manager]
+    # @see manager_of_event
+    #
+    # @since 0.1.0
+    def manager_of_event_type(event_type)
+      event_class = managed_events.find { |managed_event| managed_event.type == event_type }
+      manager_of_event(event_class)
+    end
+
+    # @param manager [EvilEvents::Core::Events::Manager]
+    # @raise [IncorrectManagerObjectError]
+    # @raise [AlreadyManagedEventClassError]
+    # @return void
+    #
+    # @since 0.1.0
+    def register(manager)
+      raise IncorrectManagerObjectError unless manager.is_a?(EvilEvents::Core::Events::Manager)
+
+      if potential_manager_duplicate?(manager) || !managed_event_type?(manager.event_type)
+        managers[manager.event_class] = manager
+      else
+        raise AlreadyManagedEventClassError
+      end
+    end
+
+    # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
+    # @return void
+    # @see register
+    #
+    # @since 0.1.0
+    def register_with(event_class)
+      register(ManagerFactory.create(event_class))
+    end
+
+    # @param manager [EvilEvents::Core::Events::Manager]
+    # @return void
+    #
+    # @since 0.1.0
+    def unregister(manager)
+      managers.delete_pair(manager.event_class, manager)
+    end
+
+    # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
+    # @return void
+    #
+    # @since 0.1.0
+    def unregister_with(event_class)
+      managers.delete(event_class)
+    end
+
+    # @param manager [EvilEvents::Core::Events::Manager]
+    # @return [Boolean]
+    #
+    # @since 0.1.0
+    def include?(manager)
+      managed_event?(manager.event_class) && manager_of_event(manager.event_class) == manager
+    end
+
+    # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
+    # @return [Boolean]
+    #
+    # @since 0.1.0
+    def managed_event?(event_class)
+      managers.key?(event_class)
+    end
+
+    private
+
+    # @return [Array<EvilEvents::Core::Events::AbstractEvent>]
+    #
+    # @since 0.1.0
+    def managed_events
+      managers.keys
+    end
+
+    # @return [Array<String>]
+    #
+    # @since 0.1.0
+    def managed_event_types
+      managed_events.map(&:type)
+    end
+
+    # @param event_type [String]
+    # @return [Boolean]
+    #
+    # @since 0.1.0
+    def managed_event_type?(event_type)
+      managed_event_types.include?(event_type)
+    end
+
+    # @param manager [EvilEvents::Core::Events::Manager]
+    # @return [Boolean]
+    #
+    # @since 0.1.0
+    def potential_manager_duplicate?(manager)
+      return false unless managed_event?(manager.event_class)
+      manager_of_event(manager.event_class).event_type == manager.event_type
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  # @api public
+  # @since 0.1.0
+  module Hash
+    module_function
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @raise [SerializationError]
+    # @return [::Hash]
+    #
+    # @since 0.1.0
+    def serialize(event)
+      raise SerializationError unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
+
+      { type: event.type, payload: event.payload }
+    end
+
+    # @param hash [::Hash]
+    # @raise [DeserializationError]
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @since 0.1.0
+    def deserialize(hash)
+      raise DeserializationError unless hash.is_a?(::Hash)
+      event_type    = hash[:type]    || hash['type']
+      event_payload = hash[:payload] || hash['payload']
+      raise DeserializationError unless event_type && event_payload
+      raise DeserializationError unless event_payload.is_a?(::Hash)
+
+      EvilEvents::BootPoint::System[:event_system].resolve_event_object(
+        event_type, symbolized_event_payload(event_payload)
+      )
+    end
+
+    # @param payload_hash [::Hash]
+    # @return [::Hash]
+    #
+    # @since 0.1.0
+    def symbolized_event_payload(payload_hash)
+      payload_hash.each_pair.each_with_object({}) do |(key, value), result_hash|
+        result_hash[key.to_sym] = value
+      end
+    end
+    private_class_method :symbolized_event_payload
+  end
+
+  # @since 0.1.0
+  register(:hash) { Hash }
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Serializers
+  # @api public
+  # @since 0.1.0
+  module JSON
+    module_function
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @raise [SerializationError]
+    # @return [::Hash]
+    #
+    # @since 0.1.0
+    def serialize(event)
+      raise SerializationError unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
+
+      ::JSON.generate(type: event.type, payload: event.payload)
+    end
+
+    # @param json [String]
+    # @raise [DeserializationError]
+    # @return [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @since 0.1.0
+    def deserialize(json)
+      raise DeserializationError unless json.is_a?(String)
+
+      begin
+        json_hash     = ::JSON.parse(json, symbolize_names: true)
+        event_type    = json_hash[:type]
+        event_payload = json_hash[:payload]
+        raise DeserializationError unless event_type && event_payload
+      rescue ::JSON::ParserError
+        raise DeserializationError
+      end
+
+      EvilEvents::BootPoint::System[:event_system].resolve_event_object(event_type, event_payload)
+    end
+  end
+
+  # @since 0.1.0
+  register(:json) { JSON }
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events
+  # @api private
+  # @since 0.1.0
+  class Serializers
+    extend EvilEvents::Shared::DependencyContainer::Mixin
+
+    # @since 0.1.0
+    SerializersError = Class.new(StandardError)
+    # @since 0.1.0
+    SerializationError = Class.new(SerializersError)
+    # @since 0.1.0
+    DeserializationError = Class.new(SerializersError)
+  end
+end