event_sorcerer 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a30a15c744e7f3f861840bbdc3cfb822a5b8a88
-  data.tar.gz: 11012f39e7e59b80349a947f63216cec5f28657a
+  metadata.gz: 12872b11f0ed0ab93b3223cfc0c2e3ec9d03412d
+  data.tar.gz: 4e63ccf41e6f96e20c5852409ebe44371d0f6ecc
 SHA512:
-  metadata.gz: 1a2db2aaa933ed7280f7cebe9d6544bcd767a605ddc78108ed2e1911481d2efb5f7ebf2b364358b82e8777357a01190dab8e3bc11371db3b6f81844287e3c0a9
-  data.tar.gz: de9da895801ddd797276efdd48c55cccad6342a822eea80b6451a2e864f7b2c97bc59825c43f2387dc0137840639a65e1b31d2e92345f172a06949d2660b1d93
+  metadata.gz: 1e11b7fd1cca67145850336cfb78f04c910e316a2b0e820443bcc8e68dca3448635776fc5453bd1b3189f3ea64c34f974e6a33d2dddc41cb61412ef9f9c5df0e
+  data.tar.gz: d3006f46d56580237e33278ddfc86500ae57bdf0799846a781e919672d61dc2659b844ea2dd0676eb4915a06473a990927d9978aa11813dff188aa3355c14a0c

data/lib/event_sorcerer/aggregate.rb

@@ -23,17 +23,25 @@ module EventSorcerer
       #
       # Returns an Array of AggregateProxy objects.
       def all
-        with_all_loaders_for_type do |loaders|
-          loaders.map(&:load).each do |aggregate|
+        all_loaders_for_type.map do |loader|
+          cached = unit_of_work.fetch_aggregate(to_s, loader.id)
+
+          next cached if cached
+
+          loader.load.tap do |aggregate|
             unit_of_work.store_aggregate(aggregate)
           end
         end
       end
 
       # Public: An array of symbols representing the names of the methods which
-      #         are events.
+      #         are events. Includes event methods of superclass.
       def event_methods
-        @event_methods ||= []
+        if superclass.respond_to? :event_methods
+          _event_methods.concat(superclass.event_methods).uniq
+        else
+          _event_methods
+        end
       end
 
       # Public: Methods defined within this block will have their method symbol
@@ -51,26 +59,26 @@ module EventSorcerer
           !starting_methods.include? method
         end
 
-        event_methods.concat new_events
+        _event_methods.concat new_events
         class_eval(&block)
 
         self
       end
 
-      # Public: Load an aggregate out of the event store.
+      # Public: Load an aggregate(s) out of the event store.
       #
-      # id - the ID of the aggregate to load.
+      # id_or_ids - the ID of the aggregate to load or an array of the same.
       #
-      # Returns an AggregateProxy object.
-      def find(id)
-        if unit_of_work.fetch_aggregate(id)
-          return unit_of_work.fetch_aggregate(id)
+      # Returns an AggregateProxy object or an array of the same.
+      def find(id_or_ids)
+        return find_many(id_or_ids) if id_or_ids.respond_to?(:each)
+
+        if unit_of_work.fetch_aggregate(to_s, id_or_ids)
+          return unit_of_work.fetch_aggregate(to_s, id_or_ids)
         end
 
-        with_loader_for_id(id) do |loader|
-          loader.load.tap do |aggregate|
-            unit_of_work.store_aggregate(aggregate)
-          end
+        loader_for_id(id_or_ids).load.tap do |aggregate|
+          unit_of_work.store_aggregate(aggregate)
         end
       end
 
@@ -80,14 +88,12 @@ module EventSorcerer
       #
       # Returns an AggregateProxy object.
       def find_or_new(id)
-        if unit_of_work.fetch_aggregate(id)
-          return unit_of_work.fetch_aggregate(id)
+        if unit_of_work.fetch_aggregate(to_s, id)
+          return unit_of_work.fetch_aggregate(to_s, id)
         end
 
-        with_loader_for_id(id, false) do |loader|
-          loader.load.tap do |aggregate|
-            unit_of_work.store_aggregate(aggregate)
-          end
+        loader_for_id(id, false).load.tap do |aggregate|
+          unit_of_work.store_aggregate(aggregate)
         end
       end
 
@@ -104,56 +110,74 @@ module EventSorcerer
 
       private
 
-      # Private: Grabs the event streams for the aggregate class and yields
-      #          them to a given block.
-      #
-      # block - the block to yield the event stream to.
+      # Private: An array of symbols representing the names of the methods
+      #          which are events.
+      def _event_methods
+        @_event_methods ||= []
+      end
+
+      # Private: Creates an AggregateLoader for each persisted aggregate.
       #
       # Returns the return value of the given block.
-      def with_all_event_streams_for_type
-        yield event_store.read_event_streams_for_type(name)
+      def all_loaders_for_type
+        event_store.read_event_streams_for_type(name).map do |stream|
+          AggregateLoader.new(self, stream.id, stream.events,
+                              stream.current_version, true)
+        end
       end
 
-      # Private: Creates AggregateLoaders for an ID and yields it to a given
-      #          block.
+      # Private: Maps an array of IDs replacing with cached aggregate if
+      #          available.
       #
-      # prohibit_new - value of the prohibit_new flag to be passed to loaders.
-      # block        - the block to yield the event stream to.
+      # ids - the IDs of the aggregates to check the cache from.
       #
-      # Returns the return value of the given block.
-      def with_all_loaders_for_type(prohibit_new = true)
-        with_all_event_streams_for_type do |streams|
-          loaders = streams.map do |stream|
-            AggregateLoader.new(self, stream.id, stream.events,
-                                stream.current_version, prohibit_new)
-          end
+      # Returns a mixed Array of AggregateProxy objects and IDs.
+      def perform_cache_pass(ids)
+        ids.map do |id|
+          cached = unit_of_work.fetch_aggregate(to_s, id)
 
-          yield loaders
+          cached ? cached : id
         end
       end
 
-      # Private: Grabs the event stream for an ID and yields it to a given
-      #          block.
+      # Private: Loads an array of aggregates out of the event store.
       #
-      # id    - the ID of the aggregate to get the event stream for.
-      # block - the block to yield the event stream to.
+      # ids - the IDs of the aggregates to load.
       #
-      # Returns the return value of the given block.
-      def with_event_stream_for_id(id)
-        yield event_store.read_event_stream(id, name)
+      # Returns an Array of AggregateProxy objects.
+      def find_many(ids)
+        aggregates = perform_cache_pass(ids)
+
+        uncached_ids = aggregates.reject { |a| a.is_a? self }
+
+        uncached = loaders_for_ids(uncached_ids).reduce({}) do |hash, loader|
+          aggregate = loader.load
+          unit_of_work.store_aggregate(aggregate)
+
+          hash.merge aggregate.id => aggregate
+        end
+
+        aggregates.map do |id_or_agg|
+          uncached[id_or_agg] ? uncached[id_or_agg] : id_or_agg
+        end
       end
 
-      # Private: Creates an AggregateLoader for an ID and yields it to a given
-      #          block.
+      def loader_for_id(id, prohibit_new = true)
+        stream = event_store.read_event_stream(id, name)
+
+        AggregateLoader.new(self, stream.id, stream.events,
+                            stream.current_version, prohibit_new)
+      end
+
+      # Private: Creates an AggregateLoader for each given ID.
       #
       # id    - the ID of the aggregate to get the event stream for.
-      # block - the block to yield the event stream to.
       #
-      # Returns the return value of the given block.
-      def with_loader_for_id(id, prohibit_new = true)
-        with_event_stream_for_id(id) do |stream|
-          yield AggregateLoader.new(self, stream.id, stream.events,
-                                    stream.current_version, prohibit_new)
+      # Returns an Array of AggregateLoader instances.
+      def loaders_for_ids(ids, prohibit_new = true)
+        event_store.read_multiple_event_streams(ids, name).map do |stream|
+          AggregateLoader.new(self, stream.id, stream.events,
+                              stream.current_version, prohibit_new)
         end
       end
     end

data/lib/event_sorcerer/aggregate_loader.rb

@@ -1,6 +1,9 @@
 module EventSorcerer
   # Public: Service class for loading aggregates from the event store.
   class AggregateLoader
+    # Public: Returns the id for the aggregate to be loaded.
+    attr_reader :id
+
     # Public: Creates a new AggregateLoader instance.
     #
     # klass        - class for the aggregate to be loaded.
@@ -29,9 +32,6 @@ module EventSorcerer
     # Private: Returns array of Events to hydrate with.
     attr_reader :events
 
-    # Private: Returns the id for the aggregate to be loaded.
-    attr_reader :id
-
     # Private: Returns the class for the aggregate to be loaded.3
     attr_reader :klass
 

data/lib/event_sorcerer/aggregate_proxy.rb

@@ -60,6 +60,8 @@ module EventSorcerer
     # Private: Handles the serialization of event arguments and pushes the
     #          Event object onto the _dirty_events array. Increments the local
     #          version number for the aggregate.
+    #
+    # Returns argument hash.
     def add_dirty_event!(time, method_sym, *arguments)
       increment_version!
 
@@ -69,7 +71,7 @@ module EventSorcerer
       details = ArgumentHashifier.hashify(method.parameters, arguments.dup)
       @_dirty_events << Event.new(method_sym, time, details)
 
-      self
+      details
     end
 
     # Private: Decrements the wrapped aggregates local version by one.
@@ -104,12 +106,10 @@ module EventSorcerer
       fail EventArgumentError if block
 
       time = Time.now
-      add_dirty_event!(time, method_sym, *arguments)
-
-      expected_args = arguments.slice(0, @_aggregate.method(method_sym).arity)
+      details = add_dirty_event!(time, method_sym, *arguments)
 
       EventSorcerer.with_time(time) do
-        @_aggregate.send method_sym, *expected_args
+        Invokr.invoke method: method_sym, on: @_aggregate, using: details
       end
     rescue StandardError => e
       undo_dirty_event!

data/lib/event_sorcerer/no_unit_of_work.rb

@@ -8,7 +8,7 @@ module EventSorcerer
       delegates :EventSorcerer, :message_bus
 
       # Public: Returns nil.
-      def fetch_aggregate(_id)
+      def fetch_aggregate(_type, _id)
         nil
       end
 

data/lib/event_sorcerer/unit_of_work.rb

@@ -41,12 +41,15 @@ module EventSorcerer
 
     # Public: Fetches an aggregate via it's ID from the identity map.
     #
-    # id - the ID for the aggregate.
+    # type - the type for the aggregate.
+    # id   - the ID for the aggregate.
     #
     # Returns nil if not found.
     # Returns Aggregate if found.
-    def fetch_aggregate(id)
-      identity_map[id]
+    def fetch_aggregate(type, id)
+      return unless identity_map[type]
+
+      identity_map[type][id]
     end
 
     def handle_save(save)
@@ -61,9 +64,9 @@ module EventSorcerer
     #
     # Returns self.
     def store_aggregate(aggregate)
-      return self if fetch_aggregate(aggregate.id)
-
-      identity_map[aggregate.id] = aggregate
+      type = aggregate.class.to_s
+      identity_map[type] ||= {}
+      identity_map[type][aggregate.id] = aggregate
 
       self
     end

data/lib/event_sorcerer/version.rb

@@ -1,4 +1,4 @@
 # Public: Defines a constant for the current version number.
 module EventSorcerer
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_sorcerer
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Sebastian Edwards
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-04 00:00:00.000000000 Z
+date: 2014-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler