evil_events 0.1.0rc1

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class EvilEvents::Core::Events::Subscriber
+  # @api public
+  # @since 0.1.0
+  module Mixin
+    # @since 0.1.0
+    SubscriberMixinError = Class.new(StandardError)
+    # @since 0.1.0
+    IncompatibleEventAttrTypeError = Class.new(SubscriberMixinError)
+
+    # @param event_type [String, Class{EvilEvents::Core::Events::AbstractEvent}]
+    # @param delegator [String, Symbol, NilClass]
+    # @raise [IncompatibleEventAttrTypeError]
+    #
+    # @since 0.1.0
+    def subscribe_to(event_type, delegator: nil)
+      case event_type
+      when Class
+        EvilEvents::BootPoint::System[:event_system].observe(event_type, self, delegator)
+      when String
+        EvilEvents::BootPoint::System[:event_system].raw_observe(event_type, self, delegator)
+      else
+        raise IncompatibleEventAttrTypeError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events
+  # @api private
+  # @since 0.1.0
+  class Subscriber
+    # @return [EvilEvents::Shared::DelegatorResolver]
+    #
+    # @since 0.1.0
+    attr_reader :delegator_resolver
+
+    # @param subscriber [Object]
+    # @param delegator_resolver [EvilEvents::Shared::DelegatorResolver]
+    #
+    # @since 0.1.0
+    def initialize(subscriber, delegator_resolver)
+      @subscriber = subscriber
+      @delegator_resolver = delegator_resolver
+    end
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return void
+    #
+    # @since 0.1.0
+    def notify(event)
+      source_object.public_send(delegator, event)
+    end
+
+    # @return [Object]
+    #
+    # @since 0.1.0
+    def source_object
+      @subscriber
+    end
+
+    # @return [String, Symbol]
+    #
+    # @since 0.1.0
+    def delegator
+      @delegator ||= delegator_resolver.delegator
+    end
+  end
+end

data/lib/evil_events/core/events.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core
+  # @since 0.1.0
+  module Events
+    require_relative 'events/serializers'
+    require_relative 'events/serializers/hash'
+    require_relative 'events/serializers/json'
+    require_relative 'events/event_extensions/type_aliasing'
+    require_relative 'events/event_extensions/payloadable'
+    require_relative 'events/event_extensions/payloadable/abstract_payload'
+    require_relative 'events/event_extensions/manageable'
+    require_relative 'events/event_extensions/adapter_customizable'
+    require_relative 'events/event_extensions/observable'
+    require_relative 'events/event_extensions/serializable'
+    require_relative 'events/abstract_event'
+    require_relative 'events/manager'
+    require_relative 'events/manager/subscriber_list'
+    require_relative 'events/manager_factory'
+    require_relative 'events/manager_registry'
+    require_relative 'events/subscriber'
+    require_relative 'events/subscriber/mixin'
+    require_relative 'events/event_class_factory'
+  end
+end

data/lib/evil_events/core.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module EvilEvents
+  # @since 0.1.0
+  module Core
+    require_relative 'core/activity_logging'
+    require_relative 'core/broadcasting'
+    require_relative 'core/events'
+  end
+end

data/lib/evil_events/shared/combined_context.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module EvilEvents
+  module Shared
+    # @example
+    #  class EventStorage
+    #    attr_reader :events
+    #
+    #    def initialize
+    #      @events = []
+    #    end
+    #
+    #    def store_event(event)
+    #      @events << event
+    #    end
+    #  end
+    #
+    #  storage = EventStorage.new
+    #  event   = 'test_event'
+    #  clojure = proc { store_event(event) }
+    #  context = EvilEvents::Shared::CombinedContext.new(storage, clojure)
+    #
+    #  storage.events # => []
+    #
+    #  context.evaluate
+    #  storage.events # => ['test_event']
+    #
+    #  context.evaluate
+    #  storage.events # => ['test_event', 'test_event']
+    #
+    # @since 0.1.0
+    # @api public
+    class CombinedContext < BasicObject
+      # @since 0.1.0
+      CombinedContextError = ::Class.new(::StandardError)
+      # @since 0.1.0
+      NonProcClojureObjectError = ::Class.new(CombinedContextError)
+
+      # @return [Object]
+      #
+      # @since 0.1.0
+      attr_reader :__required_context__
+
+      # @return [Object]
+      #
+      # @since 0.1.0
+      attr_reader :__outer_context__
+
+      # @return [Proc]
+      #
+      # @since 0.1.0
+      attr_reader :__clojure__
+
+      # @param required_context [Object]
+      # @param clojure [Proc]
+      #
+      # @since 0.1.0
+      def initialize(required_context, clojure)
+        ::Kernel.raise NonProcClojureObjectError unless clojure.is_a?(::Proc)
+
+        @__required_context__ = required_context
+        @__outer_context__    = ::Kernel.eval('self', clojure.binding)
+        @__clojure__          = clojure
+      end
+
+      # @return [Object]
+      #
+      # @see #method_missing
+      #
+      # @since 0.1.0
+      def evaluate
+        instance_eval(&__clojure__)
+      end
+
+      # @see #evaluate
+      #
+      # @since 0.1.0
+      def method_missing(method_name, *arguments, &block)
+        case
+        when __outer_context__.respond_to?(method_name)
+          __outer_context__.public_send(method_name, *arguments, &block)
+        when __required_context__.respond_to?(method_name)
+          __required_context__.public_send(method_name, *arguments, &block)
+        else
+          super
+        end
+      end
+
+      # @see #method_missing
+      #
+      # @since 0.1.0
+      def respond_to_missing?(method_name, include_private = false)
+        __outer_context__.respond_to?(method_name) ||
+          __required_context__.respond_to?(method_name) || super
+      end
+
+      # @see #method_missing
+      # @see #respond_to_missing?
+      #
+      # @since 0.1.0
+      def method(method_name)
+        case
+        when __outer_context__.respond_to?(method_name)
+          __outer_context__.method(method_name)
+        when __required_context__.respond_to?(method_name)
+          __required_context__.method(method_name)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evil_events/shared/combined_context_mixin.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EvilEvents
+  module Shared
+    # @example
+    #  require 'securerandom'
+    #
+    #  class Event
+    #    extend EvilEvents::Shared::CombinedContextMixin
+    #
+    #    class << self
+    #      def type(type = nil)
+    #        @type = type if type
+    #        @type
+    #       end
+    #    end
+    #  end
+    #
+    #  def get_uuid
+    #    SecureRandom.uuid
+    #  end
+    #
+    #  MyEvent = Event.evaluate do
+    #    type get_uuid # Event.type + binding#get_uuid => works good :)
+    #  end
+    #
+    # @see EvilEvents::Shared::CombinedContext
+    #
+    # @since 0.1.0
+    # @api public
+    module CombinedContextMixin
+      # @param clojure [Proc]
+      # @return [Object] Clojure evaluation result
+      #
+      # @see EvilEvents::Shared::CombinedContext#evaluate
+      #
+      # @since 0.1.0
+      def evaluate(&clojure)
+        CombinedContext.new(self, clojure).evaluate
+      end
+    end
+  end
+end

data/lib/evil_events/shared/configurable.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EvilEvents::Shared
+  # @api public
+  # @since 0.1.0
+  Configurable = Dry::Configurable
+end

data/lib/evil_events/shared/delegator_resolver.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module EvilEvents::Shared
+  # @example
+  #  DelegatorResolver.new(-> { 'test' }).delegator # => 'test'
+  #  DelegatorResolver.new('test') # => InvalidProcAttributeError
+  #
+  # @since 0.1.0
+  # @api public
+  class DelegatorResolver
+    # @since 0.1.0
+    DelegatorResolverError = Class.new(StandardError)
+    # @since 0.1.0
+    InvalidProcAttributeError = Class.new(DelegatorResolverError)
+
+    # @return [Proc]
+    #
+    # @since 0.1.0
+    attr_reader :method_name_resolver
+
+    # @param method_name_resolver [Proc]
+    #
+    # @since 0.1.0
+    def initialize(method_name_resolver)
+      raise InvalidProcAttributeError unless method_name_resolver.is_a?(Proc)
+      @method_name_resolver = method_name_resolver
+    end
+
+    # @return [String, Symbol]
+    #
+    # @since 0.1.0
+    def delegator
+      @delegator ||= method_name_resolver.call
+    end
+  end
+end

data/lib/evil_events/shared/dependency_container.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EvilEvents::Shared
+  # @api public
+  # @since 0.1.0
+  DependencyContainer = Dry::Container
+end

data/lib/evil_events/shared/logger.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EvilEvents::Shared
+  # @api public
+  # @since 0.1.0
+  class Logger < ::Logger
+    # @since 0.1.0
+    def initialize(*, **)
+      super
+      self.level = :info
+    end
+  end
+end

data/lib/evil_events/shared/mockable_class_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module EvilEvents::Shared
+  # @api public
+  # @since 0.1.0
+  module MockableClassBuilder
+    class << self
+      # @param class_definitions [Proc]
+      # @return [Class]
+      #
+      # @since 0.1.0
+      def new_class(&class_definitions)
+        Class.new.tap do |klass|
+          klass.class_eval(&class_definitions) if block_given?
+
+          klass.singleton_class.class_eval do
+            define_method :build_mock do
+              ::Class.new.tap do |mocking_class|
+                mocking_class.class_eval(&class_definitions)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/evil_events/shared/structure.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EvilEvents::Shared
+  # @api public
+  # @since 0.1.0
+  Structure = Dry::Struct
+end

data/lib/evil_events/shared/types.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EvilEvents::Shared
+  # @api public
+  # @since 0.1.0
+  module Types
+    include Dry::Types.module
+  end
+end

data/lib/evil_events/shared.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EvilEvents
+  # @since 0.1.0
+  module Shared
+    require_relative 'shared/mockable_class_builder'
+    require_relative 'shared/logger'
+    require_relative 'shared/configurable'
+    require_relative 'shared/dependency_container'
+    require_relative 'shared/structure'
+    require_relative 'shared/types'
+    require_relative 'shared/combined_context'
+    require_relative 'shared/combined_context_mixin'
+    require_relative 'shared/delegator_resolver'
+  end
+end

data/lib/evil_events/system/mock.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+class EvilEvents::System
+  # @see EvilEvents::System
+  # @api public
+  # @since 0.1.0
+  class Mock
+    # @see EvilEvents::System
+    # @since 0.1.0
+    attr_reader :event_emitter
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    attr_reader :manager_registry
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def observe(event_class, raw_subscriber, delegator); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def raw_observe(event_type, raw_subscriber, delegator); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def observers(event_class); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def emit(event); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def raw_emit(event_type, **event_attributes); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def resolve_adapter(adapter_name); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def register_event_class(event_class); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def unregister_event_class(event_class); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def manager_of(event); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def manager_of_event_type(event_type); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def resolve_event_object(event_type, **event_attributes); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def define_event_class(event_type, &event_class_definitions); end
+
+    # @see EvilEvents::System
+    # @since 0.1.0
+    def define_abstract_event_class(event_type); end
+  end
+end

data/lib/evil_events/system.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+class EvilEvents::System
+  class << self
+    # @return [EvilEvents::System::Mock]
+    #
+    # @since 0.1.0
+    def build_mock
+      Mock.new
+    end
+
+    # @return [EvilEvents::System]
+    #
+    # @since 0.1.0
+    def build_stub
+      new
+    end
+  end
+
+  # @since 0.1.0
+  attr_reader :event_emitter
+
+  # @since 0.1.0
+  attr_reader :manager_registry
+
+  # @since 0.1.0
+  def initialize
+    @manager_registry = EvilEvents::Core::Events::ManagerRegistry.new
+    @event_emitter    = EvilEvents::Core::Broadcasting::Emitter.new
+  end
+
+  # @param event_class [Class{Evilevents::Core::Events::AbstractEvent}]
+  # @param raw_subscriber [Object]
+  # @param delegator [String, Symbol, NilClass]
+  # @return void
+  #
+  # @since 0.1.0
+  def observe(event_class, raw_subscriber, delegator)
+    manager_registry.manager_of_event(event_class)
+                    .observe(raw_subscriber, delegator)
+  end
+
+  # @param event_type [String, Symbol]
+  # @param raw_subscriber [Object]
+  # @param delegator [String, Symbol, NilClass]
+  # @return void
+  #
+  # @since 0.1.0
+  def raw_observe(event_type, raw_subscriber, delegator)
+    manager_registry.manager_of_event_type(event_type)
+                    .observe(raw_subscriber, delegator)
+  end
+
+  # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
+  # @return [Array<EvilEvents::Core::Events::Subscriber>]
+  #
+  # @since 0.1.0
+  def observers(event_class)
+    manager_registry.manager_of_event(event_class).subscribers
+  end
+
+  # @param event [EvilEvents::Core::Events::AbstractEvent]
+  # @return void
+  #
+  # @since 0.1.0
+  def emit(event)
+    event_emitter.emit(event)
+  end
+
+  # @param event_type [String]
+  # @param event_attributes [Hash]
+  # @return void
+  #
+  # @since 0.1.0
+  def raw_emit(event_type, **event_attributes)
+    event_emitter.raw_emit(event_type, **event_attributes)
+  end
+
+  # @param adapter_name [Symbol, String]
+  # @return [EvilEvents::Core::Broadcasting::Dispatcher::Dispatchable]
+  #
+  # @since 0.1.0
+  def resolve_adapter(adapter_name)
+    EvilEvents::Core::Broadcasting::Adapters.resolve(adapter_name)
+  end
+
+  # @param event_class [Class{EvilEvents::Core::Events::AbstractEvent}]
+  # @return void
+  #
+  # @since 0.1.0
+  def register_event_class(event_class)
+    manager_registry.register_with(event_class)
+  end
+
+  # @param event_class [Class{EvilEvents::Core::events::AbstractEvent}]
+  # @return void
+  #
+  # @since 0.1.0
+  def unregister_event_class(event_class)
+    manager_registry.unregister_with(event_class)
+  end
+
+  # @param event [EvilEvents::Core::Events::AbstractEvent]
+  # @return [EvilEvents::Core::Events::Manager]
+  #
+  # @since 0.1.0
+  def manager_of_event(event)
+    manager_registry.manager_of_event(event.class)
+  end
+
+  # @param event_type [String]
+  # @return [EvilEvents::Core::Events::Manager]
+  #
+  # @since 0.1.0
+  def manager_of_event_type(event_type)
+    manager_registry.manager_of_event_type(event_type)
+  end
+
+  # @param event_type [String]
+  # @param event_attributes [Hash]
+  # @return [EvilEvents::Core::Events::AbstractEvent]
+  #
+  # @since 0.1.0
+  def resolve_event_object(event_type, **event_attributes)
+    manager_of_event_type(event_type).event_class.new(**event_attributes)
+  end
+
+  # @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::EventClassFactory.create(
+      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::EventClassFactory.create_abstract(
+      event_type
+    )
+  end
+end

data/lib/evil_events/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EvilEvents
+  # @api public
+  # @since 0.1.0
+  VERSION = '0.1.0rc1'
+end

data/lib/evil_events.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'dry-configurable'
+require 'dry-container'
+require 'dry-struct'
+require 'dry-types'
+require 'concurrent'
+require 'logger'
+require 'json'
+
+# @api public
+# @since 0.1.0
+module EvilEvents
+  require_relative 'evil_events/shared'
+  require_relative 'evil_events/core'
+  require_relative 'evil_events/system'
+  require_relative 'evil_events/system/mock'
+  require_relative 'evil_events/config'
+  require_relative 'evil_events/boot_point'
+  require_relative 'evil_events/version'
+
+  # @since 0.1.0
+  Types = Shared::Types
+
+  class << self
+    # @see EvilEvents::System
+    # @api public
+    # @since 0.1.0
+    def [](event_type)
+      EvilEvents::BootPoint::System[:event_system].define_abstract_event_class(
+        event_type
+      )
+    end
+
+    # @see EvilEvents::System
+    # @api public
+    # @since 0.1.0
+    def define_event(event_type, &event_class_definitions)
+      EvilEvents::BootPoint::System[:event_system].define_event_class(
+        event_type, &event_class_definitions
+      )
+    end
+
+    # @see EvilEvents::System
+    # @api public
+    # @since 0.1.0
+    def emit(event_type, **event_attributes)
+      EvilEvents::BootPoint::System[:event_system].raw_emit(
+        event_type, **event_attributes
+      )
+    end
+  end
+end