ruby_event_store 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f95db0e815029c6c7fcd916acab4cafeed7b438
-  data.tar.gz: 009860a36cfcb176063d12f04b8dab1d5c23c1ab
+  metadata.gz: 029ad3dcd5fb3e1b025f0702bcb48cf0ed96e5cb
+  data.tar.gz: 958e78c130cc76ebffbfa341016f3f0673796d98
 SHA512:
-  metadata.gz: c9f1553586e1c380c8e11c3683bcd47e79c760b80ea962f295f689932164d75c32d75e1325e385aeacec32ef742063cbb1f8b820ff7eb4c8687565a1d7418ab5
-  data.tar.gz: d25334086e1afbdfe4c91576b083ec65a57b5b59b35915c3c126bb497559dfd965561cd9f327f6f472e68ebafc90c05ab6c35661de628e1bbe76016cbf0f9dad
+  metadata.gz: 9039b6d85500d4635fcc2331dcae5989defa2d8f6eda64f6f4f8e0e5b501a04f483f7f74705fe4a7a7ca69ed99164b9c1f16ec3a288216a4886cc15b535a776d
+  data.tar.gz: 96e7bc7166c8e0bd9b86277c273a90cd8643f07360b5dbf017087f3e00606fb66706f3a5c1005cf051345c382122ec0604d9248f78ae24b3817b28b1b15ff061

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+### HEAD
+
+### 0.3.0 (03.03.2016)
+
+* Change: read_all_streams won't group_by results by stream name PR #4
+* Change: new way of define attributes of domain event PR #5
+* Change: reading forward and backward, refactored facade interface #6
+* Change: in memory event repository is now part of the gem, with shared specification PR #7
+
+### 0.2.0 (27.01.2016)
+
+* Change: Return the event that the repository returns PR #2
+
+### 0.1.0 (26.05.2015)
+
+Initial version

data/lib/ruby_event_store/errors.rb

@@ -4,4 +4,6 @@ module RubyEventStore
   EventNotFound              = Class.new(StandardError)
   SubscriberNotExist         = Class.new(StandardError)
   MethodNotDefined           = Class.new(StandardError)
-end
+  InvalidPageStart           = Class.new(ArgumentError)
+  InvalidPageSize            = Class.new(ArgumentError)
+end

data/lib/ruby_event_store/event.rb

@@ -3,11 +3,15 @@ require 'securerandom'
 module RubyEventStore
   class Event
 
-    def initialize(event_data={})
-      @event_type = event_data.fetch(:event_type, event_name)
-      @event_id   = event_data.fetch(:event_id, generate_id).to_s
-      @metadata   = event_data.fetch(:metadata, {})
-      @data       = event_data.fetch(:data, {})
+    def initialize(**args)
+      attributes(args).each do |key, value|
+        singleton_class.__send__(:define_method, key) { value }
+      end
+
+      @event_type = args[:event_type] || event_name
+      @event_id   = (args[:event_id]  || generate_id).to_s
+      @metadata   = (args[:metadata]  || {}).merge!(timestamp)
+      @data       = attributes(args)
     end
     attr_reader :event_type, :event_id, :metadata, :data
 
@@ -15,15 +19,19 @@ module RubyEventStore
       {
           event_type: event_type,
           event_id:   event_id,
-          metadata:   metadata.merge!(publish_time),
+          metadata:   metadata,
           data:       data
       }
     end
 
     private
 
-    def publish_time
-      { published_at: Time.now.utc }
+    def attributes(args)
+      args.reject { |k| [:event_type, :event_id, :metadata].include? k }
+    end
+
+    def timestamp
+      { timestamp: Time.now.utc }
     end
 
     def generate_id

data/lib/ruby_event_store/facade.rb

@@ -1,29 +1,55 @@
 module RubyEventStore
   class Facade
-
     def initialize(repository)
       @repository = repository
     end
     attr_reader :repository
 
     def publish_event(event_data, stream_name = GLOBAL_STREAM, expected_version = nil)
-      append_event_to_stream(event_data, stream_name, expected_version)
+      event = append_to_stream(stream_name, event_data, expected_version)
+      event_broker.notify_subscribers(event)
+    end
+
+    def append_to_stream(stream_name, event_data, expected_version = nil)
+      raise WrongExpectedEventVersion if version_incorrect?(stream_name, expected_version)
+      repository.create(event_data, stream_name)
     end
 
     def delete_stream(stream_name)
-      delete_stream_events(stream_name)
+      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+      repository.delete_stream(stream_name)
+    end
+
+    def read_events_forward(stream_name, start, count)
+      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+      page = Page.new(repository, start, count)
+      repository.read_events_forward(stream_name, page.start, page.count)
+    end
+
+    def read_events_backward(stream_name, start, count)
+      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+      page = Page.new(repository, start, count)
+      repository.read_events_backward(stream_name, page.start, page.count)
+    end
+
+    def read_stream_events_forward(stream_name)
+      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+      repository.read_stream_events_forward(stream_name)
     end
 
-    def read_events(stream_name, start, count)
-      read_events_batch(stream_name, start, count)
+    def read_stream_events_backward(stream_name)
+      raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+      repository.read_stream_events_backward(stream_name)
     end
 
-    def read_all_events(stream_name)
-      read_all_stream_events(stream_name)
+    def read_all_streams_forward(start, count)
+      page = Page.new(repository, start, count)
+      repository.read_all_streams_forward(page.start, page.count)
     end
 
-    def read_all_streams
-      read_all_events_from_store
+    def read_all_streams_backward(start, count)
+      page = Page.new(repository, start, count)
+      repository.read_all_streams_backward(page.start, page.count)
     end
 
     def subscribe(subscriber, event_types)
@@ -36,29 +62,34 @@ module RubyEventStore
 
     private
 
-    def append_event_to_stream(event_data, stream_name, expected_version)
-      event = Actions::AppendEventToStream.new(repository).call(stream_name, event_data, expected_version)
-      event_broker.notify_subscribers(event)
-    end
-
-    def delete_stream_events(stream_name)
-      Actions::DeleteStreamEvents.new(repository).call(stream_name)
-    end
-
-    def read_events_batch(stream_name, start, count)
-      Actions::ReadEventsBatch.new(repository).call(stream_name, start, count)
+    class Page
+      def initialize(repository, start, count)
+        if start.instance_of?(Symbol)
+          raise InvalidPageStart unless [:head].include?(start)
+        else
+          start = start.to_s
+          raise InvalidPageStart if start.empty?
+          raise EventNotFound unless repository.has_event?(start)
+        end
+        raise InvalidPageSize unless count > 0
+        @start = start
+        @count = count
+      end
+      attr_reader :start, :count
     end
 
-    def read_all_stream_events(stream_name)
-      Actions::ReadAllEvents.new(repository).call(stream_name)
+    def event_broker
+      @event_broker ||= PubSub::Broker.new
     end
 
-    def read_all_events_from_store
-      Actions::ReadAllStreams.new(repository).call
+    def version_incorrect?(stream_name, expected_version)
+      unless expected_version.nil?
+        find_last_event_version(stream_name) != expected_version
+      end
     end
 
-    def event_broker
-      @event_broker ||= PubSub::Broker.new
+    def find_last_event_version(stream_name)
+      repository.last_stream_event(stream_name).event_id
     end
   end
-end
+end

data/lib/ruby_event_store/in_memory_repository.rb

@@ -0,0 +1,71 @@
+require 'ostruct'
+
+module RubyEventStore
+  class InMemoryRepository
+    def initialize
+      @all = Array.new
+      @streams = Hash.new
+    end
+
+    def create(event, stream_name)
+      stream = read_stream_events_forward(stream_name)
+      all.push(event)
+      stream.push(event)
+      streams[stream_name] = stream
+      event
+    end
+
+    def delete_stream(stream_name)
+      removed = read_stream_events_forward(stream_name).map(&:event_id)
+      streams.delete(stream_name)
+      all.delete_if{|ev| removed.include?(ev.event_id)}
+    end
+
+    def has_event?(event_id)
+      all.any?{ |item| item.event_id.eql?(event_id) }
+    end
+
+    def last_stream_event(stream_name)
+      read_stream_events_forward(stream_name).last
+    end
+
+    def read_events_forward(stream_name, start_event_id, count)
+      source = read_stream_events_forward(stream_name)
+      read_batch(source, start_event_id, count)
+    end
+
+    def read_events_backward(stream_name, start_event_id, count)
+      source = read_stream_events_backward(stream_name)
+      read_batch(source, start_event_id, count)
+    end
+
+    def read_stream_events_forward(stream_name)
+      streams[stream_name] || Array.new
+    end
+
+    def read_stream_events_backward(stream_name)
+      read_stream_events_forward(stream_name).reverse
+    end
+
+    def read_all_streams_forward(start_event_id, count)
+      read_batch(all, start_event_id, count)
+    end
+
+    def read_all_streams_backward(start_event_id, count)
+      read_batch(all.reverse, start_event_id, count)
+    end
+
+    private
+    attr_accessor :streams, :all
+
+    def read_batch(source, start_event_id, count)
+      return source[0..count-1] if start_event_id.equal?(:head)
+      start_index = index_of(source, start_event_id)
+      source[start_index+1..start_index+count]
+    end
+
+    def index_of(source, event_id)
+      source.index{ |item| item.event_id.eql?(event_id) }
+    end
+  end
+end

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -0,0 +1,105 @@
+RSpec.shared_examples :event_repository do |repository_class|
+  TestDomainEvent = Class.new(RubyEventStore::Event)
+  subject(:repository)  { repository_class.new }
+
+  it 'just created is empty' do
+    expect(repository.read_all_streams_forward(:head, 1)).to be_empty
+  end
+
+  it 'what you get is what you gave' do
+    created = repository.create(event = TestDomainEvent.new, 'stream')
+    expect(created.object_id).to eq event.object_id
+  end
+
+  it 'created event is stored in given stream' do
+    expected_event = {event_type: 'TestDomainEvent', data: {}}
+    created = repository.create(TestDomainEvent.new, 'stream')
+    expect_to_be_like_event(created, expected_event)
+    expect_to_be_like_event(repository.read_all_streams_forward(:head, 1).first, expected_event)
+    expect_to_be_like_event(repository.read_stream_events_forward('stream').first, expected_event)
+    expect(repository.read_stream_events_forward('other_stream')).to be_empty
+  end
+
+  it 'does not have deleted streams' do
+    repository.create(TestDomainEvent.new, 'stream')
+    repository.create(TestDomainEvent.new, 'other_stream')
+
+    expect(repository.read_stream_events_forward('stream').count).to eq 1
+    expect(repository.read_stream_events_forward('other_stream').count).to eq 1
+    expect(repository.read_all_streams_forward(:head, 10).count).to eq 2
+
+    repository.delete_stream('stream')
+    expect(repository.read_stream_events_forward('stream')).to be_empty
+    expect(repository.read_stream_events_forward('other_stream').count).to eq 1
+    expect(repository.read_all_streams_forward(:head, 10).count).to eq 1
+  end
+
+  it 'has or has not domain event' do
+    repository.create(TestDomainEvent.new(event_id: 'just an id'), 'stream')
+
+    expect(repository.has_event?('just an id')).to be_truthy
+    expect(repository.has_event?('any other id')).to be_falsey
+  end
+
+  it 'knows last event in stream' do
+    repository.create(TestDomainEvent.new(event_id: 'event 1'), 'stream')
+    repository.create(TestDomainEvent.new(event_id: 'event 2'), 'stream')
+
+    expect(repository.last_stream_event('stream').event_id).to eq('event 2')
+    expect(repository.last_stream_event('other_stream')).to be_nil
+  end
+
+  it 'reads batch of events from stream forward & backward' do
+    event_ids = (1..10).to_a.map(&:to_s)
+    event_ids.each do |id|
+      repository.create(TestDomainEvent.new(event_id: id), 'stream')
+    end
+
+    expect(repository.read_events_forward('stream', :head, 3).map(&:event_id)).to eq ['1','2','3']
+    expect(repository.read_events_forward('stream', :head, 100).map(&:event_id)).to eq event_ids
+    expect(repository.read_events_forward('stream', '5', 4).map(&:event_id)).to eq ['6','7','8','9']
+    expect(repository.read_events_forward('stream', '5', 100).map(&:event_id)).to eq ['6','7','8','9','10']
+
+    expect(repository.read_events_backward('stream', :head, 3).map(&:event_id)).to eq ['10','9','8']
+    expect(repository.read_events_backward('stream', :head, 100).map(&:event_id)).to eq event_ids.reverse
+    expect(repository.read_events_backward('stream', '5', 4).map(&:event_id)).to eq ['4','3','2','1']
+    expect(repository.read_events_backward('stream', '5', 100).map(&:event_id)).to eq ['4','3','2','1']
+  end
+
+
+  it 'reads all stream events forward & backward' do
+    repository.create(TestDomainEvent.new(event_id: '1'), 'stream')
+    repository.create(TestDomainEvent.new(event_id: '2'), 'other_stream')
+    repository.create(TestDomainEvent.new(event_id: '3'), 'stream')
+    repository.create(TestDomainEvent.new(event_id: '4'), 'other_stream')
+    repository.create(TestDomainEvent.new(event_id: '5'), 'other_stream')
+
+    expect(repository.read_stream_events_forward('stream').map(&:event_id)).to eq ['1','3']
+    expect(repository.read_stream_events_backward('stream').map(&:event_id)).to eq ['3','1']
+  end
+
+  it 'reads batch of events from all streams forward & backward' do
+    event_ids = (1..10).to_a.map(&:to_s)
+    event_ids.each do |id|
+      repository.create(TestDomainEvent.new(event_id: id), SecureRandom.uuid)
+    end
+
+    expect(repository.read_all_streams_forward(:head, 3).map(&:event_id)).to eq ['1','2','3']
+    expect(repository.read_all_streams_forward(:head, 100).map(&:event_id)).to eq event_ids
+    expect(repository.read_all_streams_forward('5', 4).map(&:event_id)).to eq ['6','7','8','9']
+    expect(repository.read_all_streams_forward('5', 100).map(&:event_id)).to eq ['6','7','8','9','10']
+
+    expect(repository.read_all_streams_backward(:head, 3).map(&:event_id)).to eq ['10','9','8']
+    expect(repository.read_all_streams_backward(:head, 100).map(&:event_id)).to eq event_ids.reverse
+    expect(repository.read_all_streams_backward('5', 4).map(&:event_id)).to eq ['4','3','2','1']
+    expect(repository.read_all_streams_backward('5', 100).map(&:event_id)).to eq ['4','3','2','1']
+  end
+
+  private
+
+  def expect_to_be_like_event(actual, expected)
+    expect(actual.event_type).to eq expected[:event_type]
+    expect(actual.data).to eq expected[:data]
+    if expected.key? :event_id then expect(actual.event_id).to eq expected[:event_id] else true end
+  end
+end

data/lib/ruby_event_store/version.rb

@@ -1,3 +1,3 @@
 module RubyEventStore
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/ruby_event_store.rb

@@ -1,9 +1,5 @@
-require 'ruby_event_store/actions/append_event_to_stream'
-require 'ruby_event_store/actions/read_all_events'
-require 'ruby_event_store/actions/read_events_batch'
-require 'ruby_event_store/actions/delete_stream_events'
-require 'ruby_event_store/actions/read_all_streams'
 require 'ruby_event_store/pub_sub/broker'
+require 'ruby_event_store/in_memory_repository'
 require 'ruby_event_store/errors'
 require 'ruby_event_store/constants'
 require 'ruby_event_store/facade'

data/ruby_event_store.gemspec

@@ -9,9 +9,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ["rybex", "mpraglowski"]
   spec.email         = ["tomek.rybka@gmail.com", "m@praglowski.com"]
 
-  spec.summary       = %q{Implementation of Event Store in Ruby}
+  spec.summary       = %q{Event Store in Ruby}
   spec.description   = %q{Implementation of Event Store in Ruby}
-  spec.homepage      = ''
+  spec.homepage      = 'https://github.com/arkency/ruby_event_store'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.8"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec', "~> 3.2"
+  spec.add_development_dependency 'pry', "~> 0"
   spec.add_development_dependency 'mutant-rspec', '~> 0.7.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - rybex
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-27 00:00:00.000000000 Z
+date: 2016-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,28 +43,28 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -91,23 +91,21 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
 - lib/ruby_event_store.rb
-- lib/ruby_event_store/actions/append_event_to_stream.rb
-- lib/ruby_event_store/actions/delete_stream_events.rb
-- lib/ruby_event_store/actions/read_all_events.rb
-- lib/ruby_event_store/actions/read_all_streams.rb
-- lib/ruby_event_store/actions/read_events_batch.rb
 - lib/ruby_event_store/constants.rb
 - lib/ruby_event_store/errors.rb
 - lib/ruby_event_store/event.rb
 - lib/ruby_event_store/facade.rb
+- lib/ruby_event_store/in_memory_repository.rb
 - lib/ruby_event_store/pub_sub/broker.rb
+- lib/ruby_event_store/spec/event_repository_lint.rb
 - lib/ruby_event_store/version.rb
 - ruby_event_store.gemspec
-homepage: ''
+homepage: https://github.com/arkency/ruby_event_store
 licenses: []
 metadata: {}
 post_install_message: 
@@ -126,8 +124,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.5
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
-summary: Implementation of Event Store in Ruby
+summary: Event Store in Ruby
 test_files: []

data/lib/ruby_event_store/actions/append_event_to_stream.rb

@@ -1,32 +0,0 @@
-module RubyEventStore
-  module Actions
-    class AppendEventToStream
-
-      def initialize(repository)
-        @repository = repository
-      end
-
-      def call(stream_name, event, expected_version)
-        raise WrongExpectedEventVersion if version_incorrect?(stream_name, expected_version)
-        save_event(event, stream_name)
-      end
-
-      private
-      attr_reader :repository
-
-      def version_incorrect?(stream_name, expected_version)
-        unless expected_version.nil?
-          find_last_event_version(stream_name) != expected_version
-        end
-      end
-
-      def find_last_event_version(stream_name)
-        repository.last_stream_event(stream_name).event_id
-      end
-
-      def save_event(event, stream_name)
-        repository.create(event.to_h.merge!(stream: stream_name))
-      end
-    end
-  end
-end

data/lib/ruby_event_store/actions/delete_stream_events.rb

@@ -1,23 +0,0 @@
-module RubyEventStore
-  module Actions
-    class DeleteStreamEvents
-
-      def initialize(repository)
-        @repository = repository
-      end
-
-      def call(stream_name)
-        raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-        delete_stream(stream_name)
-      end
-
-      private
-      attr_reader :repository
-
-      def delete_stream(stream_name)
-        repository.delete({stream: stream_name})
-      end
-    end
-  end
-end
-

data/lib/ruby_event_store/actions/read_all_events.rb

@@ -1,22 +0,0 @@
-module RubyEventStore
-  module Actions
-    class ReadAllEvents
-
-      def initialize(repository)
-        @repository = repository
-      end
-
-      def call(stream_name)
-        raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-        get_all_events(stream_name)
-      end
-
-      private
-      attr_reader :repository
-
-      def get_all_events(stream_name)
-        repository.load_all_events_forward(stream_name)
-      end
-    end
-  end
-end

data/lib/ruby_event_store/actions/read_all_streams.rb

@@ -1,21 +0,0 @@
-module RubyEventStore
-  module Actions
-    class ReadAllStreams
-
-      def initialize(repository)
-        @repository = repository
-      end
-
-      def call
-        get_all_events.group_by { |event| event.stream }
-      end
-
-      private
-      attr_reader :repository
-
-      def get_all_events
-        repository.get_all_events
-      end
-    end
-  end
-end

data/lib/ruby_event_store/actions/read_events_batch.rb

@@ -1,29 +0,0 @@
-module RubyEventStore
-  module Actions
-    class ReadEventsBatch
-
-      def initialize(repository)
-        @repository = repository
-      end
-
-      def call(stream_name, start, count)
-        raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-        event = find_event(start)
-        get_events_batch(stream_name, event.id, count)
-      end
-
-      private
-      attr_reader :repository
-
-      def get_events_batch(stream_name, start, count)
-        repository.load_events_batch(stream_name, start, count)
-      end
-
-      def find_event(start)
-        event = repository.find({event_id: start})
-        raise EventNotFound if event.nil?
-        event
-      end
-    end
-  end
-end