ruby_event_store 2.2.0 → 2.4.1

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