ruby_event_store 0.30.0 → 0.31.0

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -0,0 +1,76 @@
+RSpec.shared_examples :broker do |broker_klass|
+  let(:event) { instance_double(::RubyEventStore::Event, type: 'EventType') }
+  let(:serialized_event) { instance_double(::RubyEventStore::SerializedRecord)  }
+  let(:handler) { HandlerClass.new }
+  let(:subscriptions) { ::RubyEventStore::PubSub::Subscriptions.new }
+  let(:dispatcher) { ::RubyEventStore::PubSub::Dispatcher.new }
+  let(:broker) { broker_klass.new(subscriptions: subscriptions, dispatcher: dispatcher) }
+
+  specify "no dispatch when no subscriptions" do
+    expect(subscriptions).to receive(:all_for).with('EventType').and_return([])
+    expect(dispatcher).not_to receive(:call)
+    broker.call(event, serialized_event)
+  end
+
+  specify "calls subscription" do
+    expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler])
+    expect(dispatcher).to receive(:call).with(handler, event, serialized_event)
+    broker.call(event, serialized_event)
+  end
+
+  specify "calls subscribed class" do
+    expect(subscriptions).to receive(:all_for).with('EventType').and_return([HandlerClass])
+    expect(dispatcher).to receive(:call).with(HandlerClass, event, serialized_event)
+    broker.call(event, serialized_event)
+  end
+
+  specify "calls all subscriptions" do
+    expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler, HandlerClass])
+    expect(dispatcher).to receive(:call).with(handler, event, serialized_event)
+    expect(dispatcher).to receive(:call).with(HandlerClass, event, serialized_event)
+    broker.call(event, serialized_event)
+  end
+
+  specify 'raise error when no subscriber' do
+    expect { broker.add_subscription(nil, [])}.to raise_error(RubyEventStore::SubscriberNotExist, "subscriber must be first argument or block")
+    expect { broker.add_global_subscription(nil)}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
+    expect { broker.add_thread_subscription(nil, []).call}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
+    expect { broker.add_thread_global_subscription(nil).call}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
+  end
+
+  specify "verify and add - local subscriptions" do
+    expect(dispatcher).to receive(:verify).with(handler)
+    expect(subscriptions).to receive(:add_subscription).with(handler, ['EventType'])
+    broker.add_subscription(handler, ['EventType'])
+  end
+
+  specify "verify and add - global subscriptions" do
+    expect(dispatcher).to receive(:verify).with(handler)
+    expect(subscriptions).to receive(:add_global_subscription).with(handler)
+    broker.add_global_subscription(handler)
+  end
+
+  specify "verify and add - thread local subscriptions" do
+    expect(dispatcher).to receive(:verify).with(handler)
+    expect(subscriptions).to receive(:add_thread_subscription).with(handler, ['EventType'])
+    broker.add_thread_subscription(handler, ['EventType'])
+  end
+
+  specify "verify and add - thread global subscriptions" do
+    expect(dispatcher).to receive(:verify).with(handler)
+    expect(subscriptions).to receive(:add_thread_global_subscription).with(handler)
+    broker.add_thread_global_subscription(handler)
+  end
+
+  private
+
+  class HandlerClass
+    @@received = nil
+    def self.received
+      @@received
+    end
+    def call(event)
+      @@received = event
+    end
+  end
+end

data/lib/ruby_event_store/spec/dispatcher_lint.rb

@@ -1,18 +1,17 @@
 RSpec.shared_examples :dispatcher do |dispatcher|
-  specify "calls subscribed instance" do
-    handler = HandlerClass.new
-    event   = instance_double(::RubyEventStore::Event)
+  let(:event) { instance_double(::RubyEventStore::Event) }
+  let(:serialized_event) { instance_double(::RubyEventStore::SerializedRecord)  }
+  let(:handler) { HandlerClass.new }
 
+  specify "calls subscribed instance" do
     expect(handler).to receive(:call).with(event)
-    dispatcher.(handler, event)
+    dispatcher.call(handler, event, serialized_event)
   end
 
   specify "calls subscribed class" do
-    event   = instance_double(::RubyEventStore::Event)
-
-    expect(HandlerClass).to receive(:new).and_return( h = HandlerClass.new )
-    expect(h).to receive(:call).with(event)
-    dispatcher.(HandlerClass, event)
+    expect(HandlerClass).to receive(:new).and_return(handler)
+    expect(handler).to receive(:call).with(event)
+    dispatcher.call(HandlerClass, event, serialized_event)
   end
 
   specify "allows callable classes and instances" do

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -1,3 +1,4 @@
+# @private
 class SRecord
   def self.new(
     event_id:   SecureRandom.uuid,

data/lib/ruby_event_store/spec/subscriptions_lint.rb

@@ -0,0 +1,111 @@
+RSpec.shared_examples :subscriptions do |subscriptions_class|
+  Test1DomainEvent = Class.new(RubyEventStore::Event)
+  Test2DomainEvent = Class.new(RubyEventStore::Event)
+  Test3DomainEvent = Class.new(RubyEventStore::Event)
+
+  class TestHandler
+    def initialize
+      @events = []
+    end
+
+    def call(event)
+      @events << event
+    end
+
+    attr_reader :events
+  end
+
+  subject(:subscriptions) { subscriptions_class.new }
+
+  it 'returns all subscribed handlers' do
+    handler         = TestHandler.new
+    another_handler = TestHandler.new
+    global_handler  = TestHandler.new
+
+    subscriptions.add_subscription(handler, [Test1DomainEvent, Test3DomainEvent])
+    subscriptions.add_subscription(another_handler, [Test2DomainEvent])
+    subscriptions.add_global_subscription(global_handler)
+
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler, global_handler])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([another_handler, global_handler])
+    expect(subscriptions.all_for('Test3DomainEvent')).to eq([handler, global_handler])
+  end
+
+  it 'returns subscribed thread handlers' do
+    handler         = TestHandler.new
+    another_handler = TestHandler.new
+    global_handler  = TestHandler.new
+
+    subscriptions.add_thread_subscription(handler, [Test1DomainEvent, Test3DomainEvent])
+    subscriptions.add_thread_subscription(another_handler, [Test2DomainEvent])
+    subscriptions.add_thread_global_subscription(global_handler)
+
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([global_handler, handler])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([global_handler, another_handler])
+    expect(subscriptions.all_for('Test3DomainEvent')).to eq([global_handler, handler])
+  end
+
+  it 'returns lambda as an output of global subscribe methods' do
+    handler   = TestHandler.new
+    result = subscriptions.add_global_subscription(handler)
+    expect(result).to respond_to(:call)
+  end
+
+  it 'returns lambda as an output of subscribe methods' do
+    handler   = TestHandler.new
+    result    = subscriptions.add_subscription(handler, [Test1DomainEvent, Test2DomainEvent])
+    expect(result).to respond_to(:call)
+  end
+
+  it 'revokes global subscription' do
+    handler   = TestHandler.new
+
+    revoke    = subscriptions.add_global_subscription(handler)
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([handler])
+    revoke.()
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([])
+  end
+
+  it 'revokes subscription' do
+    handler   = TestHandler.new
+
+    revoke    = subscriptions.add_subscription(handler, [Test1DomainEvent, Test2DomainEvent])
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([handler])
+    revoke.()
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([])
+  end
+
+  it 'revokes thread global subscription' do
+    handler   = TestHandler.new
+
+    revoke    = subscriptions.add_thread_global_subscription(handler)
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([handler])
+    revoke.()
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([])
+  end
+
+  it 'revokes thread subscription' do
+    handler           = TestHandler.new
+
+    revoke    = subscriptions.add_thread_subscription(handler, [Test1DomainEvent, Test2DomainEvent])
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([handler])
+    revoke.()
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([])
+    expect(subscriptions.all_for('Test2DomainEvent')).to eq([])
+  end
+
+  it 'subscribes by type of event which is a String' do
+    handler         = TestHandler.new
+    subscriptions.add_subscription(handler, ["Test1DomainEvent"])
+    subscriptions.add_thread_subscription(handler, ["Test1DomainEvent"])
+
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler, handler])
+  end
+end

data/lib/ruby_event_store/specification.rb

@@ -1,6 +1,12 @@
 module RubyEventStore
+
+  # Used for building and executing the query specification.
   class Specification
+    # @private
+    # @api private
     NO_LIMIT = Object.new.freeze
+    # @private
+    # @api private
     NO_BATCH = Object.new.freeze
     DEFAULT_BATCH_SIZE = 100
 
@@ -35,18 +41,34 @@ module RubyEventStore
     end
     private_constant :Result
 
+    # @api private
+    # @private
     attr_reader :result
 
+    # @api private
+    # @private
     def initialize(repository, mapper, result = Result.new(:forward, :head, NO_LIMIT, Stream.new(GLOBAL_STREAM), NO_BATCH))
       @mapper = mapper
       @repository  = repository
       @result = result
     end
 
+    # Limits the query to certain stream.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param stream_name [String] name of the stream to get events from
+    # @return [Specification]
     def stream(stream_name)
       Specification.new(repository, mapper, result.dup.tap { |r| r.stream = Stream.new(stream_name) })
     end
 
+    # Limits the query to events before or after another event.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param start [:head, String] id of event to start reading from.
+    #   :head can mean the beginning or end of the stream, depending on the
+    #   #direction
+    # @return [Specification]
     def from(start)
       case start
       when Symbol
@@ -58,19 +80,38 @@ module RubyEventStore
       Specification.new(repository, mapper, result.dup.tap { |r| r.start = start })
     end
 
+    # Sets the order of reading events to ascending (forward from the start).
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Specification]
     def forward
       Specification.new(repository, mapper, result.dup.tap { |r| r.direction = :forward })
     end
 
+    # Sets the order of reading events to descending (backward from the start).
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Specification]
     def backward
       Specification.new(repository, mapper, result.dup.tap { |r| r.direction = :backward })
     end
 
+    # Limits the query to specified number of events.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param count [Integer] maximal number of events to retrieve
+    # @return [Specification]
     def limit(count)
       raise InvalidPageSize unless count && count > 0
       Specification.new(repository, mapper, result.dup.tap { |r| r.count = count })
     end
 
+    # Executes the query based on the specification built up to this point.
+    # Yields each batch of records that was retrieved from the store.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @yield [Array<Event, Proto>] batch of events
+    # @return [Enumerator, nil] Enumerator is returned when block not given
     def each_batch
       return to_enum(:each_batch) unless block_given?
 
@@ -80,6 +121,12 @@ module RubyEventStore
       end
     end
 
+    # Executes the query based on the specification built up to this point.
+    # Yields events read from the store if block given. Otherwise, returns enumerable collection.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @yield [Event, Proto] event
+    # @return [Enumerator, nil] Enumerator is returned when block not given
     def each
       return to_enum unless block_given?
 
@@ -88,6 +135,19 @@ module RubyEventStore
       end
     end
 
+    # Specifies that events should be obtained in batches.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # Looping through a collection of events from the store
+    # can be inefficient since it will try to instantiate all
+    # the events at once.
+    #
+    # In that case, batch processing methods allow you to work
+    # with the records in batches, thereby greatly reducing
+    # memory consumption.
+    #
+    # @param batch_size [Integer] number of events to read in a single batch
+    # @return [Specification]
     def in_batches(batch_size = DEFAULT_BATCH_SIZE)
       Specification.new(repository, mapper, result.dup.tap { |r| r.batch_size = batch_size })
     end

data/lib/ruby_event_store/version.rb

@@ -1,3 +1,3 @@
 module RubyEventStore
-  VERSION = "0.30.0"
+  VERSION = "0.31.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-31 00:00:00.000000000 Z
+date: 2018-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -150,9 +150,12 @@ files:
 - README.md
 - exe/res-deprecated-read-api-migrator
 - lib/ruby_event_store.rb
+- lib/ruby_event_store/async_dispatcher.rb
+- lib/ruby_event_store/async_proxy_strategy.rb
 - lib/ruby_event_store/batch_enumerator.rb
 - lib/ruby_event_store/client.rb
 - lib/ruby_event_store/constants.rb
+- lib/ruby_event_store/correlated_commands.rb
 - lib/ruby_event_store/deprecated_read_api_rewriter.rb
 - lib/ruby_event_store/deprecated_read_api_runner.rb
 - lib/ruby_event_store/deprecations.rb
@@ -160,6 +163,7 @@ files:
 - lib/ruby_event_store/event.rb
 - lib/ruby_event_store/expected_version.rb
 - lib/ruby_event_store/in_memory_repository.rb
+- lib/ruby_event_store/link_by_metadata.rb
 - lib/ruby_event_store/mappers/default.rb
 - lib/ruby_event_store/mappers/null_mapper.rb
 - lib/ruby_event_store/mappers/protobuf.rb
@@ -167,10 +171,12 @@ files:
 - lib/ruby_event_store/projection.rb
 - lib/ruby_event_store/pub_sub/broker.rb
 - lib/ruby_event_store/pub_sub/dispatcher.rb
+- lib/ruby_event_store/pub_sub/subscriptions.rb
 - lib/ruby_event_store/serialized_record.rb
+- lib/ruby_event_store/spec/broker_lint.rb
 - lib/ruby_event_store/spec/dispatcher_lint.rb
-- lib/ruby_event_store/spec/event_broker_lint.rb
 - lib/ruby_event_store/spec/event_repository_lint.rb
+- lib/ruby_event_store/spec/subscriptions_lint.rb
 - lib/ruby_event_store/specification.rb
 - lib/ruby_event_store/stream.rb
 - lib/ruby_event_store/version.rb

data/lib/ruby_event_store/spec/event_broker_lint.rb

@@ -1,211 +0,0 @@
-RSpec.shared_examples :event_broker do |broker_class|
-  Test1DomainEvent = Class.new(RubyEventStore::Event)
-  Test2DomainEvent = Class.new(RubyEventStore::Event)
-  Test3DomainEvent = Class.new(RubyEventStore::Event)
-
-  class InvalidTestHandler
-  end
-  class TestHandler
-    def initialize
-      @events = []
-    end
-
-    def call(event)
-      @events << event
-    end
-
-    attr_reader :events
-  end
-  class TestDispatcher
-    attr_reader :dispatched
-
-    def initialize
-      @dispatched = []
-    end
-
-    def verify(_subscriber)
-    end
-
-    def call(subscriber, event)
-      @dispatched << {subscriber: subscriber, event: event}
-    end
-  end
-
-  subject(:broker) { broker_class.new }
-
-  it 'raise error when no subscriber' do
-    expect { broker.add_subscriber(nil, [])}.to raise_error(RubyEventStore::SubscriberNotExist)
-    expect { broker.add_thread_subscriber(nil, [])}.to raise_error(RubyEventStore::SubscriberNotExist)
-    expect { broker.add_global_subscriber(nil)}.to raise_error(RubyEventStore::SubscriberNotExist)
-    expect { broker.add_thread_global_subscriber(nil)}.to raise_error(RubyEventStore::SubscriberNotExist)
-  end
-
-  it 'notifies subscribed handlers' do
-    handler         = TestHandler.new
-    another_handler = TestHandler.new
-    global_handler  = TestHandler.new
-
-    broker.add_subscriber(handler, [Test1DomainEvent, Test3DomainEvent])
-    broker.add_subscriber(another_handler, [Test2DomainEvent])
-    broker.add_global_subscriber(global_handler)
-
-    event1 = Test1DomainEvent.new
-    event2 = Test2DomainEvent.new
-    event3 = Test3DomainEvent.new
-
-    [event1, event2, event3].each do |ev|
-      broker.notify_subscribers(ev)
-    end
-
-    expect(handler.events).to eq([event1,event3])
-    expect(another_handler.events).to eq([event2])
-    expect(global_handler.events).to eq([event1,event2,event3])
-  end
-
-  it 'notifies subscribed thread handlers' do
-    handler         = TestHandler.new
-    another_handler = TestHandler.new
-    global_handler  = TestHandler.new
-
-    broker.add_thread_subscriber(handler, [Test1DomainEvent, Test3DomainEvent])
-    broker.add_thread_subscriber(another_handler, [Test2DomainEvent])
-    broker.add_thread_global_subscriber(global_handler)
-
-    event1 = Test1DomainEvent.new
-    event2 = Test2DomainEvent.new
-    event3 = Test3DomainEvent.new
-
-    [event1, event2, event3].each do |ev|
-      broker.notify_subscribers(ev)
-    end
-
-    expect(handler.events).to eq([event1,event3])
-    expect(another_handler.events).to eq([event2])
-    expect(global_handler.events).to eq([event1,event2,event3])
-  end
-
-  it 'raises error when no valid method on handler' do
-    subscriber = InvalidTestHandler.new
-    expect do
-      broker.add_subscriber(subscriber, [Test1DomainEvent])
-    end.to raise_error(RubyEventStore::InvalidHandler)
-  end
-
-  it 'raises error when no valid method on global handler' do
-    subscriber = InvalidTestHandler.new
-    expect do
-      broker.add_global_subscriber(subscriber)
-    end.to raise_error(RubyEventStore::InvalidHandler)
-  end
-
-  it 'raises error when no valid method on thread handler' do
-    subscriber = InvalidTestHandler.new
-    expect do
-      broker.add_thread_subscriber(subscriber, [Test1DomainEvent])
-    end.to raise_error(RubyEventStore::InvalidHandler)
-  end
-
-  it 'raises error when no valid method on global thread handler' do
-    subscriber = InvalidTestHandler.new
-    expect do
-      broker.add_thread_global_subscriber(subscriber)
-    end.to raise_error(RubyEventStore::InvalidHandler)
-  end
-
-  it 'returns lambda as an output of global subscribe methods' do
-    handler   = TestHandler.new
-    result = broker.add_global_subscriber(handler)
-    expect(result).to respond_to(:call)
-  end
-
-  it 'returns lambda as an output of subscribe methods' do
-    handler   = TestHandler.new
-    result    = broker.add_subscriber(handler, [Test1DomainEvent, Test2DomainEvent])
-    expect(result).to respond_to(:call)
-  end
-
-  it 'revokes global subscription' do
-    handler   = TestHandler.new
-    event1    = Test1DomainEvent.new
-    event2    = Test2DomainEvent.new
-
-    revoke    = broker.add_global_subscriber(handler)
-    broker.notify_subscribers(event1)
-    expect(handler.events).to eq([event1])
-    revoke.()
-    broker.notify_subscribers(event2)
-    expect(handler.events).to eq([event1])
-  end
-
-  it 'revokes subscription' do
-    handler   = TestHandler.new
-    event1    = Test1DomainEvent.new
-    event2    = Test2DomainEvent.new
-
-    revoke    = broker.add_subscriber(handler, [Test1DomainEvent, Test2DomainEvent])
-    broker.notify_subscribers(event1)
-    expect(handler.events).to eq([event1])
-    revoke.()
-    broker.notify_subscribers(event2)
-    expect(handler.events).to eq([event1])
-  end
-
-  it 'revokes thread global subscription' do
-    handler   = TestHandler.new
-    event1    = Test1DomainEvent.new
-    event2    = Test2DomainEvent.new
-
-    revoke    = broker.add_thread_global_subscriber(handler)
-    broker.notify_subscribers(event1)
-    expect(handler.events).to eq([event1])
-    revoke.()
-    broker.notify_subscribers(event2)
-    expect(handler.events).to eq([event1])
-  end
-
-  it 'revokes thread subscription' do
-    handler   = TestHandler.new
-    event1    = Test1DomainEvent.new
-    event2    = Test2DomainEvent.new
-
-    revoke    = broker.add_thread_subscriber(handler, [Test1DomainEvent, Test2DomainEvent])
-    broker.notify_subscribers(event1)
-    expect(handler.events).to eq([event1])
-    revoke.()
-    broker.notify_subscribers(event2)
-    expect(handler.events).to eq([event1])
-  end
-
-  it 'allows to provide a custom dispatcher' do
-    dispatcher  = TestDispatcher.new
-    handler     = TestHandler.new
-    event1      = Test1DomainEvent.new
-    broker_with_custom_dispatcher = broker_class.new(dispatcher: dispatcher)
-    broker_with_custom_dispatcher.add_subscriber(handler, [Test1DomainEvent])
-    broker_with_custom_dispatcher.notify_subscribers(event1)
-    expect(dispatcher.dispatched).to eq([{subscriber: handler, event: event1}])
-  end
-
-  it 'subscribes by type of event which is a String' do
-    handler         = TestHandler.new
-    broker.add_subscriber(handler, ["Test1DomainEvent"])
-    broker.add_thread_subscriber(handler, ["Test1DomainEvent"])
-
-    event1 = Test1DomainEvent.new
-    broker.notify_subscribers(event1)
-
-    expect(handler.events).to eq([event1,event1])
-  end
-
-  private
-
-  class HandlerClass
-    @@received = nil
-    def self.received
-      @@received
-    end
-    def call(event)
-      @@received = event
-    end
-  end
-end