aggregate_root 0.39.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07b31561cc74b2f7be4a3a714f2af9e9f1b82a6567707249da9d16f8271f7f2f
-  data.tar.gz: 612fdb3ec19422a7885ed38c64f70f241fa67b34270be0ab708ef3186581d24d
+  metadata.gz: 6af35e06f7f261f5275b2e0f74b4abba41d7437a94d9527d66e7add0bf6d3788
+  data.tar.gz: fe132199dc2121bdb0bf5aa2591714aab84553a90a270307f79890b0276fca6a
 SHA512:
-  metadata.gz: d55999302930c6c01dd9275f0d0bd092a33c078d09c61d69703fa91f18715b5330e50c3e3d752bfece462aecaf1f0200b58fea52bf891035666c9e6a2430cc43
-  data.tar.gz: 3601973a69042ad88e2aa0f24091cc2aad120b4c5d265b98587a72def5b8f4cb456f161c19dcd34cb1bfbd4e625e623fd0ce64fbb74997b3cad60b7ac543b4bc
+  metadata.gz: 7157ba51608adc985fe90e595c7413b20ff15445d7c0830f05199c130f9449a4ac3f566b616beade6c19c4511168b078603f37e1dd79a4818f89c426c7b2f4fe
+  data.tar.gz: 50fe99d76b6073c9068a0cb93dd6775839cda59aed9a4f761adaa097b11316e9e3c19dffd94102b6fdc75cf769f055977b1a5ee67752e18bdc577bb78de3b960

data/Gemfile

@@ -4,4 +4,7 @@ gemspec
 
 eval_gemfile File.expand_path('../support/bundler/Gemfile.shared', __dir__)
 
-gem 'ruby_event_store', path: '../ruby_event_store'
+gem 'ruby_event_store', path: '../ruby_event_store'
+gem 'protobuf_nested_struct'
+gem 'google-protobuf', '~> 3.7.0'
+gem 'activesupport', '~> 5.0'

data/aggregate_root.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'ruby_event_store', '= 0.39.0'
+  spec.add_dependency 'ruby_event_store', '= 0.40.0'
 end

data/lib/aggregate_root.rb

@@ -3,92 +3,83 @@ require 'aggregate_root/configuration'
 require 'aggregate_root/transform'
 require 'aggregate_root/default_apply_strategy'
 require 'aggregate_root/repository'
+require 'aggregate_root/instrumented_repository'
+
 
 module AggregateRoot
-  module ClassMethods
+  module OnDSL
     def on(*event_klasses, &block)
       event_klasses.each do |event_klass|
-        name = event_klass.name || raise(ArgumentError, "Anonymous class is missing name")
+        name = event_klass.to_s
+        raise(ArgumentError, "Anonymous class is missing name") if name.start_with? "#<Class:"
         handler_name = "on_#{name}"
         define_method(handler_name, &block)
         @on_methods ||= {}
-        @on_methods[event_klass]=handler_name
+        @on_methods[name] = handler_name
         private(handler_name)
       end
     end
 
     def on_methods
-      ancestors.
-        select{|k| k.instance_variables.include?(:@on_methods)}.
-        map{|k| k.instance_variable_get(:@on_methods) }.
-        inject({}, &:merge)
+      @on_methods ||= {}
+      (superclass.respond_to?(:on_methods) ? superclass.on_methods : {}).merge(@on_methods)
     end
   end
 
-  def self.included(host_class)
-    host_class.extend(ClassMethods)
-  end
-
-  def apply(*events)
-    events.each do |event|
-      apply_strategy.(self, event)
-      unpublished << event
+  module Constructor
+    def new
+      super().tap do |instance|
+        instance.instance_variable_set(:@version, -1)
+        instance.instance_variable_set(:@unpublished_events, [])
+      end
     end
   end
 
-  def version
-    @version ||= -1
-  end
+  module AggregateMethods
+    def apply(*events)
+      events.each do |event|
+        apply_strategy.(self, event)
+        @unpublished_events << event
+      end
+    end
 
-  def version=(value)
-    @unpublished_events = nil
-    @version = value
-  end
+    def version
+      @version
+    end
 
-  def unpublished_events
-    unpublished.each
-  end
+    def version=(value)
+      @unpublished_events = []
+      @version = value
+    end
 
-  def load(stream_name, event_store: default_event_store)
-    warn <<~EOW
-      Method `load` on aggregate is deprecated. Use AggregateRoot::Repository instead.
-      Instead of: `order = Order.new.load("OrderStreamHere")`
-      you need to have code:
-      ```
-      repository = AggregateRoot::Repository.new
-      order = repository.load(Order.new, "OrderStreamHere")
-      ```
-    EOW
-    @loaded_from_stream_name = stream_name
-    Repository.new(event_store).load(self, stream_name)
+    def unpublished_events
+      @unpublished_events.each
+    end
   end
 
-  def store(stream_name = loaded_from_stream_name, event_store: default_event_store)
-    warn <<~EOW
-      Method `store` on aggregate is deprecated. Use AggregateRoot::Repository instead.
-      Instead of: `order.store("OrderStreamHere")`
-      you need to have code:
-      ```
-      repository = AggregateRoot::Repository.new
-      # load and order and execute some operation on it here
-      repository.store(order, "OrderStreamHere")
-      ```
-    EOW
-    Repository.new(event_store).store(self, stream_name)
+  def self.with_default_apply_strategy
+    Module.new do
+      def self.included(host_class)
+        host_class.extend  OnDSL
+        host_class.include AggregateRoot.with_strategy(->{ DefaultApplyStrategy.new })
+      end
+    end
   end
 
-  private
-  attr_reader :loaded_from_stream_name
-
-  def default_event_store
-    AggregateRoot.configuration.default_event_store
-  end
+  def self.with_strategy(strategy)
+    Module.new do
+      def self.included(host_class)
+        host_class.extend  Constructor
+        host_class.include AggregateMethods
+      end
 
-  def unpublished
-    @unpublished_events ||= []
+      define_method :apply_strategy do
+        strategy.call
+      end
+    end
   end
 
-  def apply_strategy
-    DefaultApplyStrategy.new(on_methods: self.class.on_methods)
+  def self.included(host_class)
+    host_class.include with_default_apply_strategy
   end
 end

data/lib/aggregate_root/default_apply_strategy.rb

@@ -2,13 +2,12 @@ module AggregateRoot
   MissingHandler = Class.new(StandardError)
 
   class DefaultApplyStrategy
-    def initialize(strict: true, on_methods: {})
+    def initialize(strict: true)
       @strict = strict
-      @on_methods = on_methods
     end
 
     def call(aggregate, event)
-      name = handler_name(event)
+      name = handler_name(aggregate, event)
       if aggregate.respond_to?(name, true)
         aggregate.method(name).call(event)
       else
@@ -18,16 +17,16 @@ module AggregateRoot
 
     private
 
-    def handler_name(event)
-      on_methods.fetch(event.class) { handler_name_by_class(event.class) }
+    def handler_name(aggregate, event)
+      aggregate.class.on_methods.fetch(event.type) { handler_name_by_type(event.type) }
     end
 
-    def handler_name_by_class(event_class)
-      "apply_#{Transform.to_snake_case(class_name(event_class))}"
+    def handler_name_by_type(event_type)
+      "apply_#{Transform.to_snake_case(event_type(event_type))}"
     end
 
-    def class_name(event_class)
-      event_class.name.split("::").last
+    def event_type(event_type)
+      event_type.split(%r{::|\.}).last
     end
 
     private

data/lib/aggregate_root/instrumented_repository.rb

@@ -0,0 +1,34 @@
+module AggregateRoot
+  class InstrumentedRepository
+    def initialize(repository, instrumentation)
+      @repository = repository
+      @instrumentation = instrumentation
+    end
+
+    def load(aggregate, stream_name)
+      instrumentation.instrument("load.repository.aggregate_root",
+                                 aggregate: aggregate,
+                                 stream: stream_name) do
+        repository.load(aggregate, stream_name)
+      end
+    end
+
+    def store(aggregate, stream_name)
+      instrumentation.instrument("store.repository.aggregate_root",
+                                 aggregate: aggregate,
+                                 version: aggregate.version,
+                                 stored_events: aggregate.unpublished_events.to_a,
+                                 stream: stream_name) do
+        repository.store(aggregate, stream_name)
+      end
+    end
+
+    def with_aggregate(aggregate, stream_name, &block)
+      block.call(load(aggregate, stream_name))
+      store(aggregate, stream_name)
+    end
+
+    private
+    attr_reader :instrumentation, :repository
+  end
+end

data/lib/aggregate_root/repository.rb

@@ -29,4 +29,4 @@ module AggregateRoot
       AggregateRoot.configuration.default_event_store
     end
   end
-end
+end

data/lib/aggregate_root/version.rb

@@ -1,3 +1,3 @@
 module AggregateRoot
-  VERSION = "0.39.0"
+  VERSION = "0.40.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aggregate_root
 version: !ruby/object:Gem::Version
-  version: 0.39.0
+  version: 0.40.0
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-24 00:00:00.000000000 Z
+date: 2019-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_event_store
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.39.0
+        version: 0.40.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.39.0
+        version: 0.40.0
 description: Event sourced (with Rails Event Store) aggregate root implementation
 email:
 - dev@arkency.com
@@ -39,6 +39,7 @@ files:
 - lib/aggregate_root.rb
 - lib/aggregate_root/configuration.rb
 - lib/aggregate_root/default_apply_strategy.rb
+- lib/aggregate_root/instrumented_repository.rb
 - lib/aggregate_root/repository.rb
 - lib/aggregate_root/transform.rb
 - lib/aggregate_root/version.rb
@@ -65,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Event sourced (with Rails Event Store) aggregate root implementation