ruby_event_store 2.2.0 → 2.4.1

data/lib/ruby_event_store/spec/mapper_lint.rb

@@ -3,8 +3,8 @@ module RubyEventStore
     specify "event_to_record returns instance of Record" do
       record = mapper.event_to_record(domain_event)
 
-      expect(record).to            be_kind_of(Record)
-      expect(record.event_id).to   eq(domain_event.event_id)
+      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
 

data/lib/ruby_event_store/spec/subscriptions_lint.rb

@@ -17,109 +17,110 @@ RSpec.shared_examples :subscriptions do |subscriptions_class|
 
   subject(:subscriptions) { subscriptions_class.new }
 
-  it 'returns all subscribed handlers' do
-    handler         = TestHandler.new
+  it "returns all subscribed handlers" do
+    handler = TestHandler.new
     another_handler = TestHandler.new
-    global_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])
+    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
+  it "returns subscribed thread handlers" do
+    handler = TestHandler.new
     another_handler = TestHandler.new
-    global_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)
-    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 =
+      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
-    handler   = TestHandler.new
+  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])
+  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
+  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 = 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([])
+    expect(subscriptions.all_for("Test1DomainEvent")).to eq([])
+    expect(subscriptions.all_for("Test2DomainEvent")).to eq([])
   end
 
-  it 'revokes subscription' do
-    handler   = TestHandler.new
+  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 = 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([])
+    expect(subscriptions.all_for("Test1DomainEvent")).to eq([])
+    expect(subscriptions.all_for("Test2DomainEvent")).to eq([])
   end
 
-  it 'revokes thread global subscription' do
-    handler   = TestHandler.new
+  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 = 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([])
+    expect(subscriptions.all_for("Test1DomainEvent")).to eq([])
+    expect(subscriptions.all_for("Test2DomainEvent")).to eq([])
   end
 
-  it 'revokes thread subscription' do
-    handler           = TestHandler.new
+  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 = 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([])
+    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
+  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])
+    expect(subscriptions.all_for("Test1DomainEvent")).to eq([handler, handler])
   end
 
-  it 'subscribes by type of event which is a class' do
-    handler         = TestHandler.new
+  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
 end

data/lib/ruby_event_store/specification.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module RubyEventStore
-
   # Used for building and executing the query specification.
   class Specification
     DEFAULT_BATCH_SIZE = 100
+
     # @api private
     # @private
     def initialize(reader, result = SpecificationResult.new)
@@ -53,7 +53,7 @@ module RubyEventStore
       Specification.new(
         reader,
         result.dup do |r|
-          r.older_than          = time
+          r.older_than = time
           r.older_than_or_equal = nil
         end
       )
@@ -69,7 +69,7 @@ module RubyEventStore
       Specification.new(
         reader,
         result.dup do |r|
-          r.older_than          = nil
+          r.older_than = nil
           r.older_than_or_equal = time
         end
       )
@@ -86,7 +86,7 @@ module RubyEventStore
         reader,
         result.dup do |r|
           r.newer_than_or_equal = nil
-          r.newer_than          = time
+          r.newer_than = time
         end
       )
     end
@@ -102,7 +102,7 @@ module RubyEventStore
         reader,
         result.dup do |r|
           r.newer_than_or_equal = time
-          r.newer_than          = nil
+          r.newer_than = nil
         end
       )
     end
@@ -125,7 +125,7 @@ module RubyEventStore
     #
     # @return [Specification]
     def as_at
-      Specification.new(reader, result.dup { |r| r.time_sort_by = :as_at})
+      Specification.new(reader, result.dup { |r| r.time_sort_by = :as_at })
     end
 
     # Sets the order of time sorting using validity time
@@ -171,9 +171,7 @@ module RubyEventStore
     def each_batch
       return to_enum(:each_batch) unless block_given?
 
-      reader.each(in_batches(result.batch_size).result) do |batch|
-        yield batch
-      end
+      reader.each(in_batches(result.batch_size).result) { |batch| yield batch }
     end
 
     # Executes the query based on the specification built up to this point.
@@ -185,9 +183,7 @@ module RubyEventStore
     def each
       return to_enum unless block_given?
 
-      each_batch do |batch|
-        batch.each { |event| yield event }
-      end
+      each_batch { |batch| batch.each { |event| yield event } }
     end
 
     # Executes the query based on the specification built up to this point
@@ -242,9 +238,15 @@ module RubyEventStore
     # @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(reader, result.dup { |r| r.read_as = :batch; r.batch_size = batch_size })
+      Specification.new(
+        reader,
+        result.dup do |r|
+          r.read_as = :batch
+          r.batch_size = batch_size
+        end
+      )
     end
-    alias :in_batches_of :in_batches
+    alias in_batches_of in_batches
 
     # Specifies that only first event should be read.
     # {http://railseventstore.org/docs/read/ Find out more}.
@@ -286,7 +288,7 @@ module RubyEventStore
     # @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 })
+      Specification.new(reader, result.dup { |r| r.with_types = types.flatten })
     end
     alias_method :of_types, :of_type
 
@@ -296,7 +298,7 @@ module RubyEventStore
     # @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 })
+      Specification.new(reader, result.dup { |r| r.with_ids = event_ids })
     end
 
     # Reads single event from repository.
@@ -331,7 +333,9 @@ module RubyEventStore
     end
 
     attr_reader :result
+
     private
+
     attr_reader :reader
   end
 end

data/lib/ruby_event_store/specification_reader.rb

@@ -20,9 +20,7 @@ module RubyEventStore
     # @api private
     # @private
     def each(specification_result)
-      repository.read(specification_result).each do |batch|
-        yield batch.map { |record| mapper.record_to_event(record) }
-      end
+      repository.read(specification_result).each { |batch| yield batch.map { |record| mapper.record_to_event(record) } }
     end
 
     # @api private
@@ -38,6 +36,7 @@ module RubyEventStore
     end
 
     private
+
     attr_reader :repository, :mapper
   end
 end

data/lib/ruby_event_store/specification_result.rb

@@ -2,51 +2,56 @@
 
 module RubyEventStore
   class SpecificationResult
-    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,
-        :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
-      )
+    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,
+            :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
 
@@ -282,11 +287,12 @@ module RubyEventStore
         attributes.read_as,
         batch_size,
         with_ids,
-        with_types,
+        with_types
       ].hash ^ BIG_VALUE
     end
 
     private
+
     attr_reader :attributes
 
     def get_direction

data/lib/ruby_event_store/stream.rb

@@ -15,19 +15,15 @@ module RubyEventStore
 
     BIG_VALUE = 0b111111100100000010010010110011101011000101010101001100100110011
     def hash
-      [
-        self.class,
-        name
-      ].hash ^ BIG_VALUE
+      [self.class, name].hash ^ BIG_VALUE
     end
 
     def ==(other_stream)
-      other_stream.instance_of?(self.class) &&
-        other_stream.name.eql?(name)
+      other_stream.instance_of?(self.class) && other_stream.name.eql?(name)
     end
 
     alias_method :eql?, :==
 
     private_constant :BIG_VALUE
   end
-end
+end

data/lib/ruby_event_store/subscriptions.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'concurrent'
+require "concurrent"
 
 module RubyEventStore
   class Subscriptions
     def initialize(event_type_resolver: default_event_type_resolver)
       @event_type_resolver = event_type_resolver
-      @local  = LocalSubscriptions.new
+      @local = LocalSubscriptions.new
       @global = GlobalSubscriptions.new
       @thread = ThreadSubscriptions.new
     end
@@ -28,12 +28,13 @@ module RubyEventStore
     end
 
     def all_for(event_type)
-      [local, global, thread].map{|r| r.all_for(event_type)}.reduce(&:+)
+      [local, global, thread].map { |r| r.all_for(event_type) }.reduce(&:+)
     end
 
     attr_reader :event_type_resolver
 
     private
+
     attr_reader :local, :global, :thread
 
     def default_event_type_resolver
@@ -50,24 +51,24 @@ module RubyEventStore
 
     class ThreadSubscriptions
       def initialize
-        @local  = ThreadLocalSubscriptions.new
+        @local = ThreadLocalSubscriptions.new
         @global = ThreadGlobalSubscriptions.new
       end
       attr_reader :local, :global
 
       def all_for(event_type)
-        [global, local].map{|r| r.all_for(event_type)}.reduce(&:+)
+        [global, local].map { |r| r.all_for(event_type) }.reduce(&:+)
       end
     end
 
     class LocalSubscriptions
       def initialize
-        @subscriptions = Hash.new {|hsh, key| hsh[key] = [] }
+        @subscriptions = Hash.new { |hsh, key| hsh[key] = [] }
       end
 
       def add(subscription, event_types)
-        event_types.each{ |type| @subscriptions[type] << subscription }
-        ->() {event_types.each{ |type| @subscriptions.fetch(type).delete(subscription) } }
+        event_types.each { |type| @subscriptions[type] << subscription }
+        -> { event_types.each { |type| @subscriptions.fetch(type).delete(subscription) } }
       end
 
       def all_for(event_type)
@@ -82,7 +83,7 @@ module RubyEventStore
 
       def add(subscription)
         @subscriptions << subscription
-        ->() { @subscriptions.delete(subscription) }
+        -> { @subscriptions.delete(subscription) }
       end
 
       def all_for(_event_type)
@@ -92,14 +93,12 @@ module RubyEventStore
 
     class ThreadLocalSubscriptions
       def initialize
-        @subscriptions = Concurrent::ThreadLocalVar.new do
-          Hash.new {|hsh, key| hsh[key] = [] }
-        end
+        @subscriptions = Concurrent::ThreadLocalVar.new { Hash.new { |hsh, key| hsh[key] = [] } }
       end
 
       def add(subscription, event_types)
-        event_types.each{ |type| @subscriptions.value[type] << subscription }
-        ->() {event_types.each{ |type| @subscriptions.value.fetch(type).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)
@@ -114,7 +113,7 @@ module RubyEventStore
 
       def add(subscription)
         @subscriptions.value += [subscription]
-        ->() { @subscriptions.value -= [subscription] }
+        -> { @subscriptions.value -= [subscription] }
       end
 
       def all_for(_event_type)

data/lib/ruby_event_store/transform_keys.rb

@@ -20,7 +20,7 @@ module RubyEventStore
             when Hash
               deep_transform(v, &block)
             when Array
-              v.map{|i| Hash === i ? deep_transform(i, &block) : i}
+              v.map { |i| Hash === i ? deep_transform(i, &block) : i }
             else
               v
             end

data/lib/ruby_event_store/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyEventStore
-  VERSION = "2.2.0"
+  VERSION = "2.4.1"
 end