sequent 4.3.0 → 6.0.0

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/helpers/param_support.rb

@@ -83,6 +83,8 @@ module Sequent
             val.iso8601
           elsif val.is_a? Date
             val.iso8601
+          elsif val.is_a? Time
+            val.iso8601(Sequent.configuration.time_precision)
           else
             val
           end

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

@@ -16,6 +16,7 @@ module Sequent
           ::Boolean => ->(value) { parse_to_bool(value) },
           ::Date => ->(value) { parse_to_date(value) },
           ::DateTime => ->(value) { parse_to_date_time(value) },
+          ::Time => ->(value) { parse_to_time(value) },
           ::Sequent::Core::Helpers::ArrayWithType => ->(values, type_in_array) { parse_array(values, type_in_array) },
           ::Sequent::Core::Helpers::Secret => ->(value) { Sequent::Core::Helpers::Secret.new(value).encrypt },
         }.freeze
@@ -52,6 +53,10 @@ module Sequent
           value.is_a?(DateTime) ? value : DateTime.deserialize_from_json(value)
         end
 
+        def self.parse_to_time(value)
+          value.is_a?(Time) ? value : Time.deserialize_from_json(value)
+        end
+
         def self.parse_array(values, type_in_array)
           fail "invalid value for array(): \"#{values}\"" unless values.is_a?(Array)
 

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module Sequent
+  module Core
+    module Helpers
+      # Validates Time
+      # Automatically included when using a
+      #
+      #   attrs value: Time
+      class TimeValidator < ActiveModel::EachValidator
+        def validate_each(subject, attribute, value)
+          return if value.is_a?(Time)
+
+          Time.deserialize_from_json(value)
+        rescue StandardError
+          subject.errors.add attribute, :invalid_time
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,7 @@ module Sequent
           ::Integer => ->(value) { valid_integer?(value) },
           ::Boolean => ->(value) { valid_bool?(value) },
           ::Date => ->(value) { valid_date?(value) },
+          ::Time => ->(value) { valid_time?(value) },
           ::DateTime => ->(value) { valid_date_time?(value) },
         }.freeze
 
@@ -53,6 +54,16 @@ module Sequent
           end
         end
 
+        def self.valid_time?(value)
+          return true if value.blank?
+
+          begin
+            value.is_a?(Time) || !!Time.iso8601(value.dup)
+          rescue StandardError
+            false
+          end
+        end
+
         def self.valid_string?(value)
           return true if value.nil?
 

data/lib/sequent/core/middleware/chain.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Middleware
+      class Chain
+        attr_reader :entries
+
+        def initialize
+          clear
+        end
+
+        def add(middleware)
+          @entries.push(middleware)
+        end
+
+        def clear
+          @entries = []
+        end
+
+        def invoke(*args, &invoker)
+          chain = @entries.dup
+
+          traverse_chain = -> do
+            if chain.empty?
+              invoker.call
+            else
+              chain.shift.call(*args, &traverse_chain)
+            end
+          end
+
+          traverse_chain.call
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/middleware/middleware.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'chain'

data/lib/sequent/core/projector.rb

@@ -86,17 +86,13 @@ module Sequent
       extend Forwardable
       include Helpers::MessageHandler
       include Migratable
+      extend ActiveSupport::DescendantsTracker
 
       def initialize(persistor = Sequent::Core::Persistors::ActiveRecordPersistor.new)
         ensure_valid!
         @persistor = persistor
       end
 
-      def self.inherited(subclass)
-        super
-        Projectors << subclass
-      end
-
       def self.replay_persistor
         nil
       end
@@ -132,22 +128,18 @@ module Sequent
     end
 
     #
-    # Utility class containing all subclasses of Projector
+    # Utility class containing all subclasses of Projector.
     #
     class Projectors
       class << self
         def projectors
-          @projectors ||= []
+          Sequent::Projector.descendants
         end
 
         def all
           projectors
         end
 
-        def <<(projector)
-          projectors << projector
-        end
-
         def find(projector_name)
           projectors.find { |c| c.name == projector_name }
         end