hakumi_components 0.1.18.pre → 0.1.19.pre

data/lib/hakumi_components/rails/validation_mapper.rb

@@ -1,35 +1,19 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Rails
-    # Maps Rails ActiveModel validations to frontend validation rules
-    # compatible with Hakumi's ValidationManager (JavaScript)
-    #
-    # @example
-    #   class User < ApplicationRecord
-    #     validates :email, presence: true, length: { maximum: 255 }
-    #   end
-    #
-    #   ValidationMapper.to_frontend_rules(user, :email)
-    #   # => [
-    #   #   { required: true, message: "Email can't be blank" },
-    #   #   { maxLength: { value: 255 }, message: "Email is too long (maximum is 255 characters)" }
-    #   # ]
     class ValidationMapper
       class << self
-        # Convert Rails validations to frontend validation rules
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol] Attribute name
-        # @return [Array<Hash>] Array of validation rules for frontend
-        def to_frontend_rules(object, attribute)
-          return [] unless object
-          return [] unless object.class.respond_to?(:validators_on)
+        extend T::Sig
 
-          validators = object.class.validators_on(attribute)
+        sig { params(object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
+        def to_frontend_rules(object, attribute)
+          reflection = ModelReflection.for(object)
+          validators = reflection.validators_for(attribute)
           return [] if validators.empty?
 
-          rules = Array.new
+          rules = T.let([], T::Array[Types::ValidationRule])
 
           validators.each do |validator|
             mapped_rules = map_validator(validator, object, attribute)
@@ -39,20 +23,18 @@ module HakumiComponents
           rules.compact
         end
 
-        # Merge manual rules with auto-detected rules
-        # Manual rules take priority over auto-detected ones for the same validation type
-        #
-        # @param manual_rules [Array<Hash>, nil] User-provided rules
-        # @param auto_rules [Array<Hash>] Auto-detected rules from validators
-        # @return [Array<Hash>] Merged rules with manual rules taking priority
+        sig do
+          params(
+            manual_rules: T.nilable(T::Array[Types::ValidationRule]),
+            auto_rules: T::Array[Types::ValidationRule]
+          ).returns(T::Array[Types::ValidationRule])
+        end
         def merge_rules(manual_rules, auto_rules)
           return auto_rules if manual_rules.nil? || manual_rules.empty?
-          return manual_rules if auto_rules.nil? || auto_rules.empty?
+          return manual_rules if auto_rules.empty?
 
-          # Get rule types from manual rules
           manual_types = manual_rules.map { |rule| extract_rule_type(rule) }.compact
 
-          # Filter out auto-detected rules that have the same type as manual rules
           merged = manual_rules.dup
           auto_rules.each do |auto_rule|
             type = extract_rule_type(auto_rule)
@@ -64,15 +46,19 @@ module HakumiComponents
 
         private
 
-        # Extract the validation type from a rule
-        # Rules have format: { required: true, message: "..." }
-        # or { minLength: { value: 3 }, message: "..." }
+        sig { params(rule: Types::ValidationRule).returns(T.nilable(Symbol)) }
         def extract_rule_type(rule)
-          # The first key that isn't :message is the rule type
-          (rule.keys - [ :message ]).first
+          key = (rule.keys - [ :message ]).first
+          key.is_a?(Symbol) ? key : nil
         end
 
-        # Map a single validator to frontend rule(s)
+        sig do
+          params(
+            validator: ActiveModel::Validator,
+            object: T.untyped,
+            attribute: Symbol
+          ).returns(T.nilable(T::Array[Types::ValidationRule]))
+        end
         def map_validator(validator, object, attribute)
           case validator
           when ActiveModel::Validations::PresenceValidator
@@ -95,16 +81,10 @@ module HakumiComponents
             map_acceptance(validator, object, attribute)
           when ActiveModel::Validations::AbsenceValidator
             map_absence(validator, object, attribute)
-          when defined?(ActiveRecord) && ActiveRecord::Validations::PresenceValidator
-            map_presence(validator, object, attribute)
-          else
-            # Unknown validator type - skip for now
-            # Can be extended by adding more cases
-            nil
           end
         end
 
-        # Map presence validation to required rule
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_presence(validator, object, attribute)
           [ {
             required: true,
@@ -112,25 +92,24 @@ module HakumiComponents
           } ]
         end
 
-        # Map length validation to minLength/maxLength rules
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_length(validator, object, attribute)
-          rules = Array.new
+          rules = T.let([], T::Array[Types::ValidationRule])
           options = validator.options
 
-          # Exact length
           exact = options[:is]
-          if exact
+          if exact.is_a?(Numeric)
             rules << {
               minLength: { value: exact },
               maxLength: { value: exact },
               message: validation_message(object, attribute, :wrong_length, { count: exact }, options)
             }
-
             return rules
           end
 
-          # Minimum length
-          min = options[:minimum] || (options[:in]&.min if options[:in].respond_to?(:min))
+          min_val = options[:minimum]
+          in_range = options[:in]
+          min = min_val.is_a?(Numeric) ? min_val : (in_range.is_a?(Range) ? in_range.min : nil)
           if min
             rules << {
               minLength: { value: min },
@@ -138,8 +117,8 @@ module HakumiComponents
             }
           end
 
-          # Maximum length
-          max = options[:maximum] || options[:is] || (options[:in]&.max if options[:in].respond_to?(:max))
+          max_val = options[:maximum]
+          max = max_val.is_a?(Numeric) ? max_val : (in_range.is_a?(Range) ? in_range.max : nil)
           if max
             rules << {
               maxLength: { value: max },
@@ -150,73 +129,47 @@ module HakumiComponents
           rules
         end
 
-        # Map numericality validation to min/max rules
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_numericality(validator, object, attribute)
-          rules = Array.new
+          rules = T.let([], T::Array[Types::ValidationRule])
           options = validator.options
 
-          # Minimum value (inclusive)
-          if options[:greater_than_or_equal_to]
+          gte = options[:greater_than_or_equal_to]
+          if gte.is_a?(Numeric)
             rules << {
-              min: { value: options[:greater_than_or_equal_to] },
-              message: validation_message(
-                object,
-                attribute,
-                :greater_than_or_equal_to,
-                { count: options[:greater_than_or_equal_to] },
-                options
-              )
+              min: { value: gte },
+              message: validation_message(object, attribute, :greater_than_or_equal_to, { count: gte }, options)
             }
           end
 
-          # Minimum value (exclusive) - add 1 for frontend
-          if options[:greater_than]
-            min_value = options[:greater_than] + 1
+          gt = options[:greater_than]
+          if gt.is_a?(Numeric)
             rules << {
-              min: { value: min_value },
-              message: validation_message(
-                object,
-                attribute,
-                :greater_than,
-                { count: options[:greater_than] },
-                options
-              )
+              min: { value: gt + 1 },
+              message: validation_message(object, attribute, :greater_than, { count: gt }, options)
             }
           end
 
-          # Maximum value (inclusive)
-          if options[:less_than_or_equal_to]
+          lte = options[:less_than_or_equal_to]
+          if lte.is_a?(Numeric)
             rules << {
-              max: { value: options[:less_than_or_equal_to] },
-              message: validation_message(
-                object,
-                attribute,
-                :less_than_or_equal_to,
-                { count: options[:less_than_or_equal_to] },
-                options
-              )
+              max: { value: lte },
+              message: validation_message(object, attribute, :less_than_or_equal_to, { count: lte }, options)
             }
           end
 
-          # Maximum value (exclusive) - subtract 1 for frontend
-          if options[:less_than]
-            max_value = options[:less_than] - 1
+          lt = options[:less_than]
+          if lt.is_a?(Numeric)
             rules << {
-              max: { value: max_value },
-              message: validation_message(
-                object,
-                attribute,
-                :less_than,
-                { count: options[:less_than] },
-                options
-              )
+              max: { value: lt - 1 },
+              message: validation_message(object, attribute, :less_than, { count: lt }, options)
             }
           end
 
           rules
         end
 
-        # Map format validation to pattern/email/url rule
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_format(validator, object, attribute)
           options = validator.options
           regex = options[:with]
@@ -224,7 +177,6 @@ module HakumiComponents
 
           regex_source = regex.source
 
-          # Detect email pattern
           if email_regex?(regex_source) || attribute.to_s.match?(/email/i)
             return [ {
               email: true,
@@ -232,7 +184,6 @@ module HakumiComponents
             } ]
           end
 
-          # Detect URL pattern
           if url_regex?(regex_source) || attribute.to_s.match?(/url|website|link/i)
             return [ {
               url: true,
@@ -240,8 +191,6 @@ module HakumiComponents
             } ]
           end
 
-          # Generic pattern rule
-          # Remove anchors (\A, \z, ^, $) as HTML pattern adds them implicitly
           pattern = regex_source.gsub(/\A(\\A|\^)|(\$|\\z)\z/, "")
 
           [ {
@@ -250,7 +199,7 @@ module HakumiComponents
           } ]
         end
 
-        # Map confirmation validation to match rule
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_confirmation(validator, object, attribute)
           [ {
             match: { field: "#{attribute}_confirmation" },
@@ -258,25 +207,25 @@ module HakumiComponents
           } ]
         end
 
-        # Map comparison validation to comparison rule
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_comparison(validator, object, attribute)
           options = validator.options
-          rules = Array.new
+          rules = T.let([], T::Array[Types::ValidationRule])
 
-          comparison_keys = %i[
+          comparison_keys = T.let(%i[
             greater_than
             greater_than_or_equal_to
             equal_to
             less_than
             less_than_or_equal_to
             other_than
-          ]
+          ], T::Array[Symbol])
 
           comparison_keys.each do |key|
             next unless options.key?(key)
 
             target = options[key]
-            comparison = build_comparison_target(target, object)
+            comparison = build_comparison_target(target)
             next unless comparison
 
             message_options = comparison_message_options(target, object, comparison)
@@ -289,33 +238,31 @@ module HakumiComponents
           rules
         end
 
-        # Map inclusion validation to enum rule
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_inclusion(validator, object, attribute)
           options = validator.options
-          values = options[:in] || options[:within]
-
-          return [] unless values
+          collection = validator_collection(options)
+          return [] unless collection
 
           [ {
-            enum: { values: values.to_a },
+            enum: { values: collection },
             message: validation_message(object, attribute, :inclusion, {}, options)
           } ]
         end
 
-        # Map exclusion validation to forbidden values rule
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_exclusion(validator, object, attribute)
           options = validator.options
-          values = options[:in] || options[:within]
-
-          return [] unless values
+          collection = validator_collection(options)
+          return [] unless collection
 
           [ {
-            exclusion: { values: values.to_a },
+            exclusion: { values: collection },
             message: validation_message(object, attribute, :exclusion, {}, options)
           } ]
         end
 
-        # Map acceptance validation to required rule
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_acceptance(validator, object, attribute)
           [ {
             required: true,
@@ -323,7 +270,7 @@ module HakumiComponents
           } ]
         end
 
-        # Map absence validation to absent rule (field must be blank)
+        sig { params(validator: ActiveModel::Validator, object: T.untyped, attribute: Symbol).returns(T::Array[Types::ValidationRule]) }
         def map_absence(validator, object, attribute)
           [ {
             absent: true,
@@ -331,93 +278,109 @@ module HakumiComponents
           } ]
         end
 
-        # Check if regex matches email pattern
+        sig { params(options: Types::ValidatorOptions).returns(T.nilable(Types::ValidationList)) }
+        def validator_collection(options)
+          values = options[:in] || options[:within]
+          return values if values.is_a?(Array)
+          return values.to_a if values.is_a?(Range)
+
+          nil
+        end
+
+        sig { params(regex_source: String).returns(T::Boolean) }
         def email_regex?(regex_source)
-          # Common email regex patterns
           regex_source.match?(/@.*\./) || regex_source.include?("EMAIL")
         end
 
-        # Check if regex matches URL pattern
+        sig { params(regex_source: String).returns(T::Boolean) }
         def url_regex?(regex_source)
-          # Common URL regex patterns
           regex_source.match?(/https?|:\/\//) || regex_source.include?("URL")
         end
 
-        # Humanize attribute name
+        sig { params(attribute: T.any(Symbol, String)).returns(String) }
         def humanize(attribute)
           attribute.to_s.humanize
         end
 
-        # Use Rails' error message generation to honor I18n and custom messages
+        sig do
+          params(
+            object: T.untyped,
+            attribute: Symbol,
+            type: Symbol,
+            options: Types::MessageOptions,
+            validator_options: Types::ValidatorOptions
+          ).returns(String)
+        end
         def validation_message(object, attribute, type, options, validator_options)
-          return fallback_message(attribute, type, options, validator_options) unless object&.respond_to?(:errors)
-          return fallback_message(attribute, type, options, validator_options) if anonymous_class?(object)
-
-          value = object.respond_to?(attribute) ? object.public_send(attribute) : nil
-          message = object.errors.generate_message(
-            attribute,
-            type,
-            options.merge(value: value, message: validator_options[:message])
-          )
+          reflection = ModelReflection.for(object)
+          errors_obj = reflection.errors
+          return fallback_message(attribute, type, options, validator_options) unless errors_obj
+          return fallback_message(attribute, type, options, validator_options) if reflection.anonymous_class?
 
-          if object.errors.respond_to?(:full_message) && object.class.name && !object.class.name.empty?
-            object.errors.full_message(attribute, message)
+          value = reflection.attribute_value(attribute)
+          merge_opts = options.merge(value: value, message: validator_options[:message])
+          message = errors_obj.generate_message(attribute, type, merge_opts)
+
+          class_name = object.class.name
+          if errors_obj.respond_to?(:full_message) && class_name && !class_name.empty?
+            errors_obj.full_message(attribute, message)
           else
             message
           end
         end
 
+        sig { params(object: T.untyped).returns(T::Boolean) }
         def anonymous_class?(object)
-          class_name = object.class.name
-          class_name.nil? || class_name.empty?
+          ModelReflection.for(object).anonymous_class?
         end
 
-        # Build comparison target from validator option value
-        #
-        # @param target [Symbol, String, Proc, Object] The comparison target value
-        # @param _object [Object] The model object (unused, Procs are not evaluated)
-        # @return [Hash, nil] Hash with :field or :value key, or nil if cannot be used client-side
-        #
-        # @note Procs are always ignored (return nil) because they cannot be reliably
-        #   evaluated on the client-side. For field comparisons, use Symbol references:
-        #   `comparison: { greater_than: :start_date }` instead of Procs.
-        def build_comparison_target(target, _object)
+        sig { params(target: Types::ValidatorOptionValue).returns(T.nilable(Types::ComparisonOperand)) }
+        def build_comparison_target(target)
           case target
           when Symbol, String
             { field: target.to_s }
-          when Proc
-            # Procs cannot be evaluated reliably on client-side
-            # Skip this validation rule for frontend
-            nil
-          else
+          when Numeric
             { value: target }
+          else
+            nil
           end
         end
 
+        sig { params(target: Types::ValidatorOptionValue, object: T.untyped, comparison: Types::ComparisonOperand).returns(Types::MessageOptions) }
         def comparison_message_options(target, object, comparison)
           if comparison[:field]
-            {
-              count: humanize(comparison[:field])
-            }
+            field = comparison[:field]
+            return { count: humanize(field) } if field.is_a?(String)
+
+            {}
           else
             resolved = resolve_comparison_value(target, object)
-            {
-              count: resolved
-            }
+            { count: resolved }
           end
         end
 
+        sig { params(target: Types::ValidatorOptionValue, object: T.untyped).returns(T.nilable(Types::ValidationComparable)) }
         def resolve_comparison_value(target, object)
-          return object.public_send(target) if target.is_a?(Symbol) && object&.respond_to?(target)
-          return target.call(object) if target.respond_to?(:call)
-
-          target
+          if target.is_a?(Symbol) && object&.respond_to?(target)
+            result = ModelReflection.for(object).attribute_value(target)
+            result.is_a?(Numeric) ? result : result.to_s
+          elsif target.is_a?(Numeric)
+            target
+          elsif target.is_a?(String)
+            target
+          end
         rescue StandardError
           nil
         end
 
-        # Fallback for standalone objects or anonymous classes where Rails can't build model-based messages.
-        # This keeps validations usable without requiring ActiveRecord models.
+        sig do
+          params(
+            attribute: T.any(Symbol, String),
+            type: Symbol,
+            options: Types::MessageOptions,
+            validator_options: Types::ValidatorOptions
+          ).returns(String)
+        end
         def fallback_message(attribute, type, options, validator_options)
           message = validator_options[:message]
           return message if message.is_a?(String)
@@ -439,43 +402,27 @@ module HakumiComponents
           "#{humanize(attribute)} #{translated}"
         end
 
+        sig { params(type: Symbol, options: Types::MessageOptions).returns(String) }
         def fallback_message_text(type, options)
           count = options[:count]
           case type
-          when :blank
-            "can't be blank"
-          when :too_short
-            "is too short (minimum is #{count} characters)"
-          when :too_long
-            "is too long (maximum is #{count} characters)"
-          when :wrong_length
-            "is the wrong length (should be #{count} characters)"
-          when :greater_than_or_equal_to
-            "must be greater than or equal to #{count}"
-          when :greater_than
-            "must be greater than #{count}"
-          when :less_than_or_equal_to
-            "must be less than or equal to #{count}"
-          when :less_than
-            "must be less than #{count}"
-          when :equal_to
-            "must be equal to #{count}"
-          when :other_than
-            "must be other than #{count}"
-          when :confirmation
-            "doesn't match #{options[:attribute]}"
-          when :inclusion
-            "is not included in the list"
-          when :exclusion
-            "is reserved"
-          when :accepted
-            "must be accepted"
-          when :present
-            "must be blank"
-          when :invalid
-            "is invalid"
-          else
-            type.to_s.tr("_", " ")
+          when :blank then "can't be blank"
+          when :too_short then "is too short (minimum is #{count} characters)"
+          when :too_long then "is too long (maximum is #{count} characters)"
+          when :wrong_length then "is the wrong length (should be #{count} characters)"
+          when :greater_than_or_equal_to then "must be greater than or equal to #{count}"
+          when :greater_than then "must be greater than #{count}"
+          when :less_than_or_equal_to then "must be less than or equal to #{count}"
+          when :less_than then "must be less than #{count}"
+          when :equal_to then "must be equal to #{count}"
+          when :other_than then "must be other than #{count}"
+          when :confirmation then "doesn't match #{options[:attribute]}"
+          when :inclusion then "is not included in the list"
+          when :exclusion then "is reserved"
+          when :accepted then "must be accepted"
+          when :present then "must be blank"
+          when :invalid then "is invalid"
+          else type.to_s.tr("_", " ")
           end
         end
       end

data/lib/hakumi_components/rails.rb

@@ -1,5 +1,7 @@
+# typed: strict
 # frozen_string_literal: true
 
+require_relative "rails/model_reflection"
 require_relative "rails/validation_introspection"
 require_relative "rails/attribute_introspection"
 require_relative "rails/validation_mapper"