interactor-validation 0.3.1 → 0.3.3

data/lib/interactor/validation/configuration.rb

@@ -4,16 +4,20 @@ module Interactor
   module Validation
     # Configuration class for interactor validation behavior
     class Configuration
-      attr_accessor :halt_on_first_error, :regex_timeout, :max_array_size,
+      attr_accessor :halt, :regex_timeout, :max_array_size,
                     :enable_instrumentation, :cache_regex_patterns
       attr_reader :error_mode
 
+      # Backward compatibility alias for halt_on_first_error
+      alias halt_on_first_error halt
+      alias halt_on_first_error= halt=
+
       # Available error modes:
       # - :default - Uses ActiveModel-style human-readable messages [DEFAULT]
       # - :code - Returns structured error codes (e.g., USERNAME_IS_REQUIRED)
       def initialize
         @error_mode = :default
-        @halt_on_first_error = false
+        @halt = false
         @regex_timeout = 0.1 # 100ms timeout for regex matching (ReDoS protection)
         @max_array_size = 1000 # Maximum array size for nested validation (memory protection)
         @enable_instrumentation = false # ActiveSupport::Notifications instrumentation

data/lib/interactor/validation/validates.rb

@@ -21,9 +21,11 @@ module Interactor
 
       def self.included(base)
         super
-        # Include ActiveModel::Validations first, then prepend our override
+        # Include ActiveModel::Validations first, then prepend our overrides
         base.include ActiveModel::Validations unless base.included_modules.include?(ActiveModel::Validations)
         base.singleton_class.prepend(ClassMethodsOverride)
+        # Prepend our instance method overrides to take precedence over ActiveModel
+        base.prepend(InstanceMethodsOverride)
       end
 
       module ClassMethodsOverride
@@ -88,22 +90,126 @@ module Interactor
         end
       end
 
+      # Wrapper for ActiveModel::Errors that intercepts halt: option
+      class ErrorsWrapper < SimpleDelegator
+        def initialize(errors, interactor)
+          super(errors)
+          @interactor = interactor
+        end
+
+        # Override add to intercept halt: option
+        def add(attribute, message = :invalid, options = {})
+          # Extract halt option before passing to ActiveModel
+          halt = options.delete(:halt)
+
+          # Call the original add method
+          __getobj__.add(attribute, message, **options)
+
+          # Set halt flag if requested
+          @interactor.instance_variable_set(:@halt_validation, true) if halt
+        end
+      end
+
+      # Module prepended to override ActiveModel instance methods
+      module InstanceMethodsOverride
+        # Override errors to return a wrapper that intercepts halt: option
+        def errors
+          @errors ||= ErrorsWrapper.new(super, self)
+        end
+
+        # Override ActiveModel's validate! to prevent exception-raising behavior
+        # This hook is called automatically after validate_params!
+        # Users can override this to add custom validation logic
+        # @return [void]
+        # @example
+        #   def validate!
+        #     super  # Optional: call parent implementation if needed
+        #     errors.add(:base, "Custom error") if some_condition?
+        #   end
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+        def validate!
+          # Preserve errors from validate_params! before calling super
+          # because super might trigger ActiveModel's valid? which clears errors
+          existing_error_details = errors.map do |error|
+            { attribute: error.attribute, type: error.type, options: error.options }
+          rescue ArgumentError => e
+            # For anonymous classes, accessing error properties may fail
+            raise unless e.message.include?("Class name cannot be blank")
+
+            { attribute: error.attribute, type: :invalid, options: {} }
+          end
+
+          # Skip custom validations if halt was requested
+          unless @halt_validation
+            # Call super to allow class's validate! to run and add custom errors
+            # Rescue exceptions that might be raised
+            begin
+              super
+            rescue NoMethodError
+              # No parent validate! method, which is fine
+            rescue ArgumentError => e
+              # For anonymous classes, super may fail when generating messages
+              raise unless e.message.include?("Class name cannot be blank")
+            rescue ActiveModel::ValidationError
+              # ActiveModel's validate! raises this when there are errors
+              # We handle errors differently, so just ignore this exception
+            end
+          end
+
+          # Restore errors from validate_params! and add any new ones from custom validate!
+          existing_error_details.each do |error_detail|
+            # Only add if not already present (avoid duplicates)
+            next if errors.where(error_detail[:attribute], error_detail[:type]).any?
+
+            begin
+              errors.add(error_detail[:attribute], error_detail[:type], **error_detail[:options])
+            rescue ArgumentError => e
+              # For anonymous classes, fall back to adding with message directly
+              raise unless e.message.include?("Class name cannot be blank")
+
+              message = error_detail[:options][:message] || error_detail[:type].to_s
+              errors.add(error_detail[:attribute], message)
+            end
+          end
+
+          # Reset halt flag after validation completes
+          @halt_validation = false
+
+          # Check all accumulated errors from validate_params! and this hook
+          # Fail the context if any errors exist
+          return if errors.empty?
+
+          # Use the existing formatted_errors method which handles all the edge cases
+          context.fail!(errors: formatted_errors)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
+      end
+
       private
 
       # Validates all declared parameters before execution
+      # Accumulates errors but does not fail the context
+      # The validate! hook will fail the context if there are any errors
       # @return [void]
-      # @raise [Interactor::Failure] if validation fails
       def validate_params!
         # Memoize config for performance
         @current_config = current_config
+        # Initialize halt flag (but don't reset if already set)
+        @halt_validation ||= false
 
         # Instrument validation if enabled
         instrument("validate_params.interactor_validation") do
           # Trigger ActiveModel validations first (validate callbacks)
           # This runs any custom validations defined with validate :method_name
-          # NOTE: valid? must be called BEFORE adding our custom errors
-          # because it clears the errors object
-          valid?
+          begin
+            valid?
+          rescue ArgumentError => e
+            # For anonymous classes, valid? may fail when generating messages
+            raise unless e.message.include?("Class name cannot be blank")
+          end
+
+          # Check if halt was requested during ActiveModel validations
+          return if @halt_validation || (@current_config.halt && errors.any?)
 
           # Run our custom param validations after ActiveModel validations
           self.class._param_validations.each do |param_name, rules|
@@ -111,16 +217,16 @@ module Interactor
             value = context.respond_to?(param_name) ? context.public_send(param_name) : nil
             validate_param(param_name, value, rules)
 
-            # Halt on first error if configured
-            break if @current_config.halt_on_first_error && errors.any?
+            # Halt on first error if configured or if halt was explicitly requested
+            break if @halt_validation || (@current_config.halt && errors.any?)
           end
 
-          return if errors.empty?
-
-          context.fail!(errors: formatted_errors)
+          # Don't fail here - let validate! hook handle failure
+          # This allows validate! to run and add additional custom errors
         end
       ensure
         @current_config = nil # Clear memoization
+        # Don't reset @halt_validation here - let validate! handle it
       end
 
       # Get the current configuration (instance config overrides global config)
@@ -142,6 +248,7 @@ module Interactor
       end
 
       # Validates a single parameter with the given rules
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def validate_param(param_name, value, rules)
         # Skip validation if explicitly marked
         return if rules[:_skip]
@@ -152,14 +259,25 @@ module Interactor
           return
         end
 
-        # Standard validations
+        # Standard validations - halt if requested or configured after each validation
         validate_presence(param_name, value, rules)
+        return if @halt_validation || (@current_config.halt && errors.any?)
+
         validate_boolean(param_name, value, rules)
+        return if @halt_validation || (@current_config.halt && errors.any?)
+
         validate_format(param_name, value, rules)
+        return if @halt_validation || (@current_config.halt && errors.any?)
+
         validate_length(param_name, value, rules)
+        return if @halt_validation || (@current_config.halt && errors.any?)
+
         validate_inclusion(param_name, value, rules)
+        return if @halt_validation || (@current_config.halt && errors.any?)
+
         validate_numericality(param_name, value, rules)
       end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       # Validates nested attributes in a hash or array
       def validate_nested(param_name, value, nested_rules)
@@ -350,7 +468,7 @@ module Interactor
 
       # Add error for nested validation
       # rubocop:disable Metrics/ParameterLists
-      def add_nested_error(param_name, attr_name, custom_message, error_type, index: nil, **interpolations)
+      def add_nested_error(param_name, attr_name, custom_message, error_type, index: nil, halt: false, **interpolations)
         # Build the attribute path for the error
         attribute_path = if index.nil?
                            # Hash validation: param_name.attr_name
@@ -370,6 +488,9 @@ module Interactor
         else
           errors.add(attribute_path, error_type, **interpolations)
         end
+
+        # Set halt flag if requested
+        @halt_validation = true if halt
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -562,8 +683,9 @@ module Interactor
       # @param param_name [Symbol] the parameter name
       # @param custom_message [String, nil] custom error message if provided
       # @param error_type [Symbol] the type of validation error
+      # @param halt [Boolean] if true, halts validation immediately after adding this error
       # @param interpolations [Hash] values to interpolate into the message
-      def add_error(param_name, custom_message, error_type, **interpolations)
+      def add_error(param_name, custom_message, error_type, halt: false, **interpolations)
         if current_config.error_mode == :code
           # Code mode: use custom message or generate code
           code_message = custom_message || error_code_for(error_type, **interpolations)
@@ -574,6 +696,9 @@ module Interactor
         else
           errors.add(param_name, error_type, **interpolations)
         end
+
+        # Set halt flag if requested
+        @halt_validation = true if halt
       end
 
       # Generate error code for :code mode using constants
@@ -628,9 +753,14 @@ module Interactor
           errors.map do |error|
             # Convert attribute path to uppercase, handling nested paths
             # Example: "attributes.username" -> "ATTRIBUTES.USERNAME"
-            # Example: "attributes[0].username" -> "ATTRIBUTES[0].USERNAME"
+            # Example: "attributes[0].username" -> "ATTRIBUTES[0]_USERNAME"
             param_name = format_attribute_for_code(error.attribute)
-            message = error.message
+            begin
+              message = error.message
+            rescue ArgumentError, NoMethodError
+              # For anonymous classes or other edge cases, fall back to type
+              message = error.type.to_s.upcase
+            end
 
             { code: "#{param_name}_#{message}" }
           end
@@ -672,7 +802,15 @@ module Interactor
           "#{attribute_name} #{error_message}"
         elsif error.respond_to?(:message)
           # Try to use ActiveModel's message for simple attributes
-          error.message
+          message = error.message
+          # If translation is missing, fall back to our default messages
+          if message.include?("Translation missing")
+            attribute_name = error.attribute.to_s.humanize
+            error_message = error.options[:message] || default_message_for_type(error.type, error.options)
+            "#{attribute_name} #{error_message}"
+          else
+            message
+          end
         end
       rescue ArgumentError, NoMethodError
         # Fallback for anonymous classes or other issues

data/lib/interactor/validation/version.rb

@@ -2,6 +2,6 @@
 
 module Interactor
   module Validation
-    VERSION = "0.3.1"
+    VERSION = "0.3.3"
   end
 end

data/lib/interactor/validation.rb

@@ -38,15 +38,21 @@ module Interactor
 
     def self.included(base)
       super
-      # Set up the validation hook after all modules are included
+      # Set up the validation hooks after all modules are included
       # Use class_eval to ensure we're in the right context
       base.class_eval do
+        # Register both validate_params! and validate! hooks
+        # Parameter validations run first, then custom validate! hook
         before :validate_params! if respond_to?(:before)
+        before :validate! if respond_to?(:before)
 
-        # Set up inherited hook to ensure child classes also get the before hook
+        # Set up inherited hook to ensure child classes also get the before hooks
         def self.inherited(subclass)
           super
           subclass.before :validate_params! if subclass.respond_to?(:before)
+          subclass.before :validate! if subclass.respond_to?(:before)
+          # Also prepend InstanceMethodsOverride to child classes
+          subclass.prepend(Interactor::Validation::Validates::InstanceMethodsOverride)
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interactor-validation
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Wilson Anciro
@@ -13,28 +13,28 @@ dependencies:
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
@@ -133,7 +133,6 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/zyxzen/interactor-validation
-  source_code_uri: https://github.com/zyxzen/interactor-validation
   changelog_uri: https://github.com/zyxzen/interactor-validation/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths: