ruby_event_store 2.3.0 → 2.4.0

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/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,37 +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(
-            event_id: record.event_id,
-            data:     record.data,
-            metadata: record.metadata.merge(
-              timestamp: record.timestamp,
-              valid_at:  record.valid_at,
-            ),
-          )
+          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,
-            data:     record.data,
-            metadata: record.metadata.merge(
-              timestamp:  record.timestamp,
-              valid_at:   record.valid_at,
-              event_type: record.event_type,
-            ),
+            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

@@ -7,13 +7,11 @@ 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,29 +51,23 @@ 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
+      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)

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