Get rid of dubious meta-apply method handlers

* no sane way to support event type scheme for extract last part
* no sane way to normalize every event type to method name

Author: mostlyobvious

aggregate_root/lib/aggregate_root.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "aggregate_root/version"
-require_relative "aggregate_root/transform"
 require_relative "aggregate_root/default_apply_strategy"
 require_relative "aggregate_root/repository"
 require_relative "aggregate_root/instrumented_repository"

aggregate_root/lib/aggregate_root/default_apply_strategy.rb

@@ -2,37 +2,32 @@
 
 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
+        lambda { |event| raise MissingHandler.new("Missing handler method on aggregate #{aggregate.class} for #{event_type}") }
+      else
+        NullHandler
+      end
     end
 
     attr_reader :strict, :on_methods

aggregate_root/lib/aggregate_root/transform.rb

@@ -26,11 +26,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
@@ -39,9 +39,8 @@ def apply_order_expired(_event)
   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 +50,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,15 +64,6 @@ 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) }) }

aggregate_root/spec/aggregate_root_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/instrumented_repository_spec.rb

@@ -29,11 +29,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