ruby_event_store 0.30.0 → 1.3.1

data/lib/ruby_event_store/spec/mapper_lint.rb

@@ -0,0 +1,17 @@
+module RubyEventStore
+  RSpec.shared_examples :mapper do |mapper, domain_event|
+    specify "event_to_serialized_record returns instance of SerializedRecord" do
+      record = mapper.event_to_serialized_record(domain_event)
+
+      expect(record).to            be_kind_of(SerializedRecord)
+      expect(record.event_id).to   eq(domain_event.event_id)
+      expect(record.event_type).to eq(domain_event.event_type)
+    end
+
+    specify "serialize and deserialize gives equal event" do
+      record = mapper.event_to_serialized_record(domain_event)
+
+      expect(mapper.serialized_record_to_event(record)).to eq(domain_event)
+    end
+  end
+end

data/lib/ruby_event_store/spec/scheduler_lint.rb

@@ -0,0 +1,9 @@
+RSpec.shared_examples :scheduler do |scheduler|
+  specify "#call" do
+    expect(scheduler).to respond_to(:call).with(2).arguments
+  end
+
+  specify "#verify" do
+    expect(scheduler).to respond_to(:verify).with(1).argument
+  end
+end

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,85 +1,94 @@
+# frozen_string_literal: true
+
 module RubyEventStore
+
+  # Used for building and executing the query specification.
   class Specification
-    NO_LIMIT = Object.new.freeze
-    NO_BATCH = Object.new.freeze
     DEFAULT_BATCH_SIZE = 100
-
-    class Result < Struct.new(:direction, :start, :count, :stream, :batch_size)
-      def limit?
-        !count.equal?(NO_LIMIT)
-      end
-
-      def global_stream?
-        stream.global?
-      end
-
-      def stream_name
-        stream.name
-      end
-
-      def head?
-        start.equal?(:head)
-      end
-
-      def forward?
-        direction.equal?(:forward)
-      end
-
-      def backward?
-        !forward?
-      end
-
-      def batched?
-        !batch_size.equal?(NO_BATCH)
-      end
-    end
-    private_constant :Result
-
-    attr_reader :result
-
-    def initialize(repository, mapper, result = Result.new(:forward, :head, NO_LIMIT, Stream.new(GLOBAL_STREAM), NO_BATCH))
-      @mapper = mapper
-      @repository  = repository
+    # @api private
+    # @private
+    def initialize(reader, result = SpecificationResult.new)
+      @reader = reader
       @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) })
+      Specification.new(reader, result.dup { |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 [String] id of event to start reading from.
+    # @return [Specification]
     def from(start)
-      case start
-      when Symbol
-        raise InvalidPageStart unless [:head].include?(start)
-      else
-        raise InvalidPageStart if start.nil? || start.empty?
-        raise EventNotFound.new(start) unless repository.has_event?(start)
-      end
-      Specification.new(repository, mapper, result.dup.tap { |r| r.start = start })
+      raise InvalidPageStart if start.nil? || start.empty?
+      raise EventNotFound.new(start) unless reader.has_event?(start)
+      Specification.new(reader, result.dup { |r| r.start = start })
+    end
+
+    # Limits the query to events before or after another event.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param start [String] id of event to start reading from.
+    # @return [Specification]
+    def to(stop)
+      raise InvalidPageStop if stop.nil? || stop.empty?
+      raise EventNotFound.new(stop) unless reader.has_event?(stop)
+      Specification.new(reader, result.dup { |r| r.stop = stop })
     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 })
+      Specification.new(reader, result.dup { |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 })
+      Specification.new(reader, result.dup { |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 })
+      Specification.new(reader, result.dup { |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?
 
-      result_  = result.batched? ? result : result.tap { |r| r.batch_size = DEFAULT_BATCH_SIZE }
-      repository.read(result_).each do |batch|
-        yield batch.map { |serialized_record| mapper.serialized_record_to_event(serialized_record) }
+      reader.each(in_batches(result.batch_size).result) do |batch|
+        yield batch
       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,12 +97,148 @@ module RubyEventStore
       end
     end
 
+    # Executes the query based on the specification built up to this point
+    # and maps the result using provided block.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Array] of mapped result
+    def map(&block)
+      raise ArgumentError.new("Block must be given") unless block_given?
+      each.map(&block)
+    end
+
+    # Reduces the results of the query based on the specification
+    # built up to this point result using provided block.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @accumulator starting state for reduce operation
+    # @return reduce result as defined by block given
+    def reduce(accumulator = nil, &block)
+      raise ArgumentError.new("Block must be given") unless block_given?
+      each.reduce(accumulator, &block)
+    end
+
+    # Calculates the size of result set based on the specification build up to this point.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Integer] Number of events to read
+    def count
+      reader.count(result)
+    end
+
+    # Executes the query based on the specification built up to this point.
+    # Returns array of domain events.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Array<Event, Proto>]
+    def to_a
+      each.to_a
+    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 })
+      Specification.new(reader, result.dup { |r| r.read_as = :batch; r.batch_size = batch_size })
     end
     alias :in_batches_of :in_batches
 
+    # Specifies that only first event should be read.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Specification]
+    def read_first
+      Specification.new(reader, result.dup { |r| r.read_as = :first })
+    end
+
+    # Specifies that only last event should be read.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Specification]
+    def read_last
+      Specification.new(reader, result.dup { |r| r.read_as = :last })
+    end
+
+    # Executes the query based on the specification built up to this point.
+    # Returns the first event in specified collection of events.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Event, nil]
+    def first
+      reader.one(read_first.result)
+    end
+
+    # Executes the query based on the specification built up to this point.
+    # Returns the last event in specified collection of events.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Event, nil]
+    def last
+      reader.one(read_last.result)
+    end
+
+    # Limits the query to certain event type(s).
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @types [Class, Array(Class)] types of event to look for.
+    # @return [Specification]
+    def of_type(*types)
+      Specification.new(reader, result.dup{ |r| r.with_types = types.flatten })
+    end
+    alias_method :of_types, :of_type
+
+    # Limits the query to certain events by given even ids.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param even_ids [Array(String)] ids of event to look for.
+    # @return [Specification]
+    def with_id(event_ids)
+      Specification.new(reader, result.dup{ |r| r.with_ids = event_ids })
+    end
+
+    # Reads single event from repository.
+    # Returns the event with specified id or nil if event is not found
+    # in specified collection of events.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Event, nil]
+    def event(event_id)
+      reader.one(read_first.with_id([event_id]).result)
+    end
+
+    # Reads single existing event from repository.
+    # Returns the event with specified id or raises [EventNotFound] error if
+    # event is not found in specified collection of events.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Event]
+    def event!(event_id)
+      event(event_id) or raise EventNotFound.new(event_id)
+    end
+
+    # Reads all events of given ids from repository.
+    # Yields each event (found by id in specified collection of 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] Enumerator is returned when block not given
+    def events(event_ids)
+      with_id(event_ids).each
+    end
+
+    attr_reader :result
     private
-    attr_reader :repository, :mapper
+    attr_reader :reader
   end
 end

data/lib/ruby_event_store/specification_reader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  # Used for fetching events based on given query specification.
+  class SpecificationReader
+    # @api private
+    # @private
+    def initialize(repository, mapper)
+      @repository = repository
+      @mapper = mapper
+    end
+
+    # @api private
+    # @private
+    def one(specification_result)
+      record = repository.read(specification_result)
+      mapper.serialized_record_to_event(record) if record
+    end
+
+    # @api private
+    # @private
+    def each(specification_result)
+      repository.read(specification_result).each do |batch|
+        yield batch.map { |serialized_record| mapper.serialized_record_to_event(serialized_record) }
+      end
+    end
+
+    # @api private
+    # @private
+    def count(specification_result)
+      repository.count(specification_result)
+    end
+
+    # @api private
+    # @private
+    def has_event?(event_id)
+      repository.has_event?(event_id)
+    end
+
+    private
+    attr_reader :repository, :mapper
+  end
+end

data/lib/ruby_event_store/specification_result.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class SpecificationResult
+    def initialize(direction: :forward,
+                   start: nil,
+                   stop: nil,
+                   count: nil,
+                   stream: Stream.new(GLOBAL_STREAM),
+                   read_as: :all,
+                   batch_size: Specification::DEFAULT_BATCH_SIZE,
+                   with_ids: nil,
+                   with_types: nil)
+      @attributes = Struct.new(:direction, :start, :stop, :count, :stream, :read_as, :batch_size, :with_ids, :with_types)
+        .new(direction, start, stop, count, stream, read_as, batch_size, with_ids, with_types)
+      freeze
+    end
+
+    # Limited results. True if number of read elements are limited
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def limit?
+      !attributes.count.nil?
+    end
+
+    # Results limit or infinity if limit not defined
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Integer|Infinity]
+    def limit
+      attributes.count || Float::INFINITY
+    end
+
+    # Stream definition. Stream to be read or nil
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Stream|nil]
+    def stream
+      attributes.stream
+    end
+
+    # Starting position. Event id of starting event
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [String]
+    def start
+      attributes.start
+    end
+
+    # Stop position. Event id of stopping event
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [String|Symbol]
+    def stop
+      attributes.stop
+    end
+
+    # Read direction. True is reading forward
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def forward?
+      get_direction.equal?(:forward)
+    end
+
+    # Read direction. True is reading backward
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def backward?
+      get_direction.equal?(:backward)
+    end
+
+    # Size of batch to read (only for :batch read strategy)
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Integer]
+    def batch_size
+      attributes.batch_size
+    end
+
+    # Ids of specified event to be read (if any given)
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Array|nil]
+    def with_ids
+      attributes.with_ids
+    end
+
+    # Read by specified ids. True if event ids have been specified.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def with_ids?
+      !with_ids.nil?
+    end
+
+    # Event types to be read (if any given)
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Array|nil]
+    def with_types
+      attributes.with_types&.map(&:to_s)
+    end
+
+    # Read by specified event types. True if event types have been specified.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def with_types?
+      !(with_types || []).empty?
+    end
+
+    # Read strategy. True if items will be read in batches
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def batched?
+      attributes.read_as.equal?(:batch)
+    end
+
+    # Read strategy. True if first item will be read
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def first?
+      attributes.read_as.equal?(:first)
+    end
+
+    # Read strategy. True if last item will be read
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def last?
+      attributes.read_as.equal?(:last)
+    end
+
+    # Read strategy. True if all items will be read
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def all?
+      attributes.read_as.equal?(:all)
+    end
+
+    # Clone [SpecificationResult]
+    # If block is given cloned attributes might be modified.
+    #
+    # @return [SpecificationResult]
+    def dup
+      new_attributes = attributes.dup
+      yield new_attributes if block_given?
+      SpecificationResult.new(**new_attributes.to_h)
+    end
+
+    # Two specification attributess are equal if:
+    # * they are of the same class
+    # * have identical data (verified with eql? method)
+    #
+    # @param other_spec [SpecificationResult, Object] object to compare
+    #
+    # @return [TrueClass, FalseClass]
+    def ==(other_spec)
+      other_spec.hash.eql?(hash)
+    end
+
+    # @private
+    BIG_VALUE = 0b100010010100011110111101100001011111100101001010111110101000000
+
+    # Generates a Fixnum hash value for this object. This function
+    # have the property that a.eql?(b) implies a.hash == b.hash.
+    #
+    # The hash value is used along with eql? by the Hash class to
+    # determine if two objects reference the same hash key.
+    #
+    # This hash is based on
+    # * class
+    # * direction
+    # * start
+    # * stop
+    # * count
+    # * stream
+    # * read_as
+    # * batch_size
+    # * with_ids
+    # * with_types
+    #
+    # @return [Integer]
+    def hash
+      [
+        self.class,
+        get_direction,
+        start,
+        stop,
+        limit,
+        stream,
+        attributes.read_as,
+        batch_size,
+        with_ids,
+        with_types,
+      ].hash ^ BIG_VALUE
+    end
+
+    private
+    attr_reader :attributes
+
+    def get_direction
+      attributes.direction
+    end
+  end
+end

data/lib/ruby_event_store/stream.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RubyEventStore
   class Stream
     def initialize(name)