sequent 4.3.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: feea2aeb3dba28570a36615392e4ecc1037bfdfd1c2d667bcc787113e4c7fdba
-  data.tar.gz: 79dc60b21109885a56f3f68cf97185afee5692167f54db1934eaa89dc9d030de
+  metadata.gz: 1dea4b53205452eaa68007ed47688b3fa074229677186e9342265cdd7a31d4db
+  data.tar.gz: 2d342b9a013372ca99b441c4980432f642a56741746291d814c68ad60cf6c26e
 SHA512:
-  metadata.gz: bb74d9c6cbb946bab9b00cb2ea73eab80caed4737d12ce2115a6c97348ca0e9452a14280b3d0de9ecba237c201fdd8b2914382751569224c89cae92128d5d3f5
-  data.tar.gz: 5fe084735eb4df8855b8102e68d027ca828a8dd7540d577b6e0a97616bbd22815432e684f20d48d04ad111db962fe935af4bff50afd8ebc7242f5c15f01b97a7
+  metadata.gz: cea76a7429f29dcff3e73789f608c968030ade74446493effcf6cf6b51f39c3815da7e5ccc040cf0392a797a6978fa773b5f8f2791f907ebbb31830ab7ae56bc
+  data.tar.gz: e03569382132ffefabd44ebc973d78a2c1745291cf64ef17c0dc744bd513d5fe72c816a0cfb69da7297ddd076df81139a53058816f02bc215f58ad48c0b7bc67

data/lib/sequent/core/command_record.rb

@@ -8,7 +8,7 @@ module Sequent
     module SerializesCommand
       def command
         args = Sequent::Core::Oj.strict_load(command_json)
-        Class.const_get(command_type.to_sym).deserialize_from_json(args)
+        Class.const_get(command_type).deserialize_from_json(args)
       end
 
       def command=(command)

data/lib/sequent/core/helpers/attr_matchers/argument_serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        class ArgumentSerializer
+          class << self
+            def serialize_value(value, enclose_hash: false)
+              return value.to_s if value.respond_to?(:matches_attr?)
+              return %("#{value}") if value.is_a?(String)
+              return serialize_hash(value, enclose_hash: enclose_hash) if value.is_a?(Hash)
+
+              value
+            end
+
+            private
+
+            def serialize_hash(hash, enclose_hash:)
+              serialized = hash
+                .map do |(name, value)|
+                  "#{name}: #{serialize_value(value, enclose_hash: true)}"
+                end
+                .join(', ')
+
+              return "{#{serialized}}" if enclose_hash
+
+              serialized
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'dsl'
+require_relative 'argument_serializer'
+require_relative 'equals'
+require_relative 'not_equals'
+require_relative 'greater_than_equals'
+require_relative 'greater_than'
+require_relative 'less_than_equals'
+require_relative 'less_than'

data/lib/sequent/core/helpers/attr_matchers/dsl.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        module DSL
+          def register_matcher(name, matcher_class)
+            if respond_to?(name)
+              fail ArgumentError, "Cannot register attr matcher because it would overwrite existing method '#{name}'"
+            end
+
+            define_method(name) do |*expected|
+              matcher_class.new(*expected)
+            end
+          end
+        end
+
+        extend DSL
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/attr_matchers/equals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        Equals = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value == expected_value
+          end
+
+          def to_s
+            "eq(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :eq,
+  Sequent::Core::Helpers::AttrMatchers::Equals,
+)

data/lib/sequent/core/helpers/attr_matchers/greater_than.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        GreaterThan = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value > expected_value
+          end
+
+          def to_s
+            "gt(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :gt,
+  Sequent::Core::Helpers::AttrMatchers::GreaterThan,
+)

data/lib/sequent/core/helpers/attr_matchers/greater_than_equals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        GreaterThanEquals = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value >= expected_value
+          end
+
+          def to_s
+            "gte(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :gte,
+  Sequent::Core::Helpers::AttrMatchers::GreaterThanEquals,
+)

data/lib/sequent/core/helpers/attr_matchers/less_than.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        LessThan = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value < expected_value
+          end
+
+          def to_s
+            "lt(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :lt,
+  Sequent::Core::Helpers::AttrMatchers::LessThan,
+)

data/lib/sequent/core/helpers/attr_matchers/less_than_equals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        LessThanEquals = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value <= expected_value
+          end
+
+          def to_s
+            "lte(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :lte,
+  Sequent::Core::Helpers::AttrMatchers::LessThanEquals,
+)

data/lib/sequent/core/helpers/attr_matchers/not_equals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        NotEquals = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value != expected_value
+          end
+
+          def to_s
+            "neq(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :neq,
+  Sequent::Core::Helpers::AttrMatchers::NotEquals,
+)

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

@@ -40,19 +40,19 @@ module Sequent
 
         # module containing class methods to be added
         module ClassMethods
-          def types
-            @types ||= {}
-            return @merged_types if @merged_types
+          attr_reader :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
+          # Called when this module is included or when a class which includes this module is inherited from.
+          #
+          # All declared attrs are merged into @types in order to prevent superfluous calculation of types in a class
+          # hierarchy.
+          def initialize_types
+            @types = inherited_types
           end
 
           def attrs(args)
-            @types ||= {}
+            validate_attrs!(args)
+
             @types.merge!(args)
             associations = []
             args.each do |attribute, type|
@@ -126,6 +126,18 @@ EOS
             @upcasters.push(block)
           end
 
+          private
+
+          def inherited_types
+            merged_types = is_a?(Class) && superclass.respond_to?(:types) ? superclass.types.dup : {}
+
+            included_modules
+              .select { |m| m.include? Sequent::Core::Helpers::AttributeSupport }
+              .reduce(merged_types) do |memo, mod|
+                memo.merge(mod.types)
+              end
+          end
+
           def upcast!(hash)
             return if @upcasters.nil?
 
@@ -133,11 +145,24 @@ EOS
               upcaster.call(hash)
             end
           end
+
+          def validate_attrs!(args)
+            duplicate_attrs = types.keys & args.keys
+
+            fail ArgumentError, "Attributes already defined: #{duplicate_attrs.join(', ')}" if duplicate_attrs.any?
+          end
+
+          def inherited(subclass)
+            super
+
+            subclass.initialize_types
+          end
         end
 
         # extend host class with class methods when we're included
         def self.included(host_class)
           host_class.extend(ClassMethods)
+          host_class.initialize_types
         end
 
         def attributes

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

@@ -36,11 +36,11 @@ module Sequent
             event_class.types.keys.reject { |k| @@autoset_ignore_attributes.include?(k.to_s) }
           end
 
-          def autoset_attributes_for_events(*event_classes)
-            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}", event.send(attribute_name.to_sym))
+          def autoset_attributes_for_events(*args)
+            args.each do |arg|
+              on arg do |event|
+                self.class.event_attribute_keys(event.class).each do |attribute_name|
+                  instance_variable_set(:"@#{attribute_name}", event.public_send(attribute_name.to_sym))
                 end
               end
             end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      class MessageDispatcher
+        def initialize(message_router, context)
+          @message_router = message_router
+          @context = context
+        end
+
+        def dispatch_message(message)
+          @message_router
+            .match_message(message)
+            .each { |handler| @context.instance_exec(message, &handler) }
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative 'message_handler_option_registry'
+require_relative 'message_router'
+require_relative 'message_dispatcher'
+
 module Sequent
   module Core
     module Helpers
@@ -36,29 +40,79 @@ module Sequent
       #
       module MessageHandler
         module ClassMethods
-          def on(*message_classes, &block)
-            message_classes.each do |message_class|
-              message_mapping[message_class] ||= []
-              message_mapping[message_class] << block
+          def on(*args, **opts, &block)
+            OnArgumentsValidator.validate_arguments!(*args)
+
+            message_matchers = args.map { |arg| MessageMatchers::ArgumentCoercer.coerce_argument(arg) }
+
+            message_router.register_matchers(
+              *message_matchers,
+              block,
+            )
+
+            opts.each do |name, value|
+              option_registry.call_option(self, name, message_matchers, value)
             end
           end
 
+          def option(name, &block)
+            option_registry.register_option(name, block)
+          end
+
           def message_mapping
-            @message_mapping ||= {}
+            message_router
+              .routes
+              .select { |matcher, _handlers| matcher.is_a?(MessageMatchers::InstanceOf) }
+              .map { |k, v| [k.expected_class, v] }
+              .to_h
           end
 
           def handles_message?(message)
-            message_mapping.keys.include? message.class
+            message_router.matches_message?(message)
+          end
+
+          def message_router
+            @message_router ||= MessageRouter.new
+          end
+        end
+
+        class OnArgumentsValidator
+          class << self
+            def validate_arguments!(*args)
+              fail ArgumentError, "Must provide at least one argument to 'on'" if args.empty?
+
+              duplicates = args
+                .select { |arg| args.count(arg) > 1 }
+                .uniq
+
+              if duplicates.any?
+                humanized_duplicates = duplicates
+                  .map { |x| MessageMatchers::ArgumentSerializer.serialize_value(x) }
+                  .join(', ')
+
+                fail ArgumentError,
+                     "Arguments to 'on' must be unique, duplicates: #{humanized_duplicates}"
+              end
+            end
           end
         end
 
         def self.included(host_class)
           host_class.extend(ClassMethods)
+          host_class.extend(MessageMatchers)
+          host_class.extend(AttrMatchers)
+
+          host_class.class_attribute :option_registry, default: MessageHandlerOptionRegistry.new
         end
 
         def handle_message(message)
-          handlers = self.class.message_mapping[message.class]
-          handlers&.each { |handler| instance_exec(message, &handler) }
+          message_dispatcher.dispatch_message(message)
+        end
+
+        private
+
+        def message_dispatcher
+          MessageDispatcher.new(self.class.message_router, self)
         end
       end
     end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      class MessageHandlerOptionRegistry
+        attr_reader :entries
+
+        def initialize
+          clear_options
+        end
+
+        ##
+        # Registers a handler for the given option.
+        #
+        def register_option(name, handler)
+          fail ArgumentError, "Option with name '#{name}' already registered" if option_registered?(name)
+
+          @entries[name] = handler
+        end
+
+        ##
+        # Calls the options with the given arguments with `self` bound to the given context.
+        #
+        def call_option(context, name, *args)
+          handler = find_option(name)
+          context.instance_exec(*args, &handler)
+        end
+
+        ##
+        # Removes all options from the registry.
+        #
+        def clear_options
+          @entries = {}
+        end
+
+        private
+
+        ##
+        # Returns the handler for given option.
+        #
+        def find_option(name)
+          @entries[name] || fail(
+            ArgumentError,
+            "Unsupported option: '#{name}'; " \
+            "#{@entries.keys.any? ? "registered options: #{@entries.keys.join(', ')}" : 'no registered options'}",
+          )
+        end
+
+        ##
+        # Returns true when an option for the given name is registered, or false otherwise.
+        #
+        def option_registered?(name)
+          @entries.key?(name)
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/message_matchers/any.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        Any = Struct.new(:opts) do
+          include ExceptOpt
+
+          def matches_message?(message)
+            return false if excluded?(message)
+
+            true
+          end
+
+          def to_s
+            "any#{matcher_arguments}"
+          end
+
+          private
+
+          def matcher_arguments
+            "(except: #{except})" if except
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::MessageMatchers.register_matcher(
+  :any,
+  Sequent::Core::Helpers::MessageMatchers::Any,
+)

data/lib/sequent/core/helpers/message_matchers/argument_coercer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        class ArgumentCoercer
+          class << self
+            def coerce_argument(arg)
+              fail ArgumentError, 'Cannot coerce nil argument' if arg.nil?
+
+              return MessageMatchers::InstanceOf.new(arg) if [Class, Module].include?(arg.class)
+              return arg if arg.respond_to?(:matches_message?)
+
+              fail ArgumentError,
+                   "Can't coerce argument '#{arg}'; " \
+                   'must be either a Class, Module or message matcher (respond to :matches_message?)'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/message_matchers/argument_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        class ArgumentSerializer
+          class << self
+            def serialize_value(value)
+              return value.to_s if value.respond_to?(:matches_message?)
+              return %("#{value}") if value.is_a?(String)
+
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/message_matchers/dsl.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        module DSL
+          def register_matcher(name, matcher_class)
+            if respond_to?(name)
+              fail ArgumentError, "Cannot register message matcher because it would overwrite existing method '#{name}'"
+            end
+
+            define_method(name) do |*expected|
+              matcher_class.new(*expected)
+            end
+          end
+        end
+
+        extend DSL
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/message_matchers/except_opt.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        module ExceptOpt
+          private
+
+          def excluded?(message)
+            [except]
+              .flatten
+              .compact
+              .any? { |x| message.is_a?(x) }
+          end
+
+          def except
+            opts.try(:[], :except)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/message_matchers/has_attrs.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        HasAttrs = Struct.new(:message_matcher, :expected_attrs) do
+          def initialize(message_matcher, expected_attrs)
+            super
+
+            fail ArgumentError, 'Missing required message matcher' if message_matcher.nil?
+            fail ArgumentError, 'Missing required expected attrs' if expected_attrs.blank?
+
+            self.message_matcher = ArgumentCoercer.coerce_argument(message_matcher)
+          end
+
+          def matches_message?(message)
+            message_matcher.matches_message?(message) &&
+              matches_attrs?(message, expected_attrs)
+          end
+
+          def to_s
+            'has_attrs(' \
+              "#{MessageMatchers::ArgumentSerializer.serialize_value(message_matcher)}, " \
+              "#{AttrMatchers::ArgumentSerializer.serialize_value(expected_attrs)}" \
+            ')'
+          end
+
+          private
+
+          def matches_attrs?(message, expected_attrs, path = [])
+            expected_attrs.all? do |(name, expected_value)|
+              matches_attr?(message, expected_value, path.dup.push(name))
+            end
+          end
+
+          def matches_attr?(message, expected_value, path)
+            return matches_attrs?(message, expected_value, path) if expected_value.is_a?(Hash)
+
+            expected_value = AttrMatchers::Equals.new(expected_value) unless expected_value.respond_to?(:matches_attr?)
+            value = path.reduce(message) { |memo, p| memo.public_send(p) }
+
+            expected_value.matches_attr?(value)
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::MessageMatchers.register_matcher(
+  :has_attrs,
+  Sequent::Core::Helpers::MessageMatchers::HasAttrs,
+)

data/lib/sequent/core/helpers/message_matchers/instance_of.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        InstanceOf = Struct.new(:expected_class) do
+          def matches_message?(message)
+            message.instance_of?(expected_class)
+          end
+
+          def to_s
+            expected_class
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::MessageMatchers.register_matcher(
+  :instance_of,
+  Sequent::Core::Helpers::MessageMatchers::InstanceOf,
+)

data/lib/sequent/core/helpers/message_matchers/is_a.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        IsA = Struct.new(:expected_class, :opts) do
+          include ExceptOpt
+
+          def matches_message?(message)
+            message.is_a?(expected_class) unless excluded?(message)
+          end
+
+          def to_s
+            "is_a(#{matcher_arguments})"
+          end
+
+          private
+
+          def matcher_arguments
+            arguments = expected_class.to_s
+            arguments += ", except: #{except}" if except
+            arguments
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::MessageMatchers.register_matcher(
+  :is_a,
+  Sequent::Core::Helpers::MessageMatchers::IsA,
+)

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'dsl'
+require_relative 'argument_coercer'
+require_relative 'argument_serializer'
+require_relative 'except_opt'
+require_relative 'instance_of'
+require_relative 'is_a'
+require_relative 'has_attrs'
+require_relative 'any'

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative './attr_matchers/attr_matchers'
+require_relative './message_matchers/message_matchers'
+
+module Sequent
+  module Core
+    module Helpers
+      class MessageRouter
+        attr_reader :routes
+
+        def initialize
+          clear_routes
+        end
+
+        ##
+        # Registers a handler for the given matchers.
+        #
+        # A matcher must implement #matches_message?(message) and return a truthy value when it matches,
+        # or a falsey value otherwise.
+        #
+        def register_matchers(*matchers, handler)
+          matchers.each do |matcher|
+            @routes[matcher] << handler
+          end
+        end
+
+        ##
+        # Returns a set of handlers that match the given message, or an empty set when none match.
+        #
+        def match_message(message)
+          @routes
+            .reduce(Set.new) do |memo, (matcher, handlers)|
+              memo = memo.merge(handlers) if matcher.matches_message?(message)
+              memo
+            end
+        end
+
+        ##
+        # Returns true when there is at least one handler for the given message, or false otherwise.
+        #
+        def matches_message?(message)
+          match_message(message).any?
+        end
+
+        ##
+        # Removes all routes from the router.
+        #
+        def clear_routes
+          @routes = Hash.new { |h, k| h[k] = Set.new }
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/workflow.rb

@@ -13,7 +13,7 @@ module Sequent
         Workflows << subclass
       end
 
-      def self.on(*message_classes, &block)
+      def self.on(*args, **opts, &block)
         decorated_block = ->(event) do
           begin
             old_event = CurrentEvent.current
@@ -23,7 +23,7 @@ module Sequent
             CurrentEvent.current = old_event
           end
         end
-        super(*message_classes, &decorated_block)
+        super(*args, **opts, &decorated_block)
       end
 
       def execute_commands(*commands)

data/lib/sequent/test/command_handler_helpers.rb

@@ -11,8 +11,8 @@ module Sequent
     # This provides a nice DSL for event based testing of your CommandHandler like
     #
     # given_events InvoiceCreatedEvent.new(args)
-    # when_command PayInvoiceCommand(args)
-    # then_events InvoicePaidEvent(args)
+    # when_command PayInvoiceCommand.new(args)
+    # then_events InvoicePaidEvent.new(args)
     #
     # Example for Rspec config
     #

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sequent
-  VERSION = '4.3.0'
+  VERSION = '5.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Lars Vonk
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-21 00:00:00.000000000 Z
+date: 2022-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -21,9 +21,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -31,9 +31,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -41,9 +41,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -51,9 +51,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: bcrypt
   requirement: !ruby/object:Gem::Requirement
@@ -333,6 +333,15 @@ files:
 - lib/sequent/core/ext/ext.rb
 - lib/sequent/core/helpers/array_with_type.rb
 - lib/sequent/core/helpers/association_validator.rb
+- lib/sequent/core/helpers/attr_matchers/argument_serializer.rb
+- lib/sequent/core/helpers/attr_matchers/attr_matchers.rb
+- lib/sequent/core/helpers/attr_matchers/dsl.rb
+- lib/sequent/core/helpers/attr_matchers/equals.rb
+- lib/sequent/core/helpers/attr_matchers/greater_than.rb
+- lib/sequent/core/helpers/attr_matchers/greater_than_equals.rb
+- lib/sequent/core/helpers/attr_matchers/less_than.rb
+- lib/sequent/core/helpers/attr_matchers/less_than_equals.rb
+- lib/sequent/core/helpers/attr_matchers/not_equals.rb
 - lib/sequent/core/helpers/attribute_support.rb
 - lib/sequent/core/helpers/autoset_attributes.rb
 - lib/sequent/core/helpers/boolean_validator.rb
@@ -343,7 +352,19 @@ files:
 - lib/sequent/core/helpers/equal_support.rb
 - lib/sequent/core/helpers/helpers.rb
 - lib/sequent/core/helpers/mergable.rb
+- lib/sequent/core/helpers/message_dispatcher.rb
 - lib/sequent/core/helpers/message_handler.rb
+- lib/sequent/core/helpers/message_handler_option_registry.rb
+- lib/sequent/core/helpers/message_matchers/any.rb
+- lib/sequent/core/helpers/message_matchers/argument_coercer.rb
+- lib/sequent/core/helpers/message_matchers/argument_serializer.rb
+- lib/sequent/core/helpers/message_matchers/dsl.rb
+- lib/sequent/core/helpers/message_matchers/except_opt.rb
+- lib/sequent/core/helpers/message_matchers/has_attrs.rb
+- lib/sequent/core/helpers/message_matchers/instance_of.rb
+- lib/sequent/core/helpers/message_matchers/is_a.rb
+- lib/sequent/core/helpers/message_matchers/message_matchers.rb
+- lib/sequent/core/helpers/message_router.rb
 - lib/sequent/core/helpers/param_support.rb
 - lib/sequent/core/helpers/secret.rb
 - lib/sequent/core/helpers/string_support.rb