sequent 4.0.0 → 4.1.0

data/lib/sequent/core/event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model'
 require_relative 'helpers/string_support'
 require_relative 'helpers/equal_support'
@@ -7,16 +9,17 @@ require_relative 'helpers/copyable'
 module Sequent
   module Core
     class Event
-      include Sequent::Core::Helpers::StringSupport,
-              Sequent::Core::Helpers::EqualSupport,
-              Sequent::Core::Helpers::AttributeSupport,
-              Sequent::Core::Helpers::Copyable
+      include Sequent::Core::Helpers::Copyable
+      include Sequent::Core::Helpers::AttributeSupport
+      include Sequent::Core::Helpers::EqualSupport
+      include Sequent::Core::Helpers::StringSupport
       attrs aggregate_id: String, sequence_number: Integer, created_at: DateTime
 
       def initialize(args = {})
         update_all_attributes args
-        raise "Missing aggregate_id" unless @aggregate_id
-        raise "Missing sequence_number" unless @sequence_number
+        fail 'Missing aggregate_id' unless @aggregate_id
+        fail 'Missing sequence_number' unless @sequence_number
+
         @created_at ||= DateTime.now
       end
 
@@ -24,22 +27,24 @@ module Sequent
         result = {}
         instance_variables
           .reject { |k| payload_variables.include?(k) }
-          .select { |k| self.class.types.keys.include?(to_attribute_name(k))}
+          .select { |k| self.class.types.keys.include?(to_attribute_name(k)) }
           .each do |k|
-          result[k.to_s[1 .. -1].to_sym] = instance_variable_get(k)
+          result[k.to_s[1..-1].to_sym] = instance_variable_get(k)
         end
         result
       end
+
       protected
+
       def payload_variables
-        %i{@aggregate_id @sequence_number @created_at}
+        %i[@aggregate_id @sequence_number @created_at]
       end
 
       private
+
       def to_attribute_name(instance_variable_name)
-        instance_variable_name[1 .. -1].to_sym
+        instance_variable_name[1..-1].to_sym
       end
-
     end
 
     class SnapshotEvent < Event

data/lib/sequent/core/event_publisher.rb

@@ -1,17 +1,23 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     #
-    # EventPublisher ensures that, for every thread, events will be published in the order in which they are queued for publishing.
+    # EventPublisher ensures that, for every thread, events will be published
+    #   in the order in which they are queued for publishing.
     #
-    # This potentially introduces a wrinkle into your plans: You therefore should not split a "unit of work" across multiple threads.
+    # This potentially introduces a wrinkle into your plans:
+    #   You therefore should not split a "unit of work" across multiple threads.
     #
-    # If you want other behaviour, you are free to implement your own version of EventPublisher and configure Sequent to use it.
+    # If you want other behaviour, you are free to implement your own version of EventPublisher
+    #   and configure Sequent to use it.
     #
     class EventPublisher
       class PublishEventError < RuntimeError
         attr_reader :event_handler_class, :event
 
         def initialize(event_handler_class, event)
+          super()
           @event_handler_class = event_handler_class
           @event = event
         end
@@ -23,6 +29,7 @@ module Sequent
 
       def publish_events(events)
         return if configuration.disable_event_handlers
+
         events.each { |event| events_queue.push(event) }
         process_events
       end
@@ -35,13 +42,9 @@ module Sequent
 
       def process_events
         Sequent::Util.skip_if_already_processing(:events_queue_lock) do
-          begin
-            while(!events_queue.empty?) do
-              process_event(events_queue.pop)
-            end
-          ensure
-            events_queue.clear
-          end
+          process_event(events_queue.pop) until events_queue.empty?
+        ensure
+          events_queue.clear
         end
       end
 
@@ -51,11 +54,9 @@ module Sequent
         Sequent.logger.debug("[EventPublisher] Publishing event #{event.class}")
 
         configuration.event_handlers.each do |handler|
-          begin
-            handler.handle_message event
-          rescue
-            raise PublishEventError.new(handler.class, event)
-          end
+          handler.handle_message event
+        rescue StandardError
+          raise PublishEventError.new(handler.class, event)
         end
       end
 

data/lib/sequent/core/event_record.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require_relative 'sequent_oj'
-require_relative '../application_record.rb'
+require_relative '../application_record'
 
 module Sequent
   module Core
-
     # == Event Record Hooks
     #
     # These hooks are called during the life cycle of
@@ -27,7 +28,6 @@ module Sequent
     #     end
     #   end
     class EventRecordHooks
-
       # Called after assigning Sequent's event attributes to the +event_record+.
       #
       # *Params*
@@ -42,13 +42,12 @@ module Sequent
       def self.after_serialization(event_record, event)
         # noop
       end
-
     end
 
     module SerializesEvent
       def event
-        payload = Sequent::Core::Oj.strict_load(self.event_json)
-        Class.const_get(self.event_type).deserialize_from_json(payload)
+        payload = Sequent::Core::Oj.strict_load(event_json)
+        Class.const_get(event_type).deserialize_from_json(payload)
       end
 
       def event=(event)
@@ -76,7 +75,7 @@ module Sequent
     class EventRecord < Sequent::ApplicationRecord
       include SerializesEvent
 
-      self.table_name = "event_records"
+      self.table_name = 'event_records'
 
       belongs_to :stream_record
       belongs_to :command_record
@@ -98,6 +97,7 @@ module Sequent
 
       def find_origin(record)
         return find_origin(record.parent) if record.parent.present?
+
         record
       end
     end

data/lib/sequent/core/event_store.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require_relative 'event_record'
 require_relative 'sequent_oj'
 
 module Sequent
   module Core
-
     class EventStore
       include ActiveRecord::ConnectionAdapters::Quoting
       extend Forwardable
@@ -16,13 +17,13 @@ module Sequent
         attr_reader :event_hash
 
         def initialize(event_hash)
+          super()
           @event_hash = event_hash
         end
 
         def message
           "Event hash: #{event_hash.inspect}\nCause: #{cause.inspect}"
         end
-
       end
 
       def initialize
@@ -41,7 +42,7 @@ module Sequent
       #   `StreamRecord` to arrays ordered uncommitted `Event`s.
       #
       def commit_events(command, streams_with_events)
-        fail ArgumentError, "command is required" if command.nil?
+        fail ArgumentError, 'command is required' if command.nil?
 
         Sequent.logger.debug("[EventStore] Committing events for command #{command.class}")
 
@@ -61,27 +62,36 @@ module Sequent
 
         streams = Sequent.configuration.stream_record_class.where(aggregate_id: aggregate_ids)
 
-        query = aggregate_ids.uniq.map { |aggregate_id| aggregate_query(aggregate_id) }.join(" UNION ALL ")
-        events = Sequent.configuration.event_record_class.connection.select_all(query).map! do |event_hash|
+        query = aggregate_ids.uniq.map { |aggregate_id| aggregate_query(aggregate_id) }.join(' UNION ALL ')
+        events = Sequent.configuration.event_record_class.connection.select_all(query).map do |event_hash|
           deserialize_event(event_hash)
         end
 
         events
-          .group_by { |event| event.aggregate_id }
-          .map { |aggregate_id, _events| [streams.find { |stream_record| stream_record.aggregate_id == aggregate_id }.event_stream, _events] }
+          .group_by(&:aggregate_id)
+          .map do |aggregate_id, es|
+          [
+            streams.find do |stream_record|
+              stream_record.aggregate_id == aggregate_id
+            end.event_stream,
+            es,
+          ]
+        end
       end
 
       def aggregate_query(aggregate_id)
-        %Q{(
-SELECT event_type, event_json
-  FROM #{quote_table_name Sequent.configuration.event_record_class.table_name} AS o
-WHERE aggregate_id = #{quote(aggregate_id)}
-AND sequence_number >= COALESCE((SELECT MAX(sequence_number)
-                                 FROM #{quote_table_name Sequent.configuration.event_record_class.table_name} AS i
-                                 WHERE event_type = #{quote Sequent.configuration.snapshot_event_class.name}
-                                   AND i.aggregate_id = #{quote(aggregate_id)}), 0)
-ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuration.snapshot_event_class.name} THEN 0 ELSE 1 END) ASC
-)}
+        <<~SQL.chomp
+          (
+          SELECT event_type, event_json
+            FROM #{quote_table_name Sequent.configuration.event_record_class.table_name} AS o
+          WHERE aggregate_id = #{quote(aggregate_id)}
+          AND sequence_number >= COALESCE((SELECT MAX(sequence_number)
+                                           FROM #{quote_table_name Sequent.configuration.event_record_class.table_name} AS i
+                                           WHERE event_type = #{quote Sequent.configuration.snapshot_event_class.name}
+                                             AND i.aggregate_id = #{quote(aggregate_id)}), 0)
+          ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuration.snapshot_event_class.name} THEN 0 ELSE 1 END) ASC
+          )
+        SQL
       end
 
       def stream_exists?(aggregate_id)
@@ -97,7 +107,7 @@ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuratio
       # @param block that returns the events.
       # <b>DEPRECATED:</b> use <tt>replay_events_from_cursor</tt> instead.
       def replay_events
-        warn "[DEPRECATION] `replay_events` is deprecated in favor of `replay_events_from_cursor`"
+        warn '[DEPRECATION] `replay_events` is deprecated in favor of `replay_events_from_cursor`'
         events = yield.map { |event_hash| deserialize_event(event_hash) }
         publish_events(events)
       end
@@ -109,8 +119,7 @@ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuratio
       #
       # @param get_events lambda that returns the events cursor
       # @param on_progress lambda that gets called on substantial progress
-      def replay_events_from_cursor(block_size: 2000,
-                                    get_events:,
+      def replay_events_from_cursor(get_events:, block_size: 2000,
                                     on_progress: PRINT_PROGRESS)
         progress = 0
         cursor = get_events.call
@@ -128,7 +137,7 @@ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuratio
         on_progress[progress, true, ids_replayed]
       end
 
-      PRINT_PROGRESS = lambda do |progress, done, _|
+      PRINT_PROGRESS = ->(progress, done, _) do
         if done
           Sequent.logger.debug "Done replaying #{progress} events"
         else
@@ -142,38 +151,34 @@ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuratio
       def aggregates_that_need_snapshots(last_aggregate_id, limit = 10)
         stream_table = quote_table_name Sequent.configuration.stream_record_class.table_name
         event_table = quote_table_name Sequent.configuration.event_record_class.table_name
-        query = %Q{
-SELECT aggregate_id
-  FROM #{stream_table} stream
- WHERE aggregate_id::varchar > COALESCE(#{quote last_aggregate_id}, '')
-   AND snapshot_threshold IS NOT NULL
-   AND snapshot_threshold <= (
-         (SELECT MAX(events.sequence_number) FROM #{event_table} events WHERE events.event_type <> #{quote Sequent.configuration.snapshot_event_class.name} AND stream.aggregate_id = events.aggregate_id) -
-         COALESCE((SELECT MAX(snapshots.sequence_number) FROM #{event_table} snapshots WHERE snapshots.event_type = #{quote Sequent.configuration.snapshot_event_class.name} AND stream.aggregate_id = snapshots.aggregate_id), 0))
- ORDER BY aggregate_id
- LIMIT #{quote limit}
- FOR UPDATE
-}
+        query = <<~SQL.chomp
+          SELECT aggregate_id
+            FROM #{stream_table} stream
+           WHERE aggregate_id::varchar > COALESCE(#{quote last_aggregate_id}, '')
+             AND snapshot_threshold IS NOT NULL
+             AND snapshot_threshold <= (
+                   (SELECT MAX(events.sequence_number) FROM #{event_table} events WHERE events.event_type <> #{quote Sequent.configuration.snapshot_event_class.name} AND stream.aggregate_id = events.aggregate_id) -
+                   COALESCE((SELECT MAX(snapshots.sequence_number) FROM #{event_table} snapshots WHERE snapshots.event_type = #{quote Sequent.configuration.snapshot_event_class.name} AND stream.aggregate_id = snapshots.aggregate_id), 0))
+           ORDER BY aggregate_id
+           LIMIT #{quote limit}
+           FOR UPDATE
+        SQL
         Sequent.configuration.event_record_class.connection.select_all(query).map { |x| x['aggregate_id'] }
       end
 
       def find_event_stream(aggregate_id)
         record = Sequent.configuration.stream_record_class.where(aggregate_id: aggregate_id).first
-        if record
-          record.event_stream
-        else
-          nil
-        end
+        record&.event_stream
       end
 
       private
 
       def column_names
         @column_names ||= Sequent
-                            .configuration
-                            .event_record_class
-                            .column_names
-                            .reject { |c| c == primary_key_event_records }
+          .configuration
+          .event_record_class
+          .column_names
+          .reject { |c| c == primary_key_event_records }
       end
 
       def primary_key_event_records
@@ -181,11 +186,11 @@ SELECT aggregate_id
       end
 
       def deserialize_event(event_hash)
-        event_type = event_hash.fetch("event_type")
-        event_json = Sequent::Core::Oj.strict_load(event_hash.fetch("event_json"))
+        event_type = event_hash.fetch('event_type')
+        event_json = Sequent::Core::Oj.strict_load(event_hash.fetch('event_json'))
         resolve_event_type(event_type).deserialize_from_json(event_json)
-      rescue
-        raise DeserializeEventError.new(event_hash)
+      rescue StandardError
+        raise DeserializeEventError, event_hash
       end
 
       def resolve_event_type(event_type)
@@ -215,13 +220,15 @@ SELECT aggregate_id
         end
         connection = Sequent.configuration.event_record_class.connection
         values = event_records
-                   .map { |r| "(#{column_names.map { |c| connection.quote(r[c.to_sym]) }.join(',')})" }
-                   .join(',')
+          .map { |r| "(#{column_names.map { |c| connection.quote(r[c.to_sym]) }.join(',')})" }
+          .join(',')
         columns = column_names.map { |c| connection.quote_column_name(c) }.join(',')
-        sql = %Q{insert into #{connection.quote_table_name(Sequent.configuration.event_record_class.table_name)} (#{columns}) values #{values}}
+        sql = <<~SQL.chomp
+          insert into #{connection.quote_table_name(Sequent.configuration.event_record_class.table_name)} (#{columns}) values #{values}
+        SQL
         Sequent.configuration.event_record_class.connection.insert(sql, nil, primary_key_event_records)
       rescue ActiveRecord::RecordNotUnique
-        fail OptimisticLockingError.new
+        raise OptimisticLockingError
       end
     end
   end

data/lib/sequent/core/ext/ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Symbol
   def self.deserialize_from_json(value)
     value.blank? ? nil : value.try(:to_sym)
@@ -25,19 +27,25 @@ end
 class BigDecimal
   def self.deserialize_from_json(value)
     return nil if value.nil?
+
     BigDecimal(value)
   end
 end
 
 module Boolean
   def self.deserialize_from_json(value)
-    value.nil? ? nil : (value.present? ? value : false)
+    if value.nil?
+      nil
+    else
+      (value.present? ? value : false)
+    end
   end
 end
 
 class Date
   def self.from_params(value)
     return value if value.is_a?(Date)
+
     value.blank? ? nil : Date.iso8601(value.dup)
   rescue ArgumentError
     value

data/lib/sequent/core/helpers/array_with_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     module Helpers
@@ -5,7 +7,8 @@ module Sequent
         attr_accessor :item_type
 
         def initialize(item_type)
-          raise "needs a item_type" unless item_type
+          fail 'needs a item_type' unless item_type
+
           @item_type = item_type
         end
 

data/lib/sequent/core/helpers/association_validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model/validator'
 
 module Sequent
@@ -21,24 +23,23 @@ module Sequent
       #   validates_with Sequent::Core::AssociationValidator, associations: [:trainee]
       #
       class AssociationValidator < ActiveModel::Validator
-
         def initialize(options = {})
           super
-          raise "Must provide ':associations' to validate" unless options[:associations].present?
+          fail "Must provide ':associations' to validate" unless options[:associations].present?
         end
 
         def validate(record)
           associations = options[:associations]
           associations = [associations] unless associations.instance_of?(Array)
           associations.each do |association|
-            value = record.instance_variable_get("@#{association.to_s}")
+            value = record.instance_variable_get("@#{association}")
             if value && incorrect_type?(value, record, association)
               record.errors.add(association, "is not of type #{describe_type(record.class.types[association])}")
-            elsif value && value.is_a?(Array)
+            elsif value&.is_a?(Array)
               item_type = record.class.types.fetch(association).item_type
-              record.errors.add(association, "is invalid") unless validate_all(value, item_type).all?
-            else
-              record.errors.add(association, "is invalid") if value && value.invalid?
+              record.errors.add(association, 'is invalid') unless validate_all(value, item_type).all?
+            elsif value&.invalid?
+              record.errors.add(association, 'is invalid')
             end
           end
         end
@@ -47,6 +48,7 @@ module Sequent
 
         def incorrect_type?(value, record, association)
           return unless record.class.respond_to?(:types)
+
           type = record.class.types[association]
           if type.respond_to?(:candidate?)
             !type.candidate?(value)

data/lib/sequent/core/helpers/attribute_support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require_relative '../ext/ext'
 require_relative 'array_with_type'
@@ -38,18 +40,15 @@ module Sequent
 
         # module containing class methods to be added
         module ClassMethods
-
           def types
             @types ||= {}
-            if @merged_types
-              @merged_types
-            else
-              @merged_types = is_a?(Class) && superclass.respond_to?(:types) ? @types.merge(superclass.types) : @types
-              included_modules.select { |m| m.include? Sequent::Core::Helpers::AttributeSupport }.each do |mod|
-                @merged_types.merge!(mod.types)
-              end
-              @merged_types
+            return @merged_types if @merged_types
+
+            @merged_types = is_a?(Class) && superclass.respond_to?(:types) ? @types.merge(superclass.types) : @types
+            included_modules.select { |m| m.include? Sequent::Core::Helpers::AttributeSupport }.each do |mod|
+              @merged_types.merge!(mod.types)
             end
+            @merged_types
           end
 
           def attrs(args)
@@ -58,14 +57,15 @@ module Sequent
             associations = []
             args.each do |attribute, type|
               attr_accessor attribute
+
               if included_modules.include?(Sequent::Core::Helpers::TypeConversionSupport)
                 Sequent::Core::Helpers::DefaultValidators.for(type).add_validations_for(self, attribute)
               end
 
-              if type.class == Sequent::Core::Helpers::ArrayWithType
+              if type.instance_of?(Sequent::Core::Helpers::ArrayWithType)
                 associations << attribute
               elsif included_modules.include?(ActiveModel::Validations) &&
-                type.included_modules.include?(Sequent::Core::Helpers::AttributeSupport)
+                    type.included_modules.include?(Sequent::Core::Helpers::AttributeSupport)
                 associations << attribute
               end
             end
@@ -77,9 +77,9 @@ module Sequent
               def update_all_attributes(attrs)
                 super if defined?(super)
                 ensure_known_attributes(attrs)
-                #{@types.map { |attribute, _|
-              "@#{attribute} = attrs[:#{attribute}]"
-            }.join("\n            ")}
+                #{@types.map do |attribute, _|
+                    "@#{attribute} = attrs[:#{attribute}]"
+                  end.join("\n            ")}
                 self
               end
 EOS
@@ -87,9 +87,9 @@ EOS
             class_eval <<EOS
                def update_all_attributes_from_json(attrs)
                  super if defined?(super)
-                 #{@types.map { |attribute, type|
-              "@#{attribute} = #{type}.deserialize_from_json(attrs['#{attribute}'])"
-            }.join("\n           ")}
+                 #{@types.map do |attribute, type|
+                     "@#{attribute} = #{type}.deserialize_from_json(attrs['#{attribute}'])"
+                   end.join("\n           ")}
                end
 EOS
           end
@@ -106,17 +106,33 @@ EOS
 
           def deserialize_from_json(args)
             unless args.nil?
-              obj = allocate()
+              obj = allocate
+
+              upcast!(args)
+
               obj.update_all_attributes_from_json(args)
               obj
             end
           end
 
-
           def numeric?(object)
-            true if Float(object) rescue false
+            true if Float(object)
+          rescue StandardError
+            false
           end
 
+          def upcast(&block)
+            @upcasters ||= []
+            @upcasters.push(block)
+          end
+
+          def upcast!(hash)
+            return if @upcasters.nil?
+
+            @upcasters.each do |upcaster|
+              upcaster.call(hash)
+            end
+          end
         end
 
         # extend host class with class methods when we're included
@@ -124,11 +140,10 @@ EOS
           host_class.extend(ClassMethods)
         end
 
-
         def attributes
           hash = HashWithIndifferentAccess.new
           self.class.types.each do |name, _|
-            value = self.instance_variable_get("@#{name}")
+            value = instance_variable_get("@#{name}")
             hash[name] = if value.respond_to?(:attributes)
                            value.attributes
                          else
@@ -141,7 +156,7 @@ EOS
         def as_json(opts = {})
           hash = HashWithIndifferentAccess.new
           self.class.types.each do |name, _|
-            value = self.instance_variable_get("@#{name}")
+            value = instance_variable_get("@#{name}")
             hash[name] = if value.respond_to?(:as_json)
                            value.as_json(opts)
                          else
@@ -158,15 +173,15 @@ EOS
         def validation_errors(prefix = nil)
           result = errors.to_hash
           self.class.types.each do |field|
-            value = self.instance_variable_get("@#{field[0]}")
+            value = instance_variable_get("@#{field[0]}")
             if value.respond_to? :validation_errors
-              value.validation_errors.each { |k, v| result["#{field[0].to_s}_#{k.to_s}".to_sym] = v }
-            elsif field[1].class == ArrayWithType and value.present?
+              value.validation_errors.each { |k, v| result["#{field[0]}_#{k}".to_sym] = v }
+            elsif field[1].instance_of?(ArrayWithType) && value.present?
               value
                 .select { |val| val.respond_to?(:validation_errors) }
                 .each_with_index do |val, index|
                 val.validation_errors.each do |k, v|
-                  result["#{field[0].to_s}_#{index}_#{k.to_s}".to_sym] = v
+                  result["#{field[0]}_#{index}_#{k}".to_sym] = v
                 end
               end
             end
@@ -178,7 +193,9 @@ EOS
           return unless Sequent.configuration.strict_check_attributes_on_apply_events
 
           unknowns = attrs.keys.map(&:to_s) - self.class.types.keys.map(&:to_s)
-          raise UnknownAttributeError.new("#{self.class.name} does not specify attrs: #{unknowns.join(", ")}") if unknowns.any?
+          if unknowns.any?
+            fail UnknownAttributeError, "#{self.class.name} does not specify attrs: #{unknowns.join(', ')}"
+          end
         end
       end
     end

data/lib/sequent/core/helpers/autoset_attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     module Helpers
@@ -24,8 +26,7 @@ module Sequent
       #
       module AutosetAttributes
         module ClassMethods
-
-          @@autoset_ignore_attributes = %w{aggregate_id sequence_number created_at}
+          @@autoset_ignore_attributes = %w[aggregate_id sequence_number created_at]
 
           def set_autoset_ignore_attributes(attribute_names)
             @@autoset_ignore_attributes = attribute_names
@@ -39,7 +40,7 @@ module Sequent
             event_classes.each do |event_class|
               on event_class do |event|
                 self.class.event_attribute_keys(event_class).each do |attribute_name|
-                  instance_variable_set(:"@#{attribute_name.to_s}", event.send(attribute_name.to_sym))
+                  instance_variable_set(:"@#{attribute_name}", event.send(attribute_name.to_sym))
                 end
               end
             end
@@ -53,4 +54,3 @@ module Sequent
     end
   end
 end
-