ruby_event_store 2.2.0 → 2.4.1

data/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -13,11 +13,20 @@ module RubyEventStore
       end
     end
 
-    def verify(subscriber)
-      dispatcher.verify(subscriber)
+    def method_missing(method_name, *arguments, **keyword_arguments, &block)
+      if respond_to?(method_name)
+        dispatcher.public_send(method_name, *arguments, **keyword_arguments, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private)
+      dispatcher.respond_to?(method_name)
     end
 
     private
+
     attr_reader :instrumentation, :dispatcher
   end
 end

data/lib/ruby_event_store/instrumented_repository.rb

@@ -25,14 +25,6 @@ module RubyEventStore
       end
     end
 
-    def has_event?(event_id)
-      repository.has_event?(event_id)
-    end
-
-    def last_stream_event(stream)
-      repository.last_stream_event(stream)
-    end
-
     def read(specification)
       instrumentation.instrument("read.repository.rails_event_store", specification: specification) do
         repository.read(specification)
@@ -57,7 +49,20 @@ module RubyEventStore
       end
     end
 
+    def method_missing(method_name, *arguments, **keyword_arguments, &block)
+      if respond_to?(method_name)
+        repository.public_send(method_name, *arguments, **keyword_arguments, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private)
+      repository.respond_to?(method_name)
+    end
+
     private
+
     attr_reader :repository, :instrumentation
   end
 end

data/lib/ruby_event_store/link_by_metadata.rb

@@ -2,7 +2,6 @@
 
 module RubyEventStore
   class LinkByMetadata
-
     def initialize(event_store:, key:, prefix: nil)
       @event_store = event_store
       @key = key
@@ -12,31 +11,19 @@ module RubyEventStore
     def call(event)
       return unless event.metadata.has_key?(@key)
 
-      @event_store.link(
-        [event.event_id],
-        stream_name: "#{@prefix}#{event.metadata.fetch(@key)}"
-      )
+      @event_store.link([event.event_id], stream_name: "#{@prefix}#{event.metadata.fetch(@key)}")
     end
-
   end
 
   class LinkByCorrelationId < LinkByMetadata
     def initialize(event_store:, prefix: nil)
-      super(
-        event_store: event_store,
-        prefix:      prefix,
-        key:         :correlation_id,
-      )
+      super(event_store: event_store, prefix: prefix, key: :correlation_id)
     end
   end
 
   class LinkByCausationId < LinkByMetadata
     def initialize(event_store:, prefix: nil)
-      super(
-        event_store: event_store,
-        prefix:      prefix,
-        key:         :causation_id,
-      )
+      super(event_store: event_store, prefix: prefix, key: :causation_id)
     end
   end
 
@@ -47,11 +34,7 @@ module RubyEventStore
     end
 
     def call(event)
-      @event_store.link(
-        [event.event_id],
-        stream_name: "#{@prefix}#{event.event_type}"
-      )
+      @event_store.link([event.event_id], stream_name: "#{@prefix}#{event.event_type}")
     end
   end
-
 end

data/lib/ruby_event_store/mappers/default.rb

@@ -4,10 +4,12 @@ module RubyEventStore
   module Mappers
     class Default < PipelineMapper
       def initialize(events_class_remapping: {})
-        super(Pipeline.new(
-          Transformation::EventClassRemapper.new(events_class_remapping),
-          Transformation::SymbolizeMetadataKeys.new,
-        ))
+        super(
+          Pipeline.new(
+            Transformation::EventClassRemapper.new(events_class_remapping),
+            Transformation::SymbolizeMetadataKeys.new
+          )
+        )
       end
     end
   end

data/lib/ruby_event_store/mappers/encryption_key.rb

@@ -5,31 +5,22 @@ module RubyEventStore
     class EncryptionKey
       def initialize(cipher:, key:)
         @cipher = cipher
-        @key    = key
+        @key = key
       end
 
       def encrypt(message, iv)
-        crypto     = prepare_encrypt(cipher)
-        crypto.iv  = iv
+        crypto = prepare_encrypt(cipher)
+        crypto.iv = iv
         crypto.key = key
 
-        if crypto.authenticated?
-          encrypt_authenticated(crypto, message)
-        else
-          crypto.update(message) + crypto.final
-        end
+        crypto.authenticated? ? encrypt_authenticated(crypto, message) : crypto.update(message) + crypto.final
       end
 
       def decrypt(message, iv)
-        crypto     = prepare_decrypt(cipher)
-        crypto.iv  = iv
+        crypto = prepare_decrypt(cipher)
+        crypto.iv = iv
         crypto.key = key
-        ciphertext =
-          if crypto.authenticated?
-            ciphertext_from_authenticated(crypto, message)
-          else
-            message
-          end
+        ciphertext = crypto.authenticated? ? ciphertext_from_authenticated(crypto, message) : message
         (crypto.update(ciphertext) + crypto.final).force_encoding("UTF-8")
       end
 

data/lib/ruby_event_store/mappers/encryption_mapper.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module RubyEventStore
   module Mappers
     class EncryptionMapper < PipelineMapper
-      def initialize(key_repository, serializer: YAML, forgotten_data: ForgottenData.new)
-        super(Pipeline.new(
-          Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data),
-        ))
+      def initialize(key_repository, serializer: Serializers::YAML, forgotten_data: ForgottenData.new)
+        super(
+          Pipeline.new(
+            Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data)
+          )
+        )
       end
     end
   end

data/lib/ruby_event_store/mappers/forgotten_data.rb

@@ -3,7 +3,7 @@
 module RubyEventStore
   module Mappers
     class ForgottenData
-      FORGOTTEN_DATA = 'FORGOTTEN_DATA'.freeze
+      FORGOTTEN_DATA = "FORGOTTEN_DATA".freeze
 
       def initialize(string = FORGOTTEN_DATA)
         @string = string

data/lib/ruby_event_store/mappers/in_memory_encryption_key_repository.rb

@@ -3,7 +3,7 @@
 module RubyEventStore
   module Mappers
     class InMemoryEncryptionKeyRepository
-      DEFAULT_CIPHER = 'aes-256-gcm'.freeze
+      DEFAULT_CIPHER = "aes-256-gcm".freeze
 
       def initialize
         @keys = {}

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -3,7 +3,6 @@
 module RubyEventStore
   module Mappers
     class NullMapper < PipelineMapper
-
       def initialize
         super(Pipeline.new)
       end

data/lib/ruby_event_store/mappers/pipeline.rb

@@ -4,22 +4,15 @@ module RubyEventStore
   module Mappers
     class Pipeline
       def initialize(*transformations, to_domain_event: Transformation::DomainEvent.new)
-        @transformations = [
-          to_domain_event,
-          transformations,
-        ].flatten.freeze
+        @transformations = [to_domain_event, transformations].flatten.freeze
       end
 
       def dump(domain_event)
-        transformations.reduce(domain_event) do |item, transform|
-          transform.dump(item)
-        end
+        transformations.reduce(domain_event) { |item, transform| transform.dump(item) }
       end
 
       def load(record)
-        transformations.reverse.reduce(record) do |item, transform|
-          transform.load(item)
-        end
+        transformations.reverse.reduce(record) { |item, transform| transform.load(item) }
       end
 
       attr_reader :transformations

data/lib/ruby_event_store/mappers/pipeline_mapper.rb

@@ -16,6 +16,7 @@ module RubyEventStore
       end
 
       private
+
       attr_reader :pipeline
     end
   end

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

@@ -5,27 +5,37 @@ module RubyEventStore
     module Transformation
       class DomainEvent
         def dump(domain_event)
-          metadata  = domain_event.metadata.dup.to_h
+          metadata = domain_event.metadata.dup.to_h
           timestamp = metadata.delete(:timestamp)
-          valid_at  = metadata.delete(:valid_at)
+          valid_at = metadata.delete(:valid_at)
           Record.new(
-            event_id:   domain_event.event_id,
-            metadata:   metadata,
-            data:       domain_event.data,
+            event_id: domain_event.event_id,
+            metadata: metadata,
+            data: domain_event.data,
             event_type: domain_event.event_type,
-            timestamp:  timestamp,
-            valid_at:   valid_at,
+            timestamp: timestamp,
+            valid_at: valid_at
           )
         end
 
         def load(record)
-          Object.const_get(record.event_type).new(
+          Object
+            .const_get(record.event_type)
+            .new(
+              event_id: record.event_id,
+              data: record.data,
+              metadata: record.metadata.merge(timestamp: record.timestamp, valid_at: record.valid_at)
+            )
+        rescue NameError
+          Event.new(
             event_id: record.event_id,
-            metadata: record.metadata.merge(
-              timestamp: record.timestamp,
-              valid_at: record.valid_at,
-            ),
-            data:     record.data,
+            data: record.data,
+            metadata:
+              record.metadata.merge(
+                timestamp: record.timestamp,
+                valid_at: record.valid_at,
+                event_type: record.event_type
+              )
           )
         end
       end

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

@@ -6,38 +6,38 @@ module RubyEventStore
       class Encryption
         class Leaf
           def self.===(hash)
-            hash.keys.sort.eql? %i(cipher identifier iv)
+            hash.keys.sort.eql? %i[cipher identifier iv]
           end
         end
         private_constant :Leaf
 
         class MissingEncryptionKey < StandardError
           def initialize(key_identifier)
-            super %Q|Could not find encryption key for '#{key_identifier}'|
+            super "Could not find encryption key for '#{key_identifier}'"
           end
         end
 
-        def initialize(key_repository, serializer: YAML, forgotten_data: ForgottenData.new)
+        def initialize(key_repository, serializer: Serializers::YAML, forgotten_data: ForgottenData.new)
           @key_repository = key_repository
           @serializer = serializer
           @forgotten_data = forgotten_data
         end
 
         def dump(record)
-          data        = record.data
-          metadata    = record.metadata.dup
+          data = record.data
+          metadata = record.metadata.dup
           event_class = Object.const_get(record.event_type)
 
-          crypto_description    = encryption_metadata(data, encryption_schema(event_class))
+          crypto_description = encryption_metadata(data, encryption_schema(event_class))
           metadata[:encryption] = crypto_description unless crypto_description.empty?
 
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: record.event_type,
-            data:       encrypt_data(deep_dup(data), crypto_description),
-            metadata:   metadata,
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: encrypt_data(deep_dup(data), crypto_description),
+            metadata: metadata,
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
 
@@ -46,16 +46,17 @@ module RubyEventStore
           crypto_description = Hash(metadata.delete(:encryption))
 
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: record.event_type,
-            data:       decrypt_data(record.data, crypto_description),
-            metadata:   metadata,
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: decrypt_data(record.data, crypto_description),
+            metadata: metadata,
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
 
         private
+
         attr_reader :key_repository, :serializer, :forgotten_data
 
         def encryption_schema(event_class)
@@ -64,9 +65,7 @@ module RubyEventStore
 
         def deep_dup(hash)
           duplicate = hash.dup
-          duplicate.each do |k, v|
-            duplicate[k] = v.instance_of?(Hash) ? deep_dup(v) : v
-          end
+          duplicate.each { |k, v| duplicate[k] = v.instance_of?(Hash) ? deep_dup(v) : v }
           duplicate
         end
 
@@ -79,11 +78,7 @@ module RubyEventStore
               key_identifier = value.call(data)
               encryption_key = key_repository.key_of(key_identifier)
               raise MissingEncryptionKey.new(key_identifier) unless encryption_key
-              acc[key] = {
-                cipher: encryption_key.cipher,
-                iv: encryption_key.random_iv,
-                identifier: key_identifier,
-              }
+              acc[key] = { cipher: encryption_key.cipher, iv: encryption_key.random_iv, identifier: key_identifier }
             end
             acc
           end
@@ -122,7 +117,8 @@ module RubyEventStore
             cryptogram = data.fetch(attribute)
             return unless cryptogram
 
-            encryption_key = key_repository.key_of(meta.fetch(:identifier), cipher: meta.fetch(:cipher)) or return forgotten_data
+            encryption_key = key_repository.key_of(meta.fetch(:identifier), cipher: meta.fetch(:cipher)) or
+              return forgotten_data
             serializer.load(encryption_key.decrypt(cryptogram, meta.fetch(:iv)))
           when Hash
             decrypt_data(data.fetch(attribute), meta)

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

@@ -14,16 +14,17 @@ module RubyEventStore
 
         def load(record)
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: class_map[record.event_type] || record.event_type,
-            data:       record.data,
-            metadata:   record.metadata,
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: record.data,
+            metadata: record.metadata,
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
 
         private
+
         attr_reader :class_map
       end
     end

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