interactor-validation 0.3.9 → 0.4.1

data/benchmark/validation_benchmark.rb

@@ -216,9 +216,6 @@ Benchmark.ips do |x|
   x.compare!
 end
 
-# Reset configuration
-Interactor::Validation.reset_configuration!
-
 puts "\n#{"=" * 60}"
 puts "Benchmarks complete!"
 puts "\nTo run these benchmarks:"

data/lib/interactor/validation/configuration.rb

@@ -4,32 +4,12 @@ module Interactor
   module Validation
     # Configuration class for interactor validation behavior
     class Configuration
-      attr_accessor :halt, :regex_timeout, :max_array_size,
-                    :enable_instrumentation, :cache_regex_patterns,
-                    :skip_validate
-      attr_reader :error_mode
+      attr_accessor :skip_validate, :mode, :halt
 
-      # 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 = 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
-        @cache_regex_patterns = true # Cache compiled regex patterns for performance
         @skip_validate = true # Skip validate! hook if validate_params! has errors
-      end
-
-      def error_mode=(mode)
-        raise ArgumentError, "Invalid error_mode: #{mode}. Must be :default or :code" unless %i[default code].include?(mode)
-
-        @error_mode = mode
+        @mode = :default # Error message format mode (:default or :code)
+        @halt = false # Stop validation on first error
       end
     end
 
@@ -43,10 +23,6 @@ module Interactor
       def configure
         yield(configuration)
       end
-
-      def reset_configuration!
-        @configuration = Configuration.new
-      end
     end
   end
 end

data/lib/interactor/validation/core_ext.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    # Minimal core extensions - no external dependencies
+    module CoreExt
+      # Simple class attribute implementation with inheritance support
+      def class_attribute(*names)
+        names.each do |name|
+          ivar_name = "@#{name}"
+
+          # Class-level reader - checks own value, then parent
+          define_singleton_method(name) do
+            if instance_variable_defined?(ivar_name)
+              instance_variable_get(ivar_name)
+            elsif superclass.respond_to?(name)
+              # When reading from parent, ensure we get our own copy first
+              parent_value = superclass.public_send(name)
+              # Deep copy parent value if it hasn't been set on this class yet
+              if parent_value && !instance_variable_defined?(ivar_name)
+                copied_value = deep_copy(parent_value)
+                instance_variable_set(ivar_name, copied_value)
+                copied_value
+              else
+                parent_value
+              end
+            end
+          end
+
+          # Class-level writer
+          define_singleton_method("#{name}=") do |val|
+            instance_variable_set(ivar_name, val)
+          end
+
+          # Instance-level reader delegates to class
+          define_method(name) { self.class.public_send(name) }
+        end
+      end
+
+      private
+
+      def deep_copy(value)
+        case value
+        when Hash
+          value.transform_values { |v| deep_copy(v) }
+        when Array
+          value.map { |v| deep_copy(v) }
+        else
+          # For immutable objects (Symbol, Integer, etc.) or simple objects, return as-is
+          value.duplicable? ? value.dup : value
+        end
+      end
+
+      # Simple delegation
+      def delegate(*methods, to:)
+        methods.each do |method|
+          define_method(method) { |*args, &block| public_send(to).public_send(method, *args, &block) }
+        end
+      end
+    end
+  end
+end
+
+# Minimal Object extensions
+class Object
+  def present?
+    !blank?
+  end
+
+  def blank?
+    respond_to?(:empty?) ? empty? : false
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  def blank?
+    true
+  end
+end
+
+class String
+  def humanize
+    tr("_.", " ").sub(/\A./, &:upcase)
+  end
+end
+
+class Symbol
+  def humanize
+    to_s.humanize
+  end
+
+  def duplicable?
+    false
+  end
+end
+
+# Make immutable classes non-duplicable
+[NilClass, FalseClass, TrueClass, Symbol, Numeric].each do |klass|
+  klass.class_eval do
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Object
+  def duplicable?
+    true
+  end
+end
+
+class Module
+  include Interactor::Validation::CoreExt
+end

data/lib/interactor/validation/errors.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    # Minimal error collection
+    class Errors
+      include Enumerable
+
+      Error = Struct.new(:attribute, :type, :message, :options, keyword_init: true)
+
+      def initialize(halt_checker: nil)
+        @errors = []
+        @halt_checker = halt_checker
+      end
+
+      def add(attribute, type = :invalid, message: nil, **options)
+        @errors << Error.new(
+          attribute: attribute,
+          type: type,
+          message: message || type.to_s,
+          options: options
+        )
+
+        # Raise HaltValidation if halt is configured
+        raise HaltValidation if @halt_checker&.call
+      end
+
+      def empty?
+        @errors.empty?
+      end
+
+      def any?
+        !empty?
+      end
+
+      def clear
+        @errors.clear
+      end
+
+      def each(&)
+        @errors.each(&)
+      end
+
+      def to_a
+        @errors.dup
+      end
+    end
+  end
+end

data/lib/interactor/validation/params.rb

@@ -3,26 +3,16 @@
 module Interactor
   module Validation
     module Params
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :_declared_params, instance_writer: false, default: []
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_attribute :_declared_params
+        base._declared_params = []
       end
 
-      class_methods do
-        # Declares parameters that will be delegated from context
-        # and registered for validation
-        #
-        # @param param_names [Array<Symbol>] the parameter names to declare
-        # @example
-        #   params :username, :password
+      module ClassMethods
         def params(*param_names)
           param_names.each do |param_name|
-            # Ensure we're working with a copy to avoid modifying parent's array
-            current_params = _declared_params.dup
-            self._declared_params = current_params + [param_name] unless current_params.include?(param_name)
-
-            # Delegate to context for easy access
+            _declared_params << param_name unless _declared_params.include?(param_name)
             delegate param_name, to: :context
           end
         end