interactor-validation 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcab1b0ef807a7e0c68d8c56570d7e3dd20337c0cb597015b2740132738c5c14
-  data.tar.gz: 82d5c575039217f7f6a90cb9a67677c980d74120caa59c7dc12e52f74688e056
+  metadata.gz: 553f0d597d013bf2fa42f8225ead3b75fea6879b1519724d1d800e6f83db8319
+  data.tar.gz: f9eb147c94a9cd17a0bc453feb912a90edfaee8f87ec336db7b4f6c1af99b3fb
 SHA512:
-  metadata.gz: 553e1c172909fcb5dd3a16b00bfead612de5c1e46e95611014dd830d4bf46cd957c019613ed19c05775b236ef77e496b9d8a82a832badf731b74f63ff06a9ecc
-  data.tar.gz: 2382f09479bcc17d822113c3984c70ff341c7f583393ce6ee342c359aecb60139de92e01559934e84013e4a95368791b202b26eed314953df583be5f5cf5ef6d
+  metadata.gz: 124fbda7650b19706d984230a8aecd47af6c272096f26300120564e94f7664e58baceb48521909e025f621bf41e77c647a27c6a0bdc843c367d03812b36afaee
+  data.tar.gz: d188ba13516259565e742bcb1ef558b10022436823ee1c183250b582f023ead80a40236c4c33b1e6fc7a2362d13178cd0c19f88728bb6c12911bf05a09a12861

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,11 +90,75 @@ module Interactor
         end
       end
 
+      # Module prepended to override ActiveModel instance methods
+      module InstanceMethodsOverride
+        # 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
+        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|
+            begin
+              { attribute: error.attribute, type: error.type, options: error.options }
+            rescue ArgumentError => e
+              # For anonymous classes, accessing error properties may fail
+              if e.message.include?("Class name cannot be blank")
+                { attribute: error.attribute, type: :invalid, options: {} }
+              else
+                raise
+              end
+            end
+          end
+
+          # 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 ActiveModel::ValidationError
+            # ActiveModel's validate! raises this when there are errors
+            # We handle errors differently, so just ignore this exception
+          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)
+            unless 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
+          end
+
+          # 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
+      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
@@ -101,9 +167,12 @@ module Interactor
         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
 
           # Run our custom param validations after ActiveModel validations
           self.class._param_validations.each do |param_name, rules|
@@ -115,9 +184,8 @@ module Interactor
             break if @current_config.halt_on_first_error && 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
@@ -628,9 +696,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 => e
+              # 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 +745,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.2"
   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.2
 platform: ruby
 authors:
 - Wilson Anciro