active_interaction 4.1.0 → 5.1.1

data/lib/active_interaction/array_input.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  # Represents a processed array input.
+  class ArrayInput < Input
+    # @private
+    def initialize(filter, value: nil, error: nil, index_errors: false, children: [])
+      super(filter, value: value, error: error)
+
+      @filter = filter
+      @index_errors = index_errors
+      @children = children
+    end
+
+    # @overload children
+    #   Child inputs if a nested filter is used.
+    #
+    #   @return [Array<Input, ArrayInput, HashInput>]
+    attr_reader :children
+
+    # Any errors that occurred during processing.
+    #
+    # @return [Filter::Error]
+    def errors
+      return @errors if defined?(@errors)
+
+      return @errors = super if @error
+
+      child_errors = get_errors_by_index(children)
+
+      return @errors = super if child_errors.empty?
+
+      @errors ||=
+        if @index_errors
+          child_errors.map do |(error, i)|
+            name = attach_child_name(:"#{@filter.name}[#{i}]", error)
+            Filter::Error.new(error.filter, error.type, name: name)
+          end.freeze
+        else
+          error, = child_errors.first
+          [Filter::Error.new(@filter, error.type)].freeze
+        end
+    end
+
+    private
+
+    def get_errors_by_index(children)
+      children.flat_map.with_index do |child, i|
+        child.errors.map do |error|
+          [error, i]
+        end
+      end
+    end
+
+    def attach_child_name(name, error)
+      return name unless error.name.present?
+
+      if children_are_arrays?(children)
+        :"#{name}#{error.name.to_s.sub(/\A[^\[]*/, '')}"
+      elsif children_are_hashes?(children)
+        :"#{name}.#{error.name.to_s[1..]}"
+      end
+    end
+
+    def children_are_arrays?(children)
+      return @children_are_arrays if defined?(@children_are_arrays)
+
+      @children_are_arrays = children.first&.is_a?(ArrayInput)
+    end
+
+    def children_are_hashes?(children)
+      return @children_are_hashes if defined?(@children_are_hashes)
+
+      @children_are_hashes = children.first&.is_a?(HashInput)
+    end
+  end
+end

data/lib/active_interaction/base.rb

@@ -30,7 +30,7 @@ module ActiveInteraction
     include ActiveRecordable
     include Runnable
 
-    define_callbacks :type_check
+    define_callbacks :filter
 
     class << self
       include Hashable
@@ -43,7 +43,7 @@ module ActiveInteraction
       #
       #   Runs validations and if there are no errors it will call {#execute}.
       #
-      #   @param (see ActiveInteraction::Inputs.process)
+      #   @param input [Hash, ActionController::Parameters]
       #
       #   @return [Base]
 
@@ -88,7 +88,8 @@ module ActiveInteraction
         # rubocop:enable Naming/MemoizedInstanceVariableName
       end
 
-      # @private
+      private
+
       # rubocop:disable Style/MissingRespondToMissing
       def method_missing(*args, &block)
         super do |klass, names, options|
@@ -99,8 +100,6 @@ module ActiveInteraction
       end
       # rubocop:enable Style/MissingRespondToMissing
 
-      private
-
       # @param klass [Class]
       # @param name [Symbol]
       # @param options [Hash]
@@ -162,7 +161,9 @@ module ActiveInteraction
     def initialize(inputs = {})
       @_interaction_raw_inputs = inputs
 
-      populate_filters_and_inputs(Inputs.process(inputs))
+      @_interaction_inputs = Inputs.new(inputs, self) do |name, input|
+        public_send("#{name}=", input.value)
+      end
     end
 
     # @!method compose(other, inputs = {})
@@ -186,113 +187,28 @@ module ActiveInteraction
     # Returns the inputs provided to {.run} or {.run!} after being cast based
     #   on the filters in the class.
     #
-    # @return [Hash{Symbol => Object}] All inputs passed to {.run} or {.run!}.
+    # @return [Inputs] All expected inputs passed to {.run} or {.run!}.
     def inputs
       @_interaction_inputs
     end
 
-    # Returns `true` if the given key was in the hash passed to {.run}.
-    # Otherwise returns `false`. Use this to figure out if an input was given,
-    # even if it was `nil`. Keys within nested hash filter can also be checked
-    # by passing them in series. Arrays can be checked in the same manor as
-    # hashes by passing an index.
-    #
-    # @example
-    #   class Example < ActiveInteraction::Base
-    #     integer :x, default: nil
-    #     def execute; given?(:x) end
-    #   end
-    #   Example.run!()        # => false
-    #   Example.run!(x: nil)  # => true
-    #   Example.run!(x: rand) # => true
-    #
-    # @example Nested checks
-    #   class Example < ActiveInteraction::Base
-    #     hash :x, default: {} do
-    #       integer :y, default: nil
-    #     end
-    #     array :a, default: [] do
-    #       integer
-    #     end
-    #     def execute; given?(:x, :y) || given?(:a, 2) end
-    #   end
-    #   Example.run!()               # => false
-    #   Example.run!(x: nil)         # => false
-    #   Example.run!(x: {})          # => false
-    #   Example.run!(x: { y: nil })  # => true
-    #   Example.run!(x: { y: rand }) # => true
-    #   Example.run!(a: [1, 2])      # => false
-    #   Example.run!(a: [1, 2, 3])   # => true
-    #
-    # @param input [#to_sym]
-    #
-    # @return [Boolean]
-    #
-    # @since 2.1.0
-    # rubocop:disable all
-    def given?(input, *rest)
-      filter_level = self.class
-      input_level = @_interaction_raw_inputs
-
-      [input, *rest].each do |key_or_index|
-        if key_or_index.is_a?(Symbol) || key_or_index.is_a?(String)
-          key = key_or_index.to_sym
-          key_to_s = key_or_index.to_s
-          filter_level = filter_level.filters[key]
-
-          break false if filter_level.nil? || input_level.nil?
-          if filter_level.accepts_grouped_inputs?
-            break false unless input_level.key?(key) || input_level.key?(key_to_s) || Inputs.keys_for_group?(input_level.keys, key)
-          else
-            break false unless input_level.key?(key) || input_level.key?(key_to_s)
-          end
-
-          input_level = input_level[key] || input_level[key_to_s]
-        else
-          index = key_or_index
-          filter_level = filter_level.filters.first.last
-
-          break false if filter_level.nil? || input_level.nil?
-          break false unless index.between?(-input_level.size, input_level.size - 1)
-
-          input_level = input_level[index]
-        end
-      end && true
+    # @private
+    def read_attribute_for_validation(attribute)
+      super(errors.local_attribute(attribute))
     end
-    # rubocop:enable all
 
     protected
 
     def run_validations!
-      type_check
+      filter
 
       super if errors.empty?
     end
 
     private
 
-    def populate_filters_and_inputs(inputs)
-      @_interaction_inputs = Inputs.new
-
-      self.class.filters.each do |name, filter|
-        value =
-          begin
-            filter.clean(inputs[name], self)
-          rescue InvalidValueError, MissingValueError, NoDefaultError
-            # #type_check will add errors if appropriate.
-            # We'll get the original value for the error.
-            inputs[name]
-          end
-
-        @_interaction_inputs[name] = value
-        public_send("#{name}=", value)
-      end
-
-      @_interaction_inputs.freeze
-    end
-
-    def type_check
-      run_callbacks(:type_check) do
+    def filter
+      run_callbacks(:filter) do
         Validation.validate(self, self.class.filters, inputs).each do |attr, type, kwargs = {}|
           errors.add(attr, type, **kwargs)
         end

data/lib/active_interaction/concerns/active_recordable.rb

@@ -17,15 +17,15 @@ module ActiveInteraction
     #   end
     #
     #   Interaction.new.column_for_attribute(:email)
-    #   # => #<ActiveInteraction::FilterColumn:0x007faebeb2a6c8 @type=:string>
+    #   # => #<ActiveInteraction::Filter::Column:0x007faebeb2a6c8 @type=:string>
     #
     #   Interaction.new.column_for_attribute(:not_a_filter)
     #   # => nil
     #
-    # @return [FilterColumn, nil]
+    # @return [Filter::Column, nil]
     def column_for_attribute(name)
       filter = self.class.filters[name]
-      FilterColumn.intern(filter.database_column_type) if filter
+      Filter::Column.intern(filter.database_column_type) if filter
     end
 
     # Returns true if a filter of that name exists.

data/lib/active_interaction/concerns/missable.rb

@@ -7,6 +7,8 @@ module ActiveInteraction
   module Missable
     extend ActiveSupport::Concern
 
+    private
+
     # @param slug [Symbol]
     #
     # @yield [klass, args, options]
@@ -26,8 +28,6 @@ module ActiveInteraction
       self
     end
 
-    private
-
     # @param slug [Symbol]
     #
     # @return [Filter, nil]

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.
@@ -129,13 +115,18 @@ module ActiveInteraction
       raise NoDefaultError, name unless default?
 
       value = raw_default(context)
-      raise InvalidValueError if value.is_a?(GroupedInput)
+      raise InvalidDefaultError, "#{name}: #{value.inspect}" 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}"
+      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 +186,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 +216,7 @@ module ActiveInteraction
     end
 
     def convert(value)
-      value
+      [value, nil]
     end
 
     def klass
@@ -246,9 +233,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