interactor-validation 0.3.9 → 0.4.0

data/lib/interactor/validation/validators/array.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validators
+      module Array
+        def validate_array(param, value, nested_rules)
+          return unless value.is_a?(::Array)
+
+          value.each_with_index do |item, idx|
+            validate_nested_item(param, item, nested_rules, idx)
+
+            # Halt on first error if configured
+            break if validation_config(:halt) && errors.any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/validators/boolean.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validators
+      module Boolean
+        def validate_boolean(param, value)
+          return if [true, false].include?(value)
+
+          errors.add(param, :invalid, message: "must be true or false")
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/validators/format.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validators
+      module Format
+        def validate_format(param, value, rule)
+          pattern = rule.is_a?(::Hash) ? rule[:with] : rule
+          return if value.to_s.match?(pattern)
+
+          msg = rule.is_a?(::Hash) ? rule[:message] : nil
+          errors.add(param, :invalid, message: msg || "is invalid")
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/validators/hash.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validators
+      module Hash
+        def validate_hash(param, value, nested_rules)
+          return unless value.is_a?(::Hash)
+
+          validate_nested_item(param, value, nested_rules)
+        end
+
+        private
+
+        def validate_nested_item(param, item, nested_rules, index = nil)
+          return unless item.is_a?(::Hash)
+
+          nested_rules.each do |attr, attr_rules|
+            attr_path = index.nil? ? "#{param}.#{attr}" : "#{param}[#{index}].#{attr}"
+            # Use key? to avoid false being treated as nil due to || operator
+            attr_value = item.key?(attr) ? item[attr] : item[attr.to_s]
+            validate_nested_attribute(attr_path.to_sym, attr_value, attr_rules)
+          end
+        end
+
+        def validate_nested_attribute(attr_path, value, rules)
+          if rules[:presence] && !value.present? && value != false
+            msg = rules[:presence].is_a?(::Hash) ? rules[:presence][:message] : nil
+            errors.add(attr_path, :blank, message: msg || "can't be blank")
+          end
+
+          return unless value.present? || value == false
+
+          validate_format(attr_path, value, rules[:format]) if rules[:format]
+          validate_length(attr_path, value, rules[:length]) if rules[:length]
+          validate_inclusion(attr_path, value, rules[:inclusion]) if rules[:inclusion]
+          validate_numeric(attr_path, value, rules[:numeric]) if rules[:numeric]
+          validate_numeric(attr_path, value, rules[:numericality]) if rules[:numericality]
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/validators/inclusion.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validators
+      module Inclusion
+        def validate_inclusion(param, value, rule)
+          allowed = rule.is_a?(::Hash) ? rule[:in] : rule
+          return if allowed.include?(value)
+
+          msg = rule.is_a?(::Hash) ? rule[:message] : nil
+          errors.add(param, :inclusion, message: msg || "is not included in the list")
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/validators/length.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validators
+      module Length
+        def validate_length(param, value, rule)
+          # Use .length for collections (Array/Hash), .to_s.length for other types
+          len = value.respond_to?(:length) && !value.is_a?(String) ? value.length : value.to_s.length
+          unit = collection?(value) ? "items" : "characters"
+
+          validate_minimum_length(param, len, rule[:minimum], unit, rule[:message]) if rule[:minimum]
+          validate_maximum_length(param, len, rule[:maximum], unit, rule[:message]) if rule[:maximum]
+          validate_exact_length(param, len, rule[:is], unit, rule[:message]) if rule[:is]
+        end
+
+        private
+
+        def collection?(value)
+          (value.is_a?(::Array) || value.is_a?(::Hash)) && !value.is_a?(String)
+        end
+
+        def validate_minimum_length(param, len, minimum, unit, custom_message)
+          return unless len < minimum
+
+          msg = custom_message || "is too short (minimum is #{minimum} #{unit})"
+          errors.add(param, :too_short, message: msg, count: minimum)
+        end
+
+        def validate_maximum_length(param, len, maximum, unit, custom_message)
+          return unless len > maximum
+
+          msg = custom_message || "is too long (maximum is #{maximum} #{unit})"
+          errors.add(param, :too_long, message: msg, count: maximum)
+        end
+
+        def validate_exact_length(param, len, exact, unit, custom_message)
+          return unless len != exact
+
+          msg = custom_message || "is the wrong length (should be #{exact} #{unit})"
+          errors.add(param, :wrong_length, message: msg, count: exact)
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/validators/numeric.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validators
+      module Numeric
+        def validate_numeric(param, value, rule)
+          unless numeric?(value)
+            msg = rule.is_a?(::Hash) ? rule[:message] : nil
+            errors.add(param, :not_a_number, message: msg || "is not a number")
+            return
+          end
+
+          num = coerce_numeric(value)
+          rule = {} unless rule.is_a?(::Hash)
+
+          check_numeric_constraint(param, num, :greater_than, rule) { |n, v| n <= v }
+          check_numeric_constraint(param, num, :greater_than_or_equal_to, rule) { |n, v| n < v }
+          check_numeric_constraint(param, num, :less_than, rule) { |n, v| n >= v }
+          check_numeric_constraint(param, num, :less_than_or_equal_to, rule) { |n, v| n > v }
+          check_numeric_constraint(param, num, :equal_to, rule) { |n, v| n != v }
+        end
+
+        private
+
+        def check_numeric_constraint(param, num, type, rule)
+          return unless rule[type]
+          return unless yield(num, rule[type])
+
+          msg = rule[:message] || "must be #{type.to_s.tr("_", " ")} #{rule[type]}"
+          errors.add(param, type, message: msg, count: rule[type])
+        end
+
+        def numeric?(value)
+          value.is_a?(::Numeric) || value.to_s.match?(/\A-?\d+(\.\d+)?\z/)
+        end
+
+        def coerce_numeric(value)
+          return value if value.is_a?(::Numeric)
+
+          value.to_s.include?(".") ? value.to_f : value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/validators/presence.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validators
+      module Presence
+        def validate_presence(param, value, rule)
+          return if value.present? || value == false
+
+          msg = rule.is_a?(::Hash) ? rule[:message] : nil
+          errors.add(param, :blank, message: msg || "can't be blank")
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/version.rb

@@ -2,6 +2,6 @@
 
 module Interactor
   module Validation
-    VERSION = "0.3.9"
+    VERSION = "0.4.0"
   end
 end

data/lib/interactor/validation.rb

@@ -1,59 +1,28 @@
 # frozen_string_literal: true
 
 require "interactor"
-require "active_support/concern"
-require "active_model"
-
-require_relative "validation/version"
+require_relative "validation/core_ext"
 require_relative "validation/configuration"
-require_relative "validation/error_codes"
+require_relative "validation/errors"
 require_relative "validation/params"
 require_relative "validation/validates"
+require_relative "validation/version"
 
 module Interactor
   module Validation
-    class Error < StandardError; end
-
-    extend ActiveSupport::Concern
-
-    included do
-      include Params
-      include Validates
-
-      # Instance-level configuration (can override global config)
-      class_attribute :validation_config, instance_writer: false, default: nil
-    end
+    def self.included(base)
+      base.include Params
+      base.include Validates
+      base.before :run_validations! if base.respond_to?(:before)
 
-    class_methods do
-      # Configure validation behavior for this interactor class
-      # @example
-      #   configure_validation do |config|
-      #     config.error_mode = :code
-      #   end
-      def configure_validation
-        self.validation_config ||= Configuration.new
-        yield(validation_config)
-      end
+      # Ensure before hook is set up on child classes
+      base.singleton_class.prepend(InheritanceHook) if base.respond_to?(:before)
     end
 
-    def self.included(base)
-      super
-      # 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 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
+    module InheritanceHook
+      def inherited(subclass)
+        super
+        subclass.before :run_validations! if subclass.respond_to?(:before)
       end
     end
   end

data/smoke_test.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "lib/interactor/validation"
+
+# Test 1: Basic validation
+class TestBasicValidation
+  include Interactor
+  include Interactor::Validation
+
+  params :email, :username, :age
+
+  validates :email, presence: true, format: { with: /@/ }
+  validates :username, presence: true
+  validates :age, numericality: { greater_than: 0 }
+
+  def call
+    context.result = "User created: #{email}, #{username}, #{age}"
+  end
+end
+
+puts "Test 1: Basic Validation"
+puts "=" * 50
+
+# Should succeed
+result = TestBasicValidation.call(email: "user@example.com", username: "john", age: 25)
+puts "✓ Valid params: #{result.success? ? 'PASS' : 'FAIL'}"
+puts "  Result: #{result.result}" if result.success?
+
+# Should fail
+result = TestBasicValidation.call(email: "", username: "", age: -5)
+puts "✗ Invalid params: #{result.failure? ? 'PASS' : 'FAIL'}"
+puts "  Errors: #{result.errors.size} errors" if result.failure?
+result.errors.each { |e| puts "    - #{e[:attribute]}: #{e[:message]}" } if result.failure?
+
+puts
+
+# Test 2: Nested validation
+class TestNestedValidation
+  include Interactor
+  include Interactor::Validation
+
+  params :user
+
+  validates :user, presence: true do
+    attribute :name, presence: true
+    attribute :email, format: { with: /@/ }
+    attribute :age, numericality: { greater_than: 0 }
+  end
+
+  def call
+    context.result = "User created: #{user[:name]}"
+  end
+end
+
+puts "Test 2: Nested Validation"
+puts "=" * 50
+
+# Should succeed
+result = TestNestedValidation.call(user: { name: "John", email: "john@example.com", age: 30 })
+puts "✓ Valid nested params: #{result.success? ? 'PASS' : 'FAIL'}"
+puts "  Result: #{result.result}" if result.success?
+
+# Should fail
+result = TestNestedValidation.call(user: { name: "", email: "invalid", age: -5 })
+puts "✗ Invalid nested params: #{result.failure? ? 'PASS' : 'FAIL'}"
+puts "  Errors: #{result.errors.size} errors" if result.failure?
+result.errors.each { |e| puts "    - #{e[:attribute]}: #{e[:message]}" } if result.failure?
+
+puts
+
+# Test 3: Array validation
+class TestArrayValidation
+  include Interactor
+  include Interactor::Validation
+
+  params :items
+
+  validates :items do
+    attribute :name, presence: true
+    attribute :price, numericality: { greater_than: 0 }
+  end
+
+  def call
+    context.result = "Processed #{items.size} items"
+  end
+end
+
+puts "Test 3: Array Validation"
+puts "=" * 50
+
+# Should succeed
+result = TestArrayValidation.call(items: [
+  { name: "Widget", price: 10 },
+  { name: "Gadget", price: 20 }
+])
+puts "✓ Valid array: #{result.success? ? 'PASS' : 'FAIL'}"
+puts "  Result: #{result.result}" if result.success?
+
+# Should fail
+result = TestArrayValidation.call(items: [
+  { name: "Widget", price: 10 },
+  { name: "", price: -5 }
+])
+puts "✗ Invalid array item: #{result.failure? ? 'PASS' : 'FAIL'}"
+puts "  Errors: #{result.errors.size} errors" if result.failure?
+result.errors.each { |e| puts "    - #{e[:attribute]}: #{e[:message]}" } if result.failure?
+
+puts
+
+# Test 4: Custom validation
+class TestCustomValidation
+  include Interactor
+  include Interactor::Validation
+
+  params :product_id, :quantity
+
+  validates :product_id, presence: true
+  validates :quantity, numericality: { greater_than: 0 }
+
+  def validate!
+    super
+
+    # Custom business logic
+    if product_id == 999
+      errors.add(:product_id, :not_found, message: "Product not found")
+    end
+  end
+
+  def call
+    context.result = "Order created for product #{product_id}"
+  end
+end
+
+puts "Test 4: Custom Validation"
+puts "=" * 50
+
+# Should succeed
+result = TestCustomValidation.call(product_id: 123, quantity: 5)
+puts "✓ Valid with custom validation: #{result.success? ? 'PASS' : 'FAIL'}"
+puts "  Result: #{result.result}" if result.success?
+
+# Should fail with custom error
+result = TestCustomValidation.call(product_id: 999, quantity: 5)
+puts "✗ Custom validation error: #{result.failure? ? 'PASS' : 'FAIL'}"
+puts "  Errors: #{result.errors.size} errors" if result.failure?
+result.errors.each { |e| puts "    - #{e[:attribute]}: #{e[:message]}" } if result.failure?
+
+puts
+
+# Test 5: Halt on first error (disabled by default)
+class TestHaltDisabled
+  include Interactor
+  include Interactor::Validation
+
+  params :email, :username, :age
+
+  validates :email, presence: true, format: { with: /@/ }
+  validates :username, presence: true
+  validates :age, numericality: { greater_than: 0 }
+
+  def call
+    context.result = "User created"
+  end
+end
+
+puts "Test 5: Halt Disabled (Default Behavior)"
+puts "=" * 50
+
+# Should collect all errors
+result = TestHaltDisabled.call(email: "", username: "", age: -5)
+puts "✗ All errors collected: #{result.failure? && result.errors.size == 3 ? 'PASS' : 'FAIL'}"
+puts "  Expected 3 errors, got #{result.errors.size}" if result.failure?
+result.errors.each { |e| puts "    - #{e[:attribute]}: #{e[:type]}" } if result.failure?
+
+puts
+
+# Test 6: Halt on first error (enabled)
+class TestHaltEnabled
+  include Interactor
+  include Interactor::Validation
+
+  params :email, :username, :age
+
+  validates :email, presence: true, format: { with: /@/ }
+  validates :username, presence: true
+  validates :age, numericality: { greater_than: 0 }
+
+  def call
+    context.result = "User created"
+  end
+end
+
+puts "Test 6: Halt Enabled (Stop on First Error)"
+puts "=" * 50
+
+# Enable halt
+Interactor::Validation.configure do |config|
+  config.halt = true
+end
+
+# Should stop at first error
+result = TestHaltEnabled.call(email: "", username: "", age: -5)
+puts "✗ Halted on first error: #{result.failure? && result.errors.size == 1 ? 'PASS' : 'FAIL'}"
+puts "  Expected 1 error, got #{result.errors.size}" if result.failure?
+result.errors.each { |e| puts "    - #{e[:attribute]}: #{e[:type]}" } if result.failure?
+
+# Reset configuration
+Interactor::Validation.configure do |config|
+  config.halt = false
+end
+
+puts
+
+# Test 7: Halt with valid first param, invalid second
+class TestHaltPartialErrors
+  include Interactor
+  include Interactor::Validation
+
+  params :email, :username, :age
+
+  validates :email, presence: true, format: { with: /@/ }
+  validates :username, presence: true, length: { minimum: 3 }
+  validates :age, numericality: { greater_than: 0 }
+
+  def call
+    context.result = "User created"
+  end
+end
+
+puts "Test 7: Halt with Valid First Param"
+puts "=" * 50
+
+# Enable halt
+Interactor::Validation.configure do |config|
+  config.halt = true
+end
+
+# Valid email, invalid username and age - should stop at username
+result = TestHaltPartialErrors.call(email: "valid@example.com", username: "", age: -5)
+puts "✗ Halted at username error: #{result.failure? && result.errors.size == 1 && result.errors.first[:attribute] == :username ? 'PASS' : 'FAIL'}"
+puts "  Expected 1 error on username, got #{result.errors.size} errors" if result.failure?
+result.errors.each { |e| puts "    - #{e[:attribute]}: #{e[:type]}" } if result.failure?
+
+# Reset configuration
+Interactor::Validation.configure do |config|
+  config.halt = false
+end
+
+puts
+puts "=" * 50
+puts "Smoke tests complete!"