active_interaction 4.1.0 → 5.0.0

data/lib/active_interaction/errors.rb

@@ -1,93 +1,6 @@
 # frozen_string_literal: true
 
 module ActiveInteraction
-  # Top-level error class. All other errors subclass this.
-  #
-  # @return [Class]
-  Error = Class.new(StandardError)
-
-  # Raised if a constant name is invalid.
-  #
-  # @return [Class]
-  InvalidNameError = Class.new(Error)
-
-  # Raised if a converter is invalid.
-  #
-  # @return [Class]
-  InvalidConverterError = Class.new(Error)
-
-  # Raised if a default value is invalid.
-  #
-  # @return [Class]
-  InvalidDefaultError = Class.new(Error)
-
-  # Raised if a filter has an invalid definition.
-  #
-  # @return [Class]
-  InvalidFilterError = Class.new(Error)
-
-  # Raised if an interaction is invalid.
-  #
-  # @return [Class]
-  class InvalidInteractionError < Error
-    attr_accessor :interaction
-  end
-
-  # Raised if a user-supplied value is invalid.
-  #
-  # @return [Class]
-  InvalidValueError = Class.new(Error)
-
-  # Raised if a filter cannot be found.
-  #
-  # @return [Class]
-  MissingFilterError = Class.new(Error)
-
-  # Raised if no value is given.
-  #
-  # @return [Class]
-  MissingValueError = Class.new(Error)
-
-  # Raised if there is no default value.
-  #
-  # @return [Class]
-  NoDefaultError = Class.new(Error)
-
-  # Raised if a user-supplied value to a nested hash input is invalid.
-  #
-  # @return [Class]
-  class InvalidNestedValueError < InvalidValueError
-    # @return [Symbol]
-    attr_reader :filter_name
-
-    # @return [Object]
-    attr_reader :input_value
-
-    # @param filter_name [Symbol]
-    # @param input_value [Object]
-    def initialize(filter_name, input_value)
-      super("#{filter_name}: #{input_value.inspect}")
-
-      @filter_name = filter_name
-      @input_value = input_value
-    end
-  end
-
-  # Used by {Runnable} to signal a failure when composing.
-  #
-  # @private
-  class Interrupt < Error
-    attr_reader :errors
-
-    # @param errors [Runnable]
-    def initialize(errors)
-      super()
-
-      @errors = errors
-    end
-  end
-  private_constant :Interrupt
-
   # An extension that provides the ability to merge other errors into itself.
   class Errors < ActiveModel::Errors
     attr_accessor :backtrace
@@ -103,10 +16,15 @@ module ActiveInteraction
       self
     end
 
+    # @private
+    def local_attribute(attribute)
+      attribute.to_s.sub(/\A([^.\[]*).*\z/, '\1').to_sym
+    end
+
     private
 
     def attribute?(attribute)
-      @base.respond_to?(attribute)
+      @base.respond_to?(local_attribute(attribute))
     end
 
     def detailed_error?(detail)

data/lib/active_interaction/exceptions.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  # Top-level error class. All other errors subclass this.
+  Error = Class.new(StandardError)
+
+  # Raised if a constant name is invalid.
+  InvalidNameError = Class.new(Error)
+
+  # Raised if a converter is invalid.
+  InvalidConverterError = Class.new(Error)
+
+  # Raised if a default value is invalid.
+  InvalidDefaultError = Class.new(Error)
+
+  # Raised if a filter has an invalid definition.
+  InvalidFilterError = Class.new(Error)
+
+  # Raised if an interaction is invalid.
+  class InvalidInteractionError < Error
+    # The interaction where the error occured.
+    #
+    # @return [ActiveInteraction::Base]
+    attr_accessor :interaction
+  end
+
+  # Raised if a filter cannot be found.
+  MissingFilterError = Class.new(Error)
+
+  # Raised if there is no default value.
+  NoDefaultError = Class.new(Error)
+
+  # Used by {Runnable} to signal a failure when composing.
+  #
+  # @private
+  class Interrupt < Error
+    attr_reader :errors
+
+    # @param errors [Runnable]
+    def initialize(errors)
+      super()
+
+      @errors = errors
+    end
+  end
+  private_constant :Interrupt
+end

data/lib/active_interaction/filter/column.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  class Filter
+    # A minimal implementation of an `ActiveRecord::ConnectionAdapters::Column`.
+    class Column
+      # @return [nil]
+      attr_reader :limit
+
+      # @return [Symbol]
+      attr_reader :type
+
+      class << self
+        # Find or create the `Filter::Column` for a specific type.
+        #
+        # @param type [Symbol] A database column type.
+        #
+        # @example
+        #   Filter::Column.intern(:string)
+        #   # => #<ActiveInteraction::Filter::Column:0x007feeaa649c @type=:string>
+        #
+        #   Filter::Column.intern(:string)
+        #   # => #<ActiveInteraction::Filter::Column:0x007feeaa649c @type=:string>
+        #
+        #   Filter::Column.intern(:boolean)
+        #   # => #<ActiveInteraction::Filter::Column:0x007feeab8a08 @type=:boolean>
+        #
+        # @return [Filter::Column]
+        def intern(type)
+          @columns ||= {}
+          @columns[type] ||= new(type)
+        end
+
+        private :new
+      end
+
+      # @param type [type] The database column type.
+      #
+      # @private
+      def initialize(type)
+        @type = type
+      end
+
+      # Returns `true` if the column is either of type :integer or :float.
+      #
+      # @return [Boolean]
+      def number?
+        %i[integer float].include?(type)
+      end
+
+      # Returns `true` if the column is of type :string.
+      #
+      # @return [Boolean]
+      def text?
+        type == :string
+      end
+    end
+  end
+end

data/lib/active_interaction/filter/error.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module ActiveInteraction
+  class Filter
+    # A validation error that occurs while processing the filter.
+    class Error
+      # @private
+      def initialize(filter, type, name: nil)
+        @filter = filter
+        @name = name || filter.name
+        @type = type
+
+        @options = {}
+        options[:type] = I18n.translate("#{Base.i18n_scope}.types.#{filter.class.slug}") if type == :invalid_type
+      end
+
+      # The filter the error occured on.
+      #
+      # @return [ActiveInteraction::Filter]
+      attr_reader :filter
+
+      # The name of the error.
+      #
+      # @return [Symbol]
+      attr_reader :name
+
+      # Options passed to the error for error message creation.
+      #
+      # @return [Hash]
+      attr_reader :options
+
+      # The type of error.
+      #
+      # @return [Symbol]
+      attr_reader :type
+    end
+  end
+end

data/lib/active_interaction/filter.rb

@@ -73,38 +73,24 @@ module ActiveInteraction
       instance_eval(&block) if block_given?
     end
 
-    # Convert a value into the expected type. If no value is given, fall back
-    #   to the default value.
+    # Processes the input through the filter and returns a variety of data
+    #   about the input.
     #
     # @example
-    #   ActiveInteraction::Filter.new(:example).clean(nil, nil)
-    #   # => ActiveInteraction::MissingValueError: example
-    # @example
-    #   ActiveInteraction::Filter.new(:example).clean(0, nil)
-    #   # => ActiveInteraction::InvalidValueError: example: 0
-    # @example
-    #   ActiveInteraction::Filter.new(:example, default: nil).clean(nil, nil)
+    #   input = ActiveInteraction::Filter.new(:example, default: nil).process(nil, nil)
+    #   input.value
     #   # => nil
-    # @example
-    #   ActiveInteraction::Filter.new(:example, default: 0).clean(nil, nil)
-    #   # => ActiveInteraction::InvalidDefaultError: example: 0
     #
     # @param value [Object]
     # @param context [Base, nil]
     #
-    # @return [Object]
+    # @return [Input, ArrayInput, HashInput]
     #
-    # @raise [MissingValueError] If the value is missing and there is no
-    #   default.
-    # @raise [InvalidValueError] If the value is invalid.
     # @raise (see #default)
-    def clean(value, context)
-      value = cast(value, context)
-      if value.nil?
-        default(context)
-      else
-        value
-      end
+    def process(value, context)
+      value, error = cast(value, context)
+
+      Input.new(self, value: value, error: error)
     end
 
     # Get the default value.
@@ -126,16 +112,24 @@ module ActiveInteraction
     # @raise [NoDefaultError] If the default is missing.
     # @raise [InvalidDefaultError] If the default is invalid.
     def default(context = nil)
+      return @default if defined?(@default)
+
       raise NoDefaultError, name unless default?
 
       value = raw_default(context)
-      raise InvalidValueError if value.is_a?(GroupedInput)
-
-      cast(value, context)
-    rescue InvalidNestedValueError => e
-      raise InvalidDefaultError, "#{name}: #{value.inspect} (#{e})"
-    rescue InvalidValueError, MissingValueError
-      raise InvalidDefaultError, "#{name}: #{value.inspect}"
+      raise InvalidDefaultError, "#{name}: #{value.inspect}" if value.is_a?(GroupedInput)
+
+      @default =
+        if value.nil?
+          nil
+        else
+          default = process(value, context)
+          if default.errors.any? && default.errors.first.is_a?(Filter::Error)
+            raise InvalidDefaultError, "#{name}: #{value.inspect}"
+          end
+
+          default.value
+        end
     end
 
     # Get the description.
@@ -195,30 +189,26 @@ module ActiveInteraction
 
     private
 
-    # rubocop:disable Metrics/MethodLength
-    def cast(value, context, convert: true, reconstantize: true)
+    # rubocop:disable Metrics/PerceivedComplexity
+    def cast(value, context, convertize: true, reconstantize: true)
       if matches?(value)
-        adjust_output(value, context)
-      # we can't use `nil?` because BasicObject doesn't have it
-      elsif value == nil # rubocop:disable Style/NilComparison
-        raise MissingValueError, name unless default?
-
-        nil
+        [adjust_output(value, context), nil]
+      elsif value == nil # rubocop:disable Style/NilComparison - BasicObject does not have `nil?`
+        default? ? [default(context), nil] : [value, Filter::Error.new(self, :missing)]
       elsif reconstantize
-        send(__method__, value, context,
-          convert: convert,
-          reconstantize: false
-        )
-      elsif convert
-        send(__method__, convert(value), context,
-          convert: false,
-          reconstantize: reconstantize
-        )
+        send(__method__, value, context, convertize: convertize, reconstantize: false)
+      elsif convertize
+        value, error = convert(value)
+        if error
+          [value, error]
+        else
+          send(__method__, value, context, convertize: false, reconstantize: reconstantize)
+        end
       else
-        raise InvalidValueError, "#{name}: #{describe(value)}"
+        [value, Filter::Error.new(self, :invalid_type)]
       end
     end
-    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
 
     def matches?(_value)
       false
@@ -229,7 +219,7 @@ module ActiveInteraction
     end
 
     def convert(value)
-      value
+      [value, nil]
     end
 
     def klass
@@ -246,9 +236,10 @@ module ActiveInteraction
       value = options.fetch(:default)
       return value unless value.is_a?(Proc)
 
-      case value.arity
-      when 1 then context.instance_exec(self, &value)
-      else context.instance_exec(&value)
+      if value.arity == 1
+        context.instance_exec(self, &value)
+      else
+        context.instance_exec(&value)
       end
     end
   end

data/lib/active_interaction/filters/abstract_date_time_filter.rb

@@ -31,14 +31,16 @@ module ActiveInteraction
     def convert(value)
       if value.respond_to?(:to_str)
         value = value.to_str
-        value.blank? ? send(__method__, nil) : convert_string(value)
+        if value.blank?
+          send(__method__, nil)
+        else
+          [convert_string(value), nil]
+        end
       elsif value.is_a?(GroupedInput)
-        convert_grouped_input(value)
+        [convert_grouped_input(value), nil]
       else
         super
       end
-    rescue ArgumentError
-      value
     rescue NoMethodError # BasicObject
       super
     end
@@ -47,9 +49,10 @@ module ActiveInteraction
       if format?
         klass.strptime(value, format)
       else
-        klass.parse(value) ||
-          (raise ArgumentError, "no time information in #{value.inspect}")
+        klass.parse(value) || value
       end
+    rescue ArgumentError
+      value
     end
 
     def convert_grouped_input(value)

data/lib/active_interaction/filters/abstract_numeric_filter.rb

@@ -21,12 +21,16 @@ module ActiveInteraction
 
     def convert(value)
       if value.is_a?(Numeric)
-        safe_converter(value)
+        [safe_converter(value), nil]
       elsif value.respond_to?(:to_int)
-        safe_converter(value.to_int)
+        [safe_converter(value.to_int), nil]
       elsif value.respond_to?(:to_str)
         value = value.to_str
-        value.blank? ? send(__method__, nil) : safe_converter(value)
+        if value.blank?
+          send(__method__, nil)
+        else
+          [safe_converter(value), nil]
+        end
       else
         super
       end

data/lib/active_interaction/filters/array_filter.rb

@@ -8,6 +8,8 @@ module ActiveInteraction
     #
     #   @!macro filter_method_params
     #   @param block [Proc] filter method to apply to each element
+    #   @option options [Boolean] :index_errors (ActiveRecord.index_nested_attribute_errors) returns errors with an
+    #     index
     #
     #   @example
     #     array :ids
@@ -36,8 +38,37 @@ module ActiveInteraction
 
     register :array
 
+    def process(value, context)
+      input = super
+
+      return ArrayInput.new(self, value: input.value, error: input.errors.first) if input.errors.any?
+      return ArrayInput.new(self, value: default(context), error: input.errors.first) if input.value.nil?
+
+      value = input.value
+      error = nil
+      children = []
+
+      unless filters.empty?
+        value.each do |item|
+          children.push(filters[:'0'].process(item, context))
+        end
+      end
+
+      ArrayInput.new(self, value: value, error: error, children: children, index_errors: index_errors?)
+    end
+
     private
 
+    def index_errors?
+      default =
+        if ::ActiveRecord.respond_to?(:index_nested_attribute_errors)
+          ::ActiveRecord.index_nested_attribute_errors # Moved to here in Rails 7.0
+        else
+          ::ActiveRecord::Base.index_nested_attribute_errors
+        end
+      options.fetch(:index_errors, default)
+    end
+
     def klasses
       %w[
         ActiveRecord::Relation
@@ -55,16 +86,13 @@ module ActiveInteraction
       false
     end
 
-    def adjust_output(value, context)
-      return value if filters.empty?
-
-      filter = filters.values.first
-      value.map { |e| filter.clean(e, context) }
+    def adjust_output(value, _context)
+      value.to_a
     end
 
     def convert(value)
       if value.respond_to?(:to_ary)
-        value.to_ary
+        [value.to_ary, nil]
       else
         super
       end

data/lib/active_interaction/filters/boolean_filter.rb

@@ -6,7 +6,8 @@ module ActiveInteraction
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Booleans. The strings `"1"`, `"true"`, and `"on"`
     #     (case-insensitive) are converted to `true` while the strings `"0"`,
-    #     `"false"`, and `"off"` are converted to `false`.
+    #     `"false"`, and `"off"` are converted to `false`. Blank strings are
+    #     treated as a `nil` value.
     #
     #   @!macro filter_method_params
     #
@@ -38,9 +39,9 @@ module ActiveInteraction
 
       case value
       when /\A(?:0|false|off)\z/i
-        false
+        [false, nil]
       when /\A(?:1|true|on)\z/i
-        true
+        [true, nil]
       else
         super
       end

data/lib/active_interaction/filters/date_filter.rb

@@ -6,7 +6,7 @@ module ActiveInteraction
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Dates. String values are processed using `parse`
     #     unless the format option is given, in which case they will be
-    #     processed with `strptime`.
+    #     processed with `strptime`. Blank strings are treated as a `nil` value.
     #
     #   @!macro filter_method_params
     #   @option options [String] :format parse strings using this format string

data/lib/active_interaction/filters/date_time_filter.rb

@@ -6,7 +6,7 @@ module ActiveInteraction
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are DateTimes. String values are processed using
     #     `parse` unless the format option is given, in which case they will be
-    #     processed with `strptime`.
+    #     processed with `strptime`. Blank strings are treated as a `nil` value.
     #
     #   @!macro filter_method_params
     #   @option options [String] :format parse strings using this format string

data/lib/active_interaction/filters/decimal_filter.rb

@@ -7,7 +7,7 @@ module ActiveInteraction
     # @!method self.decimal(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are BigDecimals. Numerics and String values are
-    #     converted into BigDecimals.
+    #     converted into BigDecimals. Blank strings are treated as a `nil` value.
     #
     #   @!macro filter_method_params
     #

data/lib/active_interaction/filters/float_filter.rb

@@ -5,7 +5,7 @@ module ActiveInteraction
     # @!method self.float(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Floats. Integer and String values are converted
-    #     into Floats.
+    #     into Floats. Blank strings are treated as a `nil` value.
     #
     #   @!macro filter_method_params
     #

data/lib/active_interaction/filters/hash_filter.rb

@@ -25,6 +25,26 @@ module ActiveInteraction
 
     register :hash
 
+    def process(value, context)
+      input = super
+
+      return HashInput.new(self, value: input.value, error: input.errors.first) if input.errors.first
+      return HashInput.new(self, value: default(context), error: input.errors.first) if input.value.nil?
+
+      value = strip? ? HashWithIndifferentAccess.new : input.value
+      error = nil
+      children = {}
+
+      filters.each do |name, filter|
+        filter.process(input.value[name], context).tap do |result|
+          value[name] = result.value
+          children[name.to_sym] = result
+        end
+      end
+
+      HashInput.new(self, value: value, error: error, children: children)
+    end
+
     private
 
     def matches?(value)
@@ -33,29 +53,17 @@ module ActiveInteraction
       false
     end
 
-    def clean_value(hash, name, filter, value, context)
-      hash[name] = filter.clean(value[name], context)
-    rescue InvalidValueError, MissingValueError
-      raise InvalidNestedValueError.new(name, value[name])
-    end
-
     def strip?
       options.fetch(:strip, true)
     end
 
-    def adjust_output(value, context)
-      value = ActiveSupport::HashWithIndifferentAccess.new(value.to_hash)
-
-      initial = strip? ? ActiveSupport::HashWithIndifferentAccess.new : value
-
-      filters.each_with_object(initial) do |(name, filter), hash|
-        clean_value(hash, name.to_s, filter, value, context)
-      end
+    def adjust_output(value, _context)
+      ActiveSupport::HashWithIndifferentAccess.new(value)
     end
 
     def convert(value)
       if value.respond_to?(:to_hash)
-        value.to_hash
+        [value.to_hash, nil]
       else
         super
       end

data/lib/active_interaction/filters/integer_filter.rb

@@ -5,7 +5,7 @@ module ActiveInteraction
     # @!method self.integer(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Integers. String values are converted into
-    #     Integers.
+    #     Integers. Blank strings are treated as a `nil` value.
     #
     #   @!macro filter_method_params
     #   @option options [Integer] :base (10) The base used to convert strings