ruby_event_store 2.1.0 → 2.4.0

data/lib/ruby_event_store/mappers/transformation/stringify_metadata_keys.rb

@@ -13,14 +13,15 @@ module RubyEventStore
         end
 
         private
+
         def stringify(record)
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: record.event_type,
-            data:       record.data,
-            metadata:   TransformKeys.stringify(record.metadata),
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: record.data,
+            metadata: TransformKeys.stringify(record.metadata),
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
       end

data/lib/ruby_event_store/mappers/transformation/symbolize_metadata_keys.rb

@@ -13,14 +13,15 @@ module RubyEventStore
         end
 
         private
+
         def symbolize(record)
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: record.event_type,
-            data:       record.data,
-            metadata:   TransformKeys.symbolize(record.metadata),
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: record.data,
+            metadata: TransformKeys.symbolize(record.metadata),
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
       end

data/lib/ruby_event_store/mappers/transformation/upcast.rb

@@ -10,13 +10,9 @@ module RubyEventStore
           end
 
           def call(record)
-            identity   = lambda { |r| r }
+            identity = lambda { |r| r }
             new_record = @upcast_map.fetch(record.event_type, identity)[record]
-            if new_record.equal?(record)
-              record
-            else
-              call(new_record)
-            end
+            new_record.equal?(record) ? record : call(new_record)
           end
         end
 

data/lib/ruby_event_store/metadata.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'time'
-require 'forwardable'
+require "date"
+require "time"
+require "forwardable"
 
 module RubyEventStore
   class Metadata
     include Enumerable
-    extend  Forwardable
+    extend Forwardable
 
     def initialize(h = self)
       @h = {}
-      h.each do |k, v|
-        self[k] = (v)
-      end
+      h.each { |k, v| self[k] = (v) }
     end
 
     def [](key)
@@ -22,23 +20,54 @@ module RubyEventStore
     end
 
     def []=(key, val)
-      raise ArgumentError unless allowed_types.any?{|klass| klass === val }
+      raise ArgumentError unless allowed_types.any? { |klass| klass === val }
       raise ArgumentError unless Symbol === key
-      @h[key]=val
+      @h[key] = val
     end
 
     def each(&block)
       @h.each(&block)
     end
 
-    SAFE_HASH_METHODS = [:<, :<=, :>, :>=, :assoc, :clear, :compact, :compact!,
-      :delete, :delete_if, :dig, :each_key, :each_pair,
-      :each_value, :empty?, :fetch, :fetch_values,
-      :flatten, :has_key?, :has_value?,
-      :keep_if, :key, :key?, :keys, :length,
-      :rassoc, :reject!, :select!, :shift, :size, :slice,
-      :to_proc, :transform_keys, :transform_values,
-      :value?, :values, :values_at]
+    SAFE_HASH_METHODS = %i[
+      <
+      <=
+      >
+      >=
+      assoc
+      clear
+      compact
+      compact!
+      delete
+      delete_if
+      dig
+      each_key
+      each_pair
+      each_value
+      empty?
+      fetch
+      fetch_values
+      flatten
+      has_key?
+      has_value?
+      keep_if
+      key
+      key?
+      keys
+      length
+      rassoc
+      reject!
+      select!
+      shift
+      size
+      slice
+      to_proc
+      transform_keys
+      transform_values
+      value?
+      values
+      values_at
+    ]
 
     delegate SAFE_HASH_METHODS => :@h
 

data/lib/ruby_event_store/projection.rb

@@ -15,9 +15,9 @@ module RubyEventStore
     end
 
     def initialize(streams: [])
-      @streams  = streams
+      @streams = streams
       @handlers = {}
-      @init     = -> { {} }
+      @init = -> { {} }
     end
 
     attr_reader :streams, :handlers
@@ -28,9 +28,7 @@ module RubyEventStore
     end
 
     def when(events, handler)
-      Array(events).each do |event|
-        handlers[event.to_s] = handler
-      end
+      Array(events).each { |event| handlers[event.to_s] = handler }
 
       self
     end
@@ -53,33 +51,27 @@ module RubyEventStore
 
     def run(event_store, start: nil, count: PAGE_SIZE)
       return initial_state if handled_events.empty?
-      if streams.any?
-        reduce_from_streams(event_store, start, count)
-      else
-        reduce_from_all_streams(event_store, start, count)
-      end
+      streams.any? ? reduce_from_streams(event_store, start, count) : reduce_from_all_streams(event_store, start, count)
     end
 
     private
 
     def valid_starting_point?(start)
       return true unless start
-      if streams.any?
-        (start.instance_of?(Array) && start.size === streams.size)
-      else
-        start.instance_of?(String)
-      end
+      streams.any? ? (start.instance_of?(Array) && start.size === streams.size) : start.instance_of?(String)
     end
 
     def reduce_from_streams(event_store, start, count)
-      raise ArgumentError.new('Start must be an array with event ids') unless valid_starting_point?(start)
-      streams.zip(start_events(start)).reduce(initial_state) do |state, (stream_name, start_event_id)|
-        read_scope(event_store, stream_name, count, start_event_id).reduce(state, &method(:transition))
-      end
+      raise ArgumentError.new("Start must be an array with event ids") unless valid_starting_point?(start)
+      streams
+        .zip(start_events(start))
+        .reduce(initial_state) do |state, (stream_name, start_event_id)|
+          read_scope(event_store, stream_name, count, start_event_id).reduce(state, &method(:transition))
+        end
     end
 
     def reduce_from_all_streams(event_store, start, count)
-      raise ArgumentError.new('Start must be valid event id') unless valid_starting_point?(start)
+      raise ArgumentError.new("Start must be valid event id") unless valid_starting_point?(start)
       read_scope(event_store, nil, count, start).reduce(initial_state, &method(:transition))
     end
 

data/lib/ruby_event_store/record.rb

@@ -5,12 +5,12 @@ module RubyEventStore
     StringsRequired = Class.new(StandardError)
     def initialize(event_id:, data:, metadata:, event_type:, timestamp:, valid_at:)
       raise StringsRequired unless [event_id, event_type].all? { |v| v.instance_of?(String) }
-      @event_id   = event_id
-      @data       = data
-      @metadata   = metadata
+      @event_id = event_id
+      @data = data
+      @metadata = metadata
       @event_type = event_type
-      @timestamp  = timestamp
-      @valid_at   = valid_at
+      @timestamp = timestamp
+      @valid_at = valid_at
       @serialized_records = {}
       freeze
     end
@@ -19,24 +19,12 @@ module RubyEventStore
 
     BIG_VALUE = 0b110011100100000010010010110011101011110101010101001100111110011
     def hash
-      [
-        self.class,
-        event_id,
-        data,
-        metadata,
-        event_type,
-        timestamp,
-        valid_at,
-      ].hash ^ BIG_VALUE
+      [self.class, event_id, data, metadata, event_type, timestamp, valid_at].hash ^ BIG_VALUE
     end
 
     def ==(other)
-      other.instance_of?(self.class) &&
-        other.event_id.eql?(event_id) &&
-        other.data.eql?(data) &&
-        other.metadata.eql?(metadata) &&
-        other.event_type.eql?(event_type) &&
-        other.timestamp.eql?(timestamp) &&
+      other.instance_of?(self.class) && other.event_id.eql?(event_id) && other.data.eql?(data) &&
+        other.metadata.eql?(metadata) && other.event_type.eql?(event_type) && other.timestamp.eql?(timestamp) &&
         other.valid_at.eql?(valid_at)
     end
 
@@ -47,19 +35,19 @@ module RubyEventStore
         metadata: metadata,
         event_type: event_type,
         timestamp: timestamp,
-        valid_at: valid_at,
+        valid_at: valid_at
       }
     end
 
     def serialize(serializer)
       @serialized_records[serializer] ||=
         SerializedRecord.new(
-          event_id:   event_id,
+          event_id: event_id,
           event_type: event_type,
-          data:       serializer.dump(data),
-          metadata:   serializer.dump(metadata),
-          timestamp:  timestamp.iso8601(TIMESTAMP_PRECISION),
-          valid_at:   valid_at.iso8601(TIMESTAMP_PRECISION),
+          data: serializer.dump(data),
+          metadata: serializer.dump(metadata),
+          timestamp: timestamp.iso8601(TIMESTAMP_PRECISION),
+          valid_at: valid_at.iso8601(TIMESTAMP_PRECISION)
         )
     end
 

data/lib/ruby_event_store/serialized_record.rb

@@ -5,12 +5,12 @@ module RubyEventStore
     StringsRequired = Class.new(StandardError)
     def initialize(event_id:, data:, metadata:, event_type:, timestamp:, valid_at:)
       raise StringsRequired unless [event_id, event_type].all? { |v| v.instance_of?(String) }
-      @event_id   = event_id
-      @data       = data
-      @metadata   = metadata
+      @event_id = event_id
+      @data = data
+      @metadata = metadata
       @event_type = event_type
-      @timestamp  = timestamp
-      @valid_at   = valid_at
+      @timestamp = timestamp
+      @valid_at = valid_at
       freeze
     end
 
@@ -18,24 +18,12 @@ module RubyEventStore
 
     BIG_VALUE = 0b110011100100000010010010110011101011110101010101001100111110111
     def hash
-      [
-        self.class,
-        event_id,
-        data,
-        metadata,
-        event_type,
-        timestamp,
-        valid_at,
-      ].hash ^ BIG_VALUE
+      [self.class, event_id, data, metadata, event_type, timestamp, valid_at].hash ^ BIG_VALUE
     end
 
     def ==(other)
-      other.instance_of?(self.class) &&
-        other.event_id.eql?(event_id) &&
-        other.data.eql?(data) &&
-        other.metadata.eql?(metadata) &&
-        other.event_type.eql?(event_type) &&
-        other.timestamp.eql?(timestamp) &&
+      other.instance_of?(self.class) && other.event_id.eql?(event_id) && other.data.eql?(data) &&
+        other.metadata.eql?(metadata) && other.event_type.eql?(event_type) && other.timestamp.eql?(timestamp) &&
         other.valid_at.eql?(valid_at)
     end
 
@@ -46,18 +34,18 @@ module RubyEventStore
         metadata: metadata,
         event_type: event_type,
         timestamp: timestamp,
-        valid_at: valid_at,
+        valid_at: valid_at
       }
     end
 
     def deserialize(serializer)
       Record.new(
-        event_id:   event_id,
+        event_id: event_id,
         event_type: event_type,
-        data:       serializer.load(data),
-        metadata:   serializer.load(metadata),
-        timestamp:  Time.iso8601(timestamp),
-        valid_at:   Time.iso8601(valid_at),
+        data: serializer.load(data),
+        metadata: serializer.load(metadata),
+        timestamp: Time.iso8601(timestamp),
+        valid_at: Time.iso8601(valid_at)
       )
     end
 

data/lib/ruby_event_store/serializers/yaml.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module RubyEventStore
+  module Serializers
+    class YAML
+      def self.dump(value)
+        ::YAML.dump(value)
+      end
+
+      def self.load(serialized)
+        ::YAML.respond_to?(:unsafe_load) ? ::YAML.unsafe_load(serialized) : ::YAML.load(serialized)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -1,63 +1,73 @@
 RSpec.shared_examples :broker do |broker_klass|
-  let(:event) { instance_double(::RubyEventStore::Event, event_type: 'EventType') }
-  let(:record) { instance_double(::RubyEventStore::Record)  }
+  let(:event) { instance_double(::RubyEventStore::Event, event_type: "EventType") }
+  let(:record) { instance_double(::RubyEventStore::Record) }
   let(:handler) { HandlerClass.new }
   let(:subscriptions) { ::RubyEventStore::Subscriptions.new }
   let(:dispatcher) { ::RubyEventStore::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(subscriptions).to receive(:all_for).with("EventType").and_return([])
     expect(dispatcher).not_to receive(:call)
     broker.call(event, record)
   end
 
   specify "calls subscription" do
-    expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler])
+    expect(subscriptions).to receive(:all_for).with("EventType").and_return([handler])
     expect(dispatcher).to receive(:call).with(handler, event, record)
     broker.call(event, record)
   end
 
   specify "calls subscribed class" do
-    expect(subscriptions).to receive(:all_for).with('EventType').and_return([HandlerClass])
+    expect(subscriptions).to receive(:all_for).with("EventType").and_return([HandlerClass])
     expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
     broker.call(event, record)
   end
 
   specify "calls all subscriptions" do
-    expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler, HandlerClass])
+    expect(subscriptions).to receive(:all_for).with("EventType").and_return([handler, HandlerClass])
     expect(dispatcher).to receive(:call).with(handler, event, record)
     expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
     broker.call(event, record)
   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"
+  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 'raise error when wrong subscriber' do
+  specify "raise error when wrong subscriber" do
     allow(dispatcher).to receive(:verify).and_return(false)
-    expect do
-      broker.add_subscription(HandlerClass, [])
-    end.to raise_error(RubyEventStore::InvalidHandler, /Handler HandlerClass is invalid for dispatcher .*Dispatcher/)
-    expect do
-      broker.add_global_subscription(HandlerClass)
-    end.to raise_error(RubyEventStore::InvalidHandler, /is invalid for dispatcher/)
-    expect do
-      broker.add_thread_subscription(HandlerClass, [])
-    end.to raise_error(RubyEventStore::InvalidHandler, /is invalid for dispatcher/)
-    expect do
-      broker.add_thread_global_subscription(HandlerClass)
-    end.to raise_error(RubyEventStore::InvalidHandler, /is invalid for dispatcher/)
+    expect { broker.add_subscription(HandlerClass, []) }.to raise_error(
+      RubyEventStore::InvalidHandler,
+      /Handler HandlerClass is invalid for dispatcher .*Dispatcher/
+    )
+    expect { broker.add_global_subscription(HandlerClass) }.to raise_error(
+      RubyEventStore::InvalidHandler,
+      /is invalid for dispatcher/
+    )
+    expect { broker.add_thread_subscription(HandlerClass, []) }.to raise_error(
+      RubyEventStore::InvalidHandler,
+      /is invalid for dispatcher/
+    )
+    expect { broker.add_thread_global_subscription(HandlerClass) }.to raise_error(
+      RubyEventStore::InvalidHandler,
+      /is invalid for dispatcher/
+    )
   end
 
   specify "verify and add - local subscriptions" do
     expect(dispatcher).to receive(:verify).with(handler).and_return(true)
-    expect(subscriptions).to receive(:add_subscription).with(handler, ['EventType'])
-    broker.add_subscription(handler, ['EventType'])
+    expect(subscriptions).to receive(:add_subscription).with(handler, ["EventType"])
+    broker.add_subscription(handler, ["EventType"])
   end
 
   specify "verify and add - global subscriptions" do
@@ -68,8 +78,8 @@ RSpec.shared_examples :broker do |broker_klass|
 
   specify "verify and add - thread local subscriptions" do
     expect(dispatcher).to receive(:verify).with(handler).and_return(true)
-    expect(subscriptions).to receive(:add_thread_subscription).with(handler, ['EventType'])
-    broker.add_thread_subscription(handler, ['EventType'])
+    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

data/lib/ruby_event_store/spec/event_lint.rb

@@ -1,36 +1,36 @@
 RSpec.shared_examples :event do |event_class, data, metadata|
-  it 'allows initialization' do
+  it "allows initialization" do
     expect {
       event_class.new(event_id: Object.new, data: data || Object.new, metadata: metadata || {})
     }.not_to raise_error
   end
 
-  it 'provides event_id as string' do
+  it "provides event_id as string" do
     event = event_class.new
     expect(event.event_id).to be_an_instance_of(String)
-    expect(event.event_id).not_to eq ''
+    expect(event.event_id).not_to eq ""
     expect(event.event_id).not_to eq nil
   end
 
-  it 'provides message_id as string' do
+  it "provides message_id as string" do
     event = event_class.new
     expect(event.message_id).to be_an_instance_of(String)
   end
 
-  it 'message_id is the same as event_id' do
+  it "message_id is the same as event_id" do
     event = event_class.new
     expect(event.event_id).to eq event.message_id
   end
 
-  it 'exposes given event_id to string' do
-    event = event_class.new(event_id: 1234567890)
-    expect(event.event_id).to eq '1234567890'
+  it "exposes given event_id to string" do
+    event = event_class.new(event_id: 1_234_567_890)
+    expect(event.event_id).to eq "1234567890"
   end
 
-  it 'provides event type as string' do
+  it "provides event type as string" do
     event = event_class.new
     expect(event.event_type).to be_an_instance_of(String)
-    expect(event.event_type).not_to eq ''
+    expect(event.event_type).not_to eq ""
     expect(event.event_type).not_to eq nil
   end