RES 3.0 integration

aggregate_root/lib/aggregate_root.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "aggregate_root/version"
-require_relative "aggregate_root/configuration"
-require_relative "aggregate_root/transform"
 require_relative "aggregate_root/default_apply_strategy"
 require_relative "aggregate_root/repository"
 require_relative "aggregate_root/instrumented_repository"
@@ -11,12 +9,9 @@
 
 module AggregateRoot
   module OnDSL
-    ANONYMOUS_CLASS = "#<Class:".freeze
-
     def on(*event_klasses, &block)
       event_klasses.each do |event_klass|
         name = event_klass.to_s
-        raise(ArgumentError, "Anonymous class is missing name") if name.start_with? ANONYMOUS_CLASS
 
         handler_name = "on_#{name}"
         define_method(handler_name, &block)
@@ -78,19 +73,24 @@ def marshal_load(vars)
     end
   end
 
-  def self.with_default_apply_strategy
+  def self.with_default_strategy(strict: true)
     Module.new do
       def self.included(host_class)
         host_class.extend OnDSL
-        host_class.include AggregateRoot.with_strategy(-> { DefaultApplyStrategy.new })
+        host_class.extend Constructor
+        host_class.include AggregateMethods
+      end
+
+      define_method :apply_strategy do
+        DefaultApplyStrategy.new(strict: strict)
       end
     end
   end
 
   def self.with_strategy(strategy)
     Module.new do
       def self.included(host_class)
-        host_class.extend Constructor
+        host_class.extend  Constructor
         host_class.include AggregateMethods
       end
 
@@ -101,6 +101,6 @@ def self.included(host_class)
   end
 
   def self.included(host_class)
-    host_class.include with_default_apply_strategy
+    host_class.include with_default_strategy
   end
 end

aggregate_root/lib/aggregate_root/default_apply_strategy.rb

@@ -2,39 +2,35 @@
 
 module AggregateRoot
   MissingHandler = Class.new(StandardError)
+  NullHandler    = Proc.new {}
 
   class DefaultApplyStrategy
     def initialize(strict: true)
       @strict = strict
     end
 
     def call(aggregate, event)
-      name = handler_name(aggregate, event)
-      if aggregate.respond_to?(name, true)
-        aggregate.method(name).call(event)
-      else
-        raise MissingHandler.new("Missing handler method #{name} on aggregate #{aggregate.class}") if strict
-      end
+      on_handler(aggregate, event.event_type)[event]
     end
 
     private
 
-    def handler_name(aggregate, event)
-      on_dsl_handler_name(aggregate, event.event_type) || apply_handler_name(event.event_type)
-    end
-
-    def on_dsl_handler_name(aggregate, event_type)
-      aggregate.class.on_methods[event_type] if aggregate.class.respond_to?(:on_methods)
+    def on_handler(aggregate, event_type)
+      on_method_name = aggregate.class.on_methods.fetch(event_type)
+      aggregate.method(on_method_name)
+    rescue KeyError
+      missing_handler(aggregate, event_type)
     end
 
-    def apply_handler_name(event_type)
-      "apply_#{Transform.to_snake_case(event_type(event_type))}"
-    end
-
-    def event_type(event_type)
-      event_type.split(/::|\./).last
+    def missing_handler(aggregate, event_type)
+      if strict
+        raise MissingHandler.new("Missing handler method on aggregate #{aggregate.class} for #{event_type}")
+      else
+        NullHandler
+      end
     end
 
     attr_reader :strict, :on_methods
   end
+  private_constant :DefaultApplyStrategy
 end

aggregate_root/lib/aggregate_root/repository.rb

@@ -2,7 +2,7 @@
 
 module AggregateRoot
   class Repository
-    def initialize(event_store = default_event_store)
+    def initialize(event_store)
       @event_store = event_store
     end
 
@@ -29,9 +29,5 @@ def with_aggregate(aggregate, stream_name, &block)
     private
 
     attr_reader :event_store
-
-    def default_event_store
-      AggregateRoot.configuration.default_event_store
-    end
   end
 end

aggregate_root/spec/aggregate_root_spec.rb

@@ -26,22 +26,23 @@ def expire
 
       private
 
-      def apply_order_created(_event)
-        @status = :created
+      on Orders::Events::OrderCreated do |event|
+        @status     = :created
+        @created_at =  event.valid_at
       end
 
-      def apply_order_expired(_event)
-        @status = :expired
+      on Orders::Events::OrderExpired do |event|
+        @status     = :expired
+        @expired_at =  event.valid_at
       end
     end
   end
 
   it "should have ability to apply event on itself" do
     order = order_klass.new(uuid)
     order_created = Orders::Events::OrderCreated.new
-
-    expect(order).to receive(:"apply_order_created").with(order_created).and_call_original
     order.apply(order_created)
+
     expect(order.status).to eq :created
     expect(order.unpublished_events.to_a).to eq([order_created])
   end
@@ -51,6 +52,12 @@ def apply_order_expired(_event)
     expect(order.unpublished_events.to_a).to be_empty
   end
 
+  it "should raise error for missing apply method based on a default apply strategy" do
+    order = order_klass.new(uuid)
+    spanish_inquisition = Orders::Events::SpanishInquisition.new
+    expect { order.apply(spanish_inquisition) }.to raise_error(AggregateRoot::MissingHandler, "Missing handler method on aggregate #{order_klass} for Orders::Events::SpanishInquisition")
+  end
+
   it "should receive a method call based on a default apply strategy" do
     order = order_klass.new(uuid)
     order_created = Orders::Events::OrderCreated.new
@@ -59,18 +66,9 @@ def apply_order_expired(_event)
     expect(order.status).to eq :created
   end
 
-  it "should raise error for missing apply method based on a default apply strategy" do
-    order = order_klass.new(uuid)
-    spanish_inquisition = Orders::Events::SpanishInquisition.new
-    expect { order.apply(spanish_inquisition) }.to raise_error(
-      AggregateRoot::MissingHandler,
-      "Missing handler method apply_spanish_inquisition on aggregate #{order_klass}"
-    )
-  end
-
   it "should ignore missing apply method based on a default non-strict apply strategy" do
     klass =
-      Class.new { include AggregateRoot.with_strategy(-> { AggregateRoot::DefaultApplyStrategy.new(strict: false) }) }
+      Class.new { include AggregateRoot.with_default_strategy(strict: false) }
     order = klass.new
     spanish_inquisition = Orders::Events::SpanishInquisition.new
     expect { order.apply(spanish_inquisition) }.to_not raise_error
@@ -113,7 +111,7 @@ def custom_expired(_event)
   end
 
   it "ruby 2.7 compatibility" do
-    klass = Class.new { include AggregateRoot.with_default_apply_strategy }
+    klass = Class.new { include AggregateRoot.with_default_strategy }
 
     # This is just a way to ensure that the AggregateMethods was included on
     # the klass directly, not that it was an include to the anonymous module.
@@ -258,16 +256,6 @@ def custom_expired(_event)
       order.apply(Orders::Events::OrderExpired.new)
       expect(order.status).to eq(%i[base_expired inherited_expired])
     end
-
-    it "does not support anonymous events" do
-      expect do
-        Class.new do
-          include AggregateRoot
-
-          on(Class.new) { |_ev| }
-        end
-      end.to raise_error(ArgumentError, "Anonymous class is missing name")
-    end
   end
 
   describe "#initialize" do

aggregate_root/spec/instrumented_repository_spec.rb

@@ -27,11 +27,11 @@ def expire
 
         private
 
-        def apply_order_created(_event)
+        on Orders::Events::OrderCreated do |_event|
           @status = :created
         end
 
-        def apply_order_expired(_event)
+        on Orders::Events::OrderExpired do |_event|
           @status = :expired
         end
       end

aggregate_root/spec/repository_spec.rb

@@ -29,51 +29,16 @@ def expire
 
         private
 
-        def apply_order_created(_event)
+        on Orders::Events::OrderCreated do |_event|
           @status = :created
         end
 
-        def apply_order_expired(_event)
+        on Orders::Events::OrderExpired do |_event|
           @status = :expired
         end
       end
     end
 
-    def with_default_event_store(store)
-      previous = AggregateRoot.configuration.default_event_store
-      AggregateRoot.configure { |config| config.default_event_store = store }
-      yield
-      AggregateRoot.configure { |config| config.default_event_store = previous }
-    end
-
-    describe "#initialize" do
-      it "should use default client if event_store not provided" do
-        with_default_event_store(event_store) do
-          repository = AggregateRoot::Repository.new
-
-          order = repository.load(order_klass.new(uuid), stream_name)
-          order_created = Orders::Events::OrderCreated.new
-          order.apply(order_created)
-          repository.store(order, stream_name)
-
-          expect(event_store.read.stream(stream_name).to_a).to eq [order_created]
-        end
-      end
-
-      it "should prefer provided event_store client" do
-        with_default_event_store(double(:event_store)) do
-          repository = AggregateRoot::Repository.new(event_store)
-
-          order = repository.load(order_klass.new(uuid), stream_name)
-          order_created = Orders::Events::OrderCreated.new
-          order.apply(order_created)
-          repository.store(order, stream_name)
-
-          expect(event_store.read.stream(stream_name).to_a).to eq [order_created]
-        end
-      end
-    end
-
     describe "#load" do
       specify do
         event_store.publish(Orders::Events::OrderCreated.new, stream_name: stream_name)

aggregate_root/spec/spec_helper.rb

@@ -4,8 +4,6 @@
 require "ruby_event_store"
 require_relative "../../support/helpers/rspec_defaults"
 
-RSpec.configure { |spec| spec.before(:each) { AggregateRoot.configure { |config| config.default_event_store = nil } } }
-
 module Orders
   module Events
     OrderCreated = Class.new(RubyEventStore::Event)

contrib/dres_rails/Gemfile

@@ -9,7 +9,6 @@ gem "ruby_event_store", path: "../.."
 gem "ruby_event_store-browser", path: "../.."
 gem "rails_event_store", path: "../.."
 gem "ruby_event_store-active_record", path: "../.."
-gem "rails_event_store_active_record", path: "../.."
 gem "aggregate_root", path: "../.."
 
 gem "pg"

contrib/dres_rails/Gemfile.lock

@@ -263,7 +263,6 @@ DEPENDENCIES
   mutant-rspec (= 0.11.22)
   pg
   rails_event_store!
-  rails_event_store_active_record!
   rake (>= 10.0)
   rspec (~> 3.6)
   rspec-rails

contrib/ruby_event_store-outbox/README.md

@@ -25,7 +25,7 @@ In your event store configuration, as a dispatcher use `RubyEventStore::Immediat
 ```ruby
 
 RailsEventStore::Client.new(
-  dispatcher: RailsEventStore::ImmediateAsyncDispatcher.new(scheduler: RubyEventStore::Outbox::SidekiqScheduler.new),
+  dispatcher: RailsEventStore::ImmediateDispatcher.new(scheduler: RubyEventStore::Outbox::SidekiqScheduler.new),
   ...
 )
 ```

contrib/ruby_event_store-profiler/README.md

@@ -10,7 +10,7 @@ event_store =
   RubyEventStore::Client.new(
     repository: RubyEventStore::InstrumentedRepository.new(RubyEventStore::InMemoryRepository.new, instrumenter),
     mapper: RubyEventStore::Mappers::InstrumentedMapper.new(RubyEventStore::Mappers::Default.new, instrumenter),
-    dispatcher: RubyEventStore::InstrumentedDispatcher.new(RubyEventStore::Dispatcher.new, instrumenter),
+    dispatcher: RubyEventStore::InstrumentedDispatcher.new(RubyEventStore::SyncScheduler.new, instrumenter),
   )
 
 repository = AggregateRoot::InstrumentedRepository.new(AggregateRoot::Repository.new(event_store), instrumenter)

contrib/ruby_event_store-profiler/examples/demo

@@ -10,7 +10,7 @@ asn = ActiveSupport::Notifications
 event_store = RubyEventStore::Client.new(
   repository: RubyEventStore::InstrumentedRepository.new(RubyEventStore::InMemoryRepository.new, asn),
   mapper: RubyEventStore::Mappers::InstrumentedMapper.new(RubyEventStore::Mappers::Default.new, asn),
-  dispatcher: RubyEventStore::InstrumentedDispatcher.new(RubyEventStore::Dispatcher.new, asn)
+  dispatcher: RubyEventStore::InstrumentedDispatcher.new(RubyEventStore::SyncScheduler.new, asn)
 )
 DummyEvent  = Class.new(RubyEventStore::Event)
 dummy = DummyEvent.new

contrib/ruby_event_store-profiler/lib/ruby_event_store/profiler.rb

@@ -1,6 +1,6 @@
 module RubyEventStore
   class Profiler
-    METRICS = [/rails_event_store/, /aggregate_root/, "total"].freeze
+    METRICS = [/ruby_event_store/, /aggregate_root/, "total"].freeze
     private_constant :METRICS
 
     def initialize(instrumenter)