ruby_event_store 1.2.2 → 2.1.0

data/lib/ruby_event_store/spec/mapper_lint.rb

@@ -1,17 +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)
+  ::RSpec.shared_examples :mapper do |mapper, domain_event|
+    specify "event_to_record returns instance of Record" do
+      record = mapper.event_to_record(domain_event)
 
-      expect(record).to            be_kind_of(SerializedRecord)
+      expect(record).to            be_kind_of(Record)
       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)
+      record = mapper.event_to_record(domain_event)
 
-      expect(mapper.serialized_record_to_event(record)).to eq(domain_event)
+      expect(mapper.record_to_event(record)).to eq(domain_event)
     end
   end
 end

data/lib/ruby_event_store/spec/subscriptions_lint.rb

@@ -39,10 +39,16 @@ RSpec.shared_examples :subscriptions do |subscriptions_class|
     subscriptions.add_thread_subscription(handler, [Test1DomainEvent, Test3DomainEvent])
     subscriptions.add_thread_subscription(another_handler, [Test2DomainEvent])
     subscriptions.add_thread_global_subscription(global_handler)
+    t = Thread.new do
+      subscriptions.add_thread_subscription(handler, [Test2DomainEvent])
+      subscriptions.add_thread_global_subscription(another_handler)
+      expect(subscriptions.all_for('Test2DomainEvent')).to eq([another_handler, handler])
+    end
 
     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])
+    t.join
   end
 
   it 'returns lambda as an output of global subscribe methods' do
@@ -108,4 +114,23 @@ RSpec.shared_examples :subscriptions do |subscriptions_class|
 
     expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler, handler])
   end
+
+  it 'subscribes by type of event which is a class' do
+    handler         = TestHandler.new
+    subscriptions.add_subscription(handler, [Test1DomainEvent])
+    subscriptions.add_thread_subscription(handler, [Test1DomainEvent])
+
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler, handler])
+    expect(subscriptions.all_for(Test1DomainEvent)).to eq([handler, handler])
+  end
+
+  it 'subscribes by type of event which is a class or string with custom type resolver' do
+    subscriptions = subscriptions_class.new(event_type_resolver: ->(type) { type.to_s.reverse })
+    handler         = TestHandler.new
+    subscriptions.add_subscription(handler, [Test1DomainEvent])
+    subscriptions.add_thread_subscription(handler, ['Test1DomainEvent'])
+
+    expect(subscriptions.all_for('Test1DomainEvent')).to eq([handler, handler])
+    expect(subscriptions.all_for(Test1DomainEvent)).to eq([handler, handler])
+  end
 end

data/lib/ruby_event_store/specification.rb

@@ -35,7 +35,7 @@ module RubyEventStore
     # 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.
+    # @param stop [String] id of event to start reading from.
     # @return [Specification]
     def to(stop)
       raise InvalidPageStop if stop.nil? || stop.empty?
@@ -43,6 +43,99 @@ module RubyEventStore
       Specification.new(reader, result.dup { |r| r.stop = stop })
     end
 
+    # Limits the query to events that later than given time.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time [Time]
+    # @return [Specification]
+    def older_than(time)
+      raise ArgumentError unless time.respond_to?(:to_time)
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.older_than          = time
+          r.older_than_or_equal = nil
+        end
+      )
+    end
+
+    # Limits the query to events that occurred on given time or later.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time [Time]
+    # @return [Specification]
+    def older_than_or_equal(time)
+      raise ArgumentError unless time.respond_to?(:to_time)
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.older_than          = nil
+          r.older_than_or_equal = time
+        end
+      )
+    end
+
+    # Limits the query to events that occurred earlier than given time.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time [Time]
+    # @return [Specification]
+    def newer_than(time)
+      raise ArgumentError unless time.respond_to?(:to_time)
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.newer_than_or_equal = nil
+          r.newer_than          = time
+        end
+      )
+    end
+
+    # Limits the query to events that occurred on given time or earlier.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time [Time]
+    # @return [Specification]
+    def newer_than_or_equal(time)
+      raise ArgumentError unless time.respond_to?(:to_time)
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.newer_than_or_equal = time
+          r.newer_than          = nil
+        end
+      )
+    end
+
+    # Limits the query to events within given time range.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @param time_range [Range]
+    # @return [Specification]
+    def between(time_range)
+      if time_range.exclude_end?
+        newer_than_or_equal(time_range.first).older_than(time_range.last)
+      else
+        newer_than_or_equal(time_range.first).older_than_or_equal(time_range.last)
+      end
+    end
+
+    # Sets the order of time sorting using transaction time
+    # {http://railseventstore.org/docs/read/ Find out more}
+    #
+    # @return [Specification]
+    def as_at
+      Specification.new(reader, result.dup { |r| r.time_sort_by = :as_at})
+    end
+
+    # Sets the order of time sorting using validity time
+    # {http://railseventstore.org/docs/read/ Find out more}
+    #
+    # @return [Specification]
+    def as_of
+      Specification.new(reader, result.dup { |r| r.time_sort_by = :as_of })
+    end
+
     # Sets the order of reading events to ascending (forward from the start).
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
@@ -73,7 +166,7 @@ module RubyEventStore
     # 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
+    # @yield [Array<Event>] batch of events
     # @return [Enumerator, nil] Enumerator is returned when block not given
     def each_batch
       return to_enum(:each_batch) unless block_given?
@@ -87,7 +180,7 @@ module RubyEventStore
     # 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
+    # @yield [Event] event
     # @return [Enumerator, nil] Enumerator is returned when block not given
     def each
       return to_enum unless block_given?
@@ -111,7 +204,7 @@ module RubyEventStore
     # built up to this point result using provided block.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @accumulator starting state for reduce operation
+    # @param 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?
@@ -130,7 +223,7 @@ module RubyEventStore
     # Returns array of domain events.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @return [Array<Event, Proto>]
+    # @return [Array<Event>]
     def to_a
       each.to_a
     end
@@ -200,7 +293,7 @@ module RubyEventStore
     # 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.
+    # @param event_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 })
@@ -231,7 +324,7 @@ module RubyEventStore
     # read from the store if block given. Otherwise, returns enumerable collection.
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
-    # @yield [Event, Proto] event
+    # @yield [Event] event
     # @return [Enumerator] Enumerator is returned when block not given
     def events(event_ids)
       with_id(event_ids).each

data/lib/ruby_event_store/specification_reader.rb

@@ -14,14 +14,14 @@ module RubyEventStore
     # @private
     def one(specification_result)
       record = repository.read(specification_result)
-      mapper.serialized_record_to_event(record) if record
+      mapper.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) }
+        yield batch.map { |record| mapper.record_to_event(record) }
       end
     end
 

data/lib/ruby_event_store/specification_result.rb

@@ -5,14 +5,48 @@ module RubyEventStore
     def initialize(direction: :forward,
                    start: nil,
                    stop: nil,
+                   older_than: nil,
+                   older_than_or_equal: nil,
+                   newer_than: nil,
+                   newer_than_or_equal: nil,
+                   time_sort_by: 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)
+      @attributes = Struct.new(
+        :direction,
+        :start,
+        :stop,
+        :older_than,
+        :older_than_or_equal,
+        :newer_than,
+        :newer_than_or_equal,
+        :time_sort_by,
+        :count,
+        :stream,
+        :read_as,
+        :batch_size,
+        :with_ids,
+        :with_types
+      ).new(
+        direction,
+        start,
+        stop,
+        older_than,
+        older_than_or_equal,
+        newer_than,
+        newer_than_or_equal,
+        time_sort_by,
+        count,
+        stream,
+        read_as,
+        batch_size,
+        with_ids,
+        with_types
+      )
       freeze
     end
 
@@ -56,6 +90,46 @@ module RubyEventStore
       attributes.stop
     end
 
+    # Ending time.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Time]
+    def older_than
+      attributes.older_than
+    end
+
+    # Ending time.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Time]
+    def older_than_or_equal
+      attributes.older_than_or_equal
+    end
+
+    # Starting time.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Time]
+    def newer_than
+      attributes.newer_than
+    end
+
+    # Starting time.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Time]
+    def newer_than_or_equal
+      attributes.newer_than_or_equal
+    end
+
+    # Time sorting strategy. Nil when not specified.
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Symbol]
+    def time_sort_by
+      attributes.time_sort_by
+    end
+
     # Read direction. True is reading forward
     # {http://railseventstore.org/docs/read/ Find out more}.
     #
@@ -179,6 +253,11 @@ module RubyEventStore
     # * direction
     # * start
     # * stop
+    # * older_than
+    # * older_than_or_equal
+    # * newer_than
+    # * newer_than_or_equal
+    # * time_sort_by
     # * count
     # * stream
     # * read_as
@@ -193,6 +272,11 @@ module RubyEventStore
         get_direction,
         start,
         stop,
+        older_than,
+        older_than_or_equal,
+        newer_than,
+        newer_than_or_equal,
+        time_sort_by,
         limit,
         stream,
         attributes.read_as,

data/lib/ruby_event_store/subscriptions.rb

@@ -4,14 +4,15 @@ require 'concurrent'
 
 module RubyEventStore
   class Subscriptions
-    def initialize
+    def initialize(event_type_resolver: default_event_type_resolver)
+      @event_type_resolver = event_type_resolver
       @local  = LocalSubscriptions.new
       @global = GlobalSubscriptions.new
-      @thread  = ThreadSubscriptions.new
+      @thread = ThreadSubscriptions.new
     end
 
     def add_subscription(subscriber, event_types)
-      local.add(subscriber, event_types)
+      local.add(subscriber, resolve_event_types(event_types))
     end
 
     def add_global_subscription(subscriber)
@@ -19,7 +20,7 @@ module RubyEventStore
     end
 
     def add_thread_subscription(subscriber, event_types)
-      thread.local.add(subscriber, event_types)
+      thread.local.add(subscriber, resolve_event_types(event_types))
     end
 
     def add_thread_global_subscription(subscriber)
@@ -27,12 +28,25 @@ module RubyEventStore
     end
 
     def all_for(event_type)
-      [local, global, thread].map{|r| r.all_for(event_type)}.reduce(&:+)
+      resolved_event_type = resolve_event_type(event_type)
+      [local, global, thread].map{|r| r.all_for(resolved_event_type)}.reduce(&:+)
     end
 
     private
     attr_reader :local, :global, :thread
 
+    def default_event_type_resolver
+      ->(value) { value.to_s }
+    end
+
+    def resolve_event_types(event_types)
+      event_types.map(&method(:resolve_event_type))
+    end
+
+    def resolve_event_type(type)
+      @event_type_resolver.call(type)
+    end
+
     class ThreadSubscriptions
       def initialize
         @local  = ThreadLocalSubscriptions.new
@@ -51,8 +65,8 @@ module RubyEventStore
       end
 
       def add(subscription, event_types)
-        event_types.each{ |type| @subscriptions[type.to_s] << subscription }
-        ->() {event_types.each{ |type| @subscriptions.fetch(type.to_s).delete(subscription) } }
+        event_types.each{ |type| @subscriptions[type] << subscription }
+        ->() {event_types.each{ |type| @subscriptions.fetch(type).delete(subscription) } }
       end
 
       def all_for(event_type)
@@ -83,8 +97,8 @@ module RubyEventStore
       end
 
       def add(subscription, event_types)
-        event_types.each{ |type| @subscriptions.value[type.to_s] << subscription }
-        ->() {event_types.each{ |type| @subscriptions.value.fetch(type.to_s).delete(subscription) } }
+        event_types.each{ |type| @subscriptions.value[type] << subscription }
+        ->() {event_types.each{ |type| @subscriptions.value.fetch(type).delete(subscription) } }
       end
 
       def all_for(event_type)

data/lib/ruby_event_store/transform_keys.rb

@@ -4,23 +4,23 @@ module RubyEventStore
   class TransformKeys
     class << self
       def stringify(data)
-        transform(data) {|k| k.to_s}
+        deep_transform(data, &:to_s)
       end
 
       def symbolize(data)
-        transform(data) {|k| k.to_sym}
+        deep_transform(data, &:to_sym)
       end
 
       private
 
-      def transform(data, &block)
+      def deep_transform(data, &block)
         data.each_with_object({}) do |(k, v), h|
           h[yield(k)] =
             case v
             when Hash
-              transform(v, &block)
+              deep_transform(v, &block)
             when Array
-              v.map{|i| Hash === i ? transform(i, &block) : i}
+              v.map{|i| Hash === i ? deep_transform(i, &block) : i}
             else
               v
             end