nexia_event_store 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da7ed1c2d85dee75190b00526a806602d2d6c71b
-  data.tar.gz: 536ec662447be0e41c8199d19a43e732ef6f9331
+  metadata.gz: 84e933fac343a7fcf78be09656f655c380b4aff5
+  data.tar.gz: c773e4bda103b1a081cfef4deefc95de06e86833
 SHA512:
-  metadata.gz: 73bbaeaa3c718528b35aa230b5424e59cf45a63cbd7ddee2a7087a5b4f365ea8ec3d317f8b7c5c225abee78f09255f06427a17184088940c30ce669ff625d200
-  data.tar.gz: 67f5a022073cef94a0dc566085788ccca545c9c6cc3564485d0f5d3531d6e1457a4890a46ba85233dfc75975606cea79e2eb438dbbd2c4aa0143b0521a0cae60
+  metadata.gz: c7fe28929dbf33069a69d13c1def033533d79f4ed2163dd8a47b1fe1d1d1b38c0869895d5d4da7d4afc658b3509ecfc0b7f4557388b8f00876539fc86e55fcae
+  data.tar.gz: 3f604af91ed93a41538047947a733915479e43a86cd8a403bee9887cbb347fc3b0160603e6ff2edf4b5e8e2ad6128a528789578f1f18eaa6d0f895f8f9c5121b

data/lib/event_store/aggregate.rb

@@ -4,21 +4,19 @@ module EventStore
   class Aggregate
     extend Forwardable
 
-    attr_reader :id, :type, :event_table
+    attr_reader :id, :type, :event_table, :snapshot, :event_stream
 
-    def_delegators :@snapshot,
+    def_delegators :snapshot,
       :last_event,
-      :snapshot,
       :rebuild_snapshot!,
       :delete_snapshot!,
       :version,
       :version_for,
       :snapshot_version_table
 
-    def_delegators :@event_stream,
+    def_delegators :event_stream,
       :events,
       :events_from,
-      :event_stream,
       :event_stream_between,
       :event_table,
       :delete_events!
@@ -44,8 +42,8 @@ module EventStore
     end
 
     def append(events)
-      @event_stream.append(events) do |prepared_events|
-        @snapshot.store_snapshot(prepared_events)
+      event_stream.append(events) do |prepared_events|
+        snapshot.store_snapshot(prepared_events)
       end
     end
 

data/lib/event_store/client.rb

@@ -2,7 +2,17 @@ module EventStore
   class Client
     extend Forwardable
 
-    def_delegators :aggregate, :delete_snapshot!, :snapshot_version_table, :version_for
+    def_delegators :aggregate,
+                   :delete_snapshot!,
+                   :snapshot_version_table,
+                   :version_for,
+                   :event_table,
+                   :type,
+                   :id,
+                   :version
+
+    def_delegators :event_stream,
+                   :count
 
     def self.count
       Aggregate.count
@@ -20,18 +30,6 @@ module EventStore
       aggregate.snapshot_exists?
     end
 
-    def id
-      aggregate.id
-    end
-
-    def type
-      aggregate.type
-    end
-
-    def event_table
-      aggregate.event_table
-    end
-
     def append(event_data)
       aggregate.append(event_data)
       yield(event_data) if block_given?
@@ -70,14 +68,6 @@ module EventStore
       aggregate.events_from(version_number, max)
     end
 
-    def version
-      aggregate.version
-    end
-
-    def count
-      event_stream.length
-    end
-
     def destroy!
       aggregate.delete_events!
       aggregate.delete_snapshot!

data/lib/event_store/event_stream.rb

@@ -1,5 +1,6 @@
 module EventStore
   class EventStream
+    include Enumerable
 
     attr_reader :event_table
 
@@ -43,8 +44,19 @@ module EventStore
       query.all.map {|e| e[:serialized_event] = EventStore.unescape_bytea(e[:serialized_event]); e}
     end
 
-    def event_stream
-      events.all.map {|e| e[:serialized_event] = EventStore.unescape_bytea(e[:serialized_event]); e}
+    def last
+      to_a.last
+    end
+
+    def empty?
+      events.empty?
+    end
+
+    def each
+      events.all.each do |e|
+        e[:serialized_event] = EventStore.unescape_bytea(e[:serialized_event])
+        yield e
+      end
     end
 
     def delete_events!

data/lib/event_store/snapshot.rb

@@ -1,5 +1,6 @@
 module EventStore
   class Snapshot
+    include Enumerable
 
     attr_reader :snapshot_version_table, :snapshot_table
 
@@ -15,7 +16,7 @@ module EventStore
     end
 
     def last_event
-      snapshot.last
+      to_a.last
     end
 
     def version(snapshot_key =:current_version)
@@ -26,22 +27,16 @@ module EventStore
       version(snapshot_key(fully_qualified_name: fully_qualified_name, sub_key: sub_key))
     end
 
-    def size
-      snapshot.size
-    end
-
-    def snapshot
+    def each
       events_hash = auto_rebuild_snapshot(read_raw_snapshot)
-      snap = []
-      events_hash.each_pair do |key, value|
+      events_hash.inject([]) do |snapshot, (key, value)|
         fully_qualified_name, _ = key.split(EventStore::SNAPSHOT_KEY_DELIMITER)
         raw_event               = value.split(EventStore::SNAPSHOT_DELIMITER)
         version                 = raw_event.first.to_i
         serialized_event        = EventStore.unescape_bytea(raw_event[1])
         occurred_at             = Time.parse(raw_event.last)
-        snap << SerializedEvent.new(fully_qualified_name, serialized_event, version, occurred_at)
-      end
-      snap.sort {|a,b| a.version <=> b.version}
+        snapshot + [SerializedEvent.new(fully_qualified_name, serialized_event, version, occurred_at)]
+      end.sort_by(&:version).each { |e| yield e }
     end
 
     def rebuild_snapshot!

data/lib/event_store/version.rb

@@ -1,3 +1,3 @@
 module EventStore
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
 end

data/spec/event_store/client_spec.rb

@@ -49,7 +49,6 @@ describe EventStore::Client do
   describe '#raw_event_stream' do
     it "should be an array of hashes that represent database records, not EventStore::SerializedEvent objects" do
       raw_stream = es_client.new(AGGREGATE_ID_ONE, :device).raw_event_stream
-      expect(raw_stream.class).to eq(Array)
       raw_event = raw_stream.first
       expect(raw_event.class).to eq(Hash)
       expect(raw_event.keys).to eq([:id, :version, :aggregate_id, :fully_qualified_name, :occurred_at, :serialized_event, :sub_key])
@@ -288,16 +287,16 @@ describe EventStore::Client do
         it "should set the snapshot version number to match that of the last event in the aggregate's event stream" do
           events = [@new_event, @really_new_event]
           initial_stream_version = @client.raw_event_stream.last[:version]
-          expect(@client.snapshot.last.version).to eq(initial_stream_version)
+          expect(@client.snapshot.version).to eq(initial_stream_version)
           @client.append(events)
           updated_stream_version = @client.raw_event_stream.last[:version]
-          expect(@client.snapshot.last.version).to eq(updated_stream_version)
+          expect(@client.snapshot.version).to eq(updated_stream_version)
         end
 
         it "should write-through-cache the event in a snapshot without duplicating events" do
           @client.destroy!
           @client.append([@old_event, @new_event, @really_new_event])
-          expect(@client.snapshot).to eq(@client.event_stream)
+          expect(@client.snapshot.to_a).to eq(@client.event_stream)
         end
 
         it "should raise a meaningful exception when a nil event given to it to append" do
@@ -323,7 +322,7 @@ describe EventStore::Client do
           expected =  []
           expected << @client.event_stream.first
           expected << @client.event_stream.last
-          expect(@client.snapshot).to eq(expected)
+          expect(@client.snapshot.to_a).to eq(expected)
         end
 
         #TODO if we let the db assign version# then this can't be true anymore
@@ -341,10 +340,10 @@ describe EventStore::Client do
         it "should set the snapshot version number to match that of the last event in the aggregate's event stream" do
           events = [@old_event, @old_event]
           initial_stream_version = @client.raw_event_stream.last[:version]
-          expect(@client.snapshot.last.version).to eq(initial_stream_version)
+          expect(@client.snapshot.version).to eq(initial_stream_version)
           @client.append(events)
           updated_stream_version = @client.raw_event_stream.last[:version]
-          expect(@client.snapshot.last.version).to eq(updated_stream_version)
+          expect(@client.snapshot.version).to eq(updated_stream_version)
         end
       end
     end

data/spec/event_store/snapshot_spec.rb

@@ -6,12 +6,11 @@ AGGREGATE_ID_TWO = SecureRandom.uuid
 
 module EventStore
   describe "Snapshots" do
-
     context "when there are no events" do
       let(:client)    { EventStore::Client.new(AGGREGATE_ID_ONE) }
 
       it "should build an empty snapshot for a new client" do
-        expect(client.snapshot).to eq([])
+        expect(client.snapshot.any?).to eq(false)
         expect(client.version).to eq(-1)
         expect(EventStore.redis.hget(client.snapshot_version_table, :current_version)).to eq(nil)
       end
@@ -27,7 +26,7 @@ module EventStore
       let(:client)    { EventStore::Client.new(AGGREGATE_ID_TWO) }
 
       before do
-        expect(client.snapshot.length).to eq(0)
+        expect(client.snapshot.count).to eq(0)
         client.append events_for(AGGREGATE_ID_TWO)
       end
 
@@ -49,14 +48,14 @@ module EventStore
         expected_snapshot = serialized_events(expected_snapshot_events)
         actual_snapshot = client.snapshot
 
-        expect(client.event_stream.length).to eq(15)
+        expect(client.event_stream.count).to eq(15)
         expect(actual_snapshot.map(&:fully_qualified_name)).to eq(expected_snapshot_events)
-        expect(actual_snapshot.length).to eq(8)
+        expect(actual_snapshot.count).to eq(8)
         expect(actual_snapshot.map(&:serialized_event)).to eq(expected_snapshot.map(&:serialized_event))
       end
 
       it "increments the version number of the snapshot when an event is appended" do
-        expect(client.snapshot.last.version).to eq(client.raw_event_stream.last[:version])
+        expect(client.snapshot.version).to eq(client.raw_event_stream.last[:version])
       end
     end
 

data/spec/unit/snapshot_unit_spec.rb

@@ -67,35 +67,34 @@ module EventStore
 
         it "stores a a new snapshot from the aggregate's events" do
           snapshot.rebuild_snapshot!
-          expect(snapshot.size).to eq(2)
+          expect(snapshot.count).to eq(2)
           # TODO: remove #snapshot in favor of Enumerable
-          names = snapshot.snapshot.map(&:fully_qualified_name)
+          names = snapshot.map(&:fully_qualified_name)
           expect(names).to eq(events.map { |e| e[:fully_qualified_name] })
         end
       end
 
       # TODO: remove this in favor of #each and include Enumerable
-      describe "#snapshot" do
-        let(:event_snapshot)   { snapshot.snapshot }
+      describe "events" do
         let(:serialized_attrs) { [ :fully_qualified_name,
                                    :serialized_event,
                                    :version,
                                    :occurred_at ] }
 
         it "contains SerializedEvents" do
-          event_snapshot.each { |e| expect(e).to be_a(SerializedEvent) }
+          snapshot.each { |e| expect(e).to be_a(SerializedEvent) }
         end
 
         it "corresponds to the events used to build the snapshot" do
           (serialized_attrs - [ :serialized_event ]).each { |attr|
-            expect(event_snapshot.first.send(attr)).to eq(first_event[attr])
-            expect(event_snapshot.last.send(attr)).to eq(last_event[attr])
+            expect(snapshot.first.send(attr)).to eq(first_event[attr])
+            expect(snapshot.last_event.send(attr)).to eq(last_event[attr])
           }
         end
 
         it "unescapes the serialized events" do
-          expected_event = EventStore.unescape_bytea(last_event[:serialized_event])
-          expect(event_snapshot.last.serialized_event).to eq(expected_event)
+          expected_event = EventStore.unescape_bytea(first_event[:serialized_event])
+          expect(snapshot.first.serialized_event).to eq(expected_event)
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nexia_event_store
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Paul Saieg, John Colvin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-23 00:00:00.000000000 Z
+date: 2015-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -273,7 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of an EventSource (A+ES) for the Nexia Ecosystem