active_interaction 4.1.0 → 5.0.0

data/lib/active_interaction/filters/interface_filter.rb

@@ -47,34 +47,34 @@ module ActiveInteraction
         "constant #{const_name.inspect} does not exist"
     end
 
-    def matches?(object)
-      return false if object.nil?
-      return matches_methods?(object) if options.key?(:methods)
+    def matches?(value)
+      return false if value == nil # rubocop:disable Style/NilComparison
+      return matches_methods?(value) if options.key?(:methods)
 
       const = from
-      if checking_class_inheritance?(object, const)
-        class_inherits_from?(object, const)
+      if checking_class_inheritance?(value, const)
+        class_inherits_from?(value, const)
       else
-        singleton_ancestor?(object, const)
+        singleton_ancestor?(value, const)
       end
     rescue NoMethodError
       false
     end
 
-    def matches_methods?(object)
-      options[:methods].all? { |method| object.respond_to?(method) }
+    def matches_methods?(value)
+      options[:methods].all? { |method| value.respond_to?(method) }
     end
 
-    def checking_class_inheritance?(object, from)
-      object.is_a?(Class) && from.is_a?(Class)
+    def checking_class_inheritance?(value, from)
+      value.is_a?(Class) && from.is_a?(Class)
     end
 
     def class_inherits_from?(klass, inherits_from)
       klass != inherits_from && klass.ancestors.include?(inherits_from)
     end
 
-    def singleton_ancestor?(object, from)
-      object.class != from && object.singleton_class.ancestors.include?(from)
+    def singleton_ancestor?(value, from)
+      value.class != from && value.singleton_class.ancestors.include?(from)
     end
   end
 end

data/lib/active_interaction/filters/object_filter.rb

@@ -38,19 +38,25 @@ module ActiveInteraction
     end
 
     def matches?(value)
+      return false if value == nil # rubocop:disable Style/NilComparison
+
       value.class <= klass
     rescue NoMethodError
       false
     end
 
     def convert(value)
-      converter(value).tap do |result|
-        raise InvalidValueError if result.nil?
+      result = converter(value)
+
+      if result.nil?
+        [value, Filter::Error.new(self, :invalid_type)]
+      else
+        [result, nil]
       end
     rescue StandardError => e
       raise e if e.is_a?(InvalidConverterError)
 
-      raise InvalidValueError
+      [value, Filter::Error.new(self, :invalid_type)]
     end
 
     def converter(value)

data/lib/active_interaction/filters/record_filter.rb

@@ -4,7 +4,9 @@ module ActiveInteraction
   class Base # rubocop:disable Lint/EmptyClass
     # @!method self.record(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
-    #     the attributes are the correct class.
+    #     the attributes are the correct class. Blank strings passed in will be
+    #     treated as `nil` and the `finder` will not be called.
+
     #
     #   @!macro filter_method_params
     #   @option options [Class, String, Symbol] :class (use the attribute name)
@@ -44,20 +46,28 @@ module ActiveInteraction
     end
 
     def convert(value)
-      finder = options.fetch(:finder, :find)
-      find(klass, value, finder)
-    end
+      return [nil, nil] if blank_string?(value)
 
-    def find(klass, value, finder)
-      result = klass.public_send(finder, value)
+      finder = options.fetch(:finder, :find)
+      result = find(klass, value, finder)
 
-      raise InvalidValueError if result.nil?
+      if result.nil?
+        [value, Filter::Error.new(self, :invalid_type)]
+      else
+        [result, nil]
+      end
+    end
 
-      result
-    rescue StandardError => e
-      raise e if e.is_a?(InvalidConverterError)
+    def blank_string?(value)
+      value.is_a?(String) && value.blank?
+    rescue NoMethodError # BasicObject
+      false
+    end
 
-      raise InvalidValueError
+    def find(klass, value, finder)
+      klass.public_send(finder, value)
+    rescue StandardError
+      nil
     end
   end
 end

data/lib/active_interaction/filters/string_filter.rb

@@ -38,7 +38,7 @@ module ActiveInteraction
 
     def convert(value)
       if value.respond_to?(:to_str)
-        value.to_str
+        [value.to_str, nil]
       else
         super
       end

data/lib/active_interaction/filters/symbol_filter.rb

@@ -26,7 +26,7 @@ module ActiveInteraction
 
     def convert(value)
       if value.respond_to?(:to_sym)
-        value.to_sym
+        [value.to_sym, nil]
       else
         super
       end

data/lib/active_interaction/filters/time_filter.rb

@@ -6,9 +6,9 @@ module ActiveInteraction
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Times. Numeric values are processed using `at`.
     #     Strings are processed using `parse` unless the format option is
-    #     given, in which case they will be processed with `strptime`. If
-    #     `Time.zone` is available it will be used so that the values are time
-    #     zone aware.
+    #     given, in which case they will be processed with `strptime`. Blank
+    #     strings are treated as a `nil` value. If `Time.zone` is available it
+    #     will be used so that the values are time zone aware.
     #
     #   @!macro filter_method_params
     #   @option options [String] :format parse strings using this format string
@@ -59,7 +59,7 @@ module ActiveInteraction
       value = value.to_int if value.respond_to?(:to_int)
 
       if value.is_a?(Numeric)
-        klass.at(value)
+        [klass.at(value), nil]
       else
         super
       end

data/lib/active_interaction/hash_input.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  # Represents a processed hash input.
+  class HashInput < Input
+    # @private
+    def initialize(filter, value: nil, error: nil, children: {})
+      super(filter, value: value, error: error)
+
+      @children = children
+    end
+
+    # @overload children
+    #   Child inputs if nested filters are used.
+    #
+    #   @return [Hash{ Symbol => 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(children)
+
+      return @errors = super if child_errors.empty?
+
+      @errors ||=
+        child_errors.map do |error|
+          Filter::Error.new(error.filter, error.type, name: :"#{@filter.name}.#{error.name}")
+        end.freeze
+    end
+
+    private
+
+    def get_errors(children)
+      children.values.flat_map(&:errors)
+    end
+  end
+end

data/lib/active_interaction/input.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  # Represents a processed input.
+  class Input
+    # @private
+    def initialize(filter, value: nil, error: nil)
+      @filter = filter
+      @value = value
+      @error = error
+    end
+
+    # The processed input value.
+    attr_reader :value
+
+    # Any errors that occurred during processing.
+    #
+    # @return [Filter::Error]
+    def errors
+      @errors ||= Array(@error)
+    end
+  end
+end

data/lib/active_interaction/inputs.rb

@@ -1,24 +1,23 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 module ActiveInteraction
   # Holds inputs passed to the interaction.
-  class Inputs < DelegateClass(Hash)
-    class << self
-      # matches inputs like "key(1i)"
-      GROUPED_INPUT_PATTERN = /
-        \A
-        (?<key>.+)         # extracts "key"
-        \((?<index>\d+)i\) # extracts "1"
-        \z
-      /x.freeze
-      private_constant :GROUPED_INPUT_PATTERN
+  class Inputs
+    include Enumerable
+    extend Forwardable
 
-      # @private
-      def keys_for_group?(keys, group_key)
-        search_key = /\A#{group_key}\(\d+i\)\z/
-        keys.any? { |key| search_key.match?(key) }
-      end
+    # matches inputs like "key(1i)"
+    GROUPED_INPUT_PATTERN = /
+      \A
+      (?<key>.+)         # extracts "key"
+      \((?<index>\d+)i\) # extracts "1"
+      \z
+    /x.freeze
+    private_constant :GROUPED_INPUT_PATTERN
 
+    class << self
       # Checking `syscall` is the result of what appears to be a bug in Ruby.
       # https://bugs.ruby-lang.org/issues/15597
       # @private
@@ -34,47 +33,159 @@ module ActiveInteraction
             !Object.private_method_defined?(name)
           )
       end
+    end
 
-      # @param inputs [Hash, ActionController::Parameters, ActiveInteraction::Inputs] Attribute values to set.
-      #
-      # @private
-      def process(inputs)
-        normalize_inputs!(inputs)
-          .stringify_keys
-          .sort
-          .each_with_object({}) do |(k, v), h|
-            next if reserved?(k)
-
-            if (group = GROUPED_INPUT_PATTERN.match(k))
-              assign_to_grouped_input!(h, group[:key], group[:index], v)
-            else
-              h[k.to_sym] = v
-            end
-          end
+    # @private
+    def initialize(raw_inputs, base)
+      @base = base
+      @normalized_inputs = normalize(raw_inputs)
+      @inputs = base.class.filters.each_with_object({}) do |(name, filter), inputs|
+        inputs[name] = filter.process(@normalized_inputs[name], base)
+
+        yield name, inputs[name] if block_given?
       end
+    end
 
-      private
+    # @private
+    def normalized
+      @normalized_inputs
+    end
 
-      def normalize_inputs!(inputs)
-        return inputs if inputs.is_a?(Hash) || inputs.is_a?(Inputs)
+    # Turn the inputs into a Hash.
+    #
+    # @return [Hash]
+    def to_h
+      @to_h ||= @inputs.transform_values(&:value).freeze
+    end
 
-        parameters = 'ActionController::Parameters'
-        klass = parameters.safe_constantize
-        return inputs.to_unsafe_h if klass && inputs.is_a?(klass)
+    def_delegators :to_h,
+      :[],
+      :dig,
+      :each,
+      :each_key,
+      :each_pair,
+      :each_value,
+      :empty?,
+      :except,
+      :fetch,
+      :fetch_values,
+      :filter,
+      :flatten,
+      :has_key?,
+      :has_value?,
+      :include?,
+      :inspect,
+      :key,
+      :key?,
+      :keys,
+      :length,
+      :member?,
+      :merge,
+      :rassoc,
+      :reject,
+      :select,
+      :size,
+      :slice,
+      :store,
+      :to_a,
+      :to_s,
+      :value?,
+      :values,
+      :values_at
 
-        raise ArgumentError, "inputs must be a hash or #{parameters}"
-      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]
+    #
+    # rubocop:disable all
+    def given?(input, *rest)
+      filter_level = @base.class
+      input_level = @normalized_inputs
 
-      def assign_to_grouped_input!(inputs, key, index, value)
-        key = key.to_sym
+      [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]
 
-        inputs[key] = GroupedInput.new unless inputs[key].is_a?(GroupedInput)
-        inputs[key][index] = value
-      end
+          break false if filter_level.nil? || input_level.nil?
+          break false unless input_level.key?(key) || input_level.key?(key_to_s)
+
+          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
     end
+    # rubocop:enable all
+
+    private
+
+    def normalize(inputs)
+      convert(inputs)
+        .sort
+        .each_with_object({}) do |(k, v), h|
+          next if self.class.reserved?(k)
+
+          if (group = GROUPED_INPUT_PATTERN.match(k))
+            assign_to_grouped_input!(h, group[:key], group[:index], v)
+          else
+            h[k.to_sym] = v
+          end
+        end
+    end
+
+    def convert(inputs)
+      return inputs.stringify_keys if inputs.is_a?(Hash)
+      return inputs.to_unsafe_h.stringify_keys if inputs.is_a?(ActionController::Parameters)
+
+      raise ArgumentError, 'inputs must be a hash or ActionController::Parameters'
+    end
+
+    def assign_to_grouped_input!(inputs, key, index, value)
+      key = key.to_sym
 
-    def initialize(inputs = {})
-      super(inputs)
+      inputs[key] = GroupedInput.new unless inputs[key].is_a?(GroupedInput)
+      inputs[key][index] = value
     end
   end
 end

data/lib/active_interaction/locale/en.yml

@@ -3,7 +3,6 @@ en:
     errors:
       messages:
         invalid: is invalid
-        invalid_nested: has an invalid nested value (%{name} => %{value})
         invalid_type: is not a valid %{type}
         missing: is required
     types:

data/lib/active_interaction/locale/fr.yml

@@ -3,7 +3,6 @@ fr:
     errors:
       messages:
         invalid: est invalide
-        invalid_nested: contient une valeur imbriquée invalide (%{name} => %{value})
         invalid_type: a un type invalide (%{type})
         missing: est obligatoire
     types:

data/lib/active_interaction/locale/it.yml

@@ -3,7 +3,6 @@ it:
     errors:
       messages:
         invalid: non è valido
-        invalid_nested: ha un valore nidificato non valido (%{name} => %{value})
         invalid_type: non è di tipo %{type}
         missing: è obbligatorio
     types:

data/lib/active_interaction/locale/ja.yml

@@ -3,7 +3,6 @@ ja:
     errors:
       messages:
         invalid: は無効です
-        invalid_nested: は無効なネストされた値です (%{name} => %{value})
         invalid_type: は無効な %{type} です
         missing: が必要です
     types:

data/lib/active_interaction/locale/pt-BR.yml

@@ -3,7 +3,6 @@ pt-BR:
     errors:
       messages:
         invalid: é inválido
-        invalid_nested: possui um valor aninhado inválido (%{name} => %{value})
         invalid_type: não é um(a) %{type} válido(a)
         missing: é obrigatório
     types:

data/lib/active_interaction/modules/validation.rb

@@ -8,26 +8,15 @@ module ActiveInteraction
     class << self
       # @param context [Base]
       # @param filters [Hash{Symbol => Filter}]
-      # @param inputs [Hash{Symbol => Object}]
+      # @param inputs [Inputs]
       def validate(context, filters, inputs)
         filters.each_with_object([]) do |(name, filter), errors|
-          filter.clean(inputs[name], context)
-        rescue NoDefaultError
-          nil
-        rescue InvalidNestedValueError => e
-          errors << [filter.name, :invalid_nested, { name: e.filter_name.inspect, value: e.input_value.inspect }]
-        rescue InvalidValueError
-          errors << [filter.name, :invalid_type, { type: type(filter) }]
-        rescue MissingValueError
-          errors << [filter.name, :missing]
-        end
-      end
+          input = filter.process(inputs[name], context)
 
-      private
-
-      # @param filter [Filter]
-      def type(filter)
-        I18n.translate("#{Base.i18n_scope}.types.#{filter.class.slug}")
+          input.errors.each do |error|
+            errors << [error.name, error.type, error.options]
+          end
+        end
       end
     end
   end

data/lib/active_interaction/version.rb

@@ -4,5 +4,5 @@ module ActiveInteraction
   # The version number.
   #
   # @return [Gem::Version]
-  VERSION = Gem::Version.new('4.1.0')
+  VERSION = Gem::Version.new('5.0.0')
 end

data/lib/active_interaction.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'active_model'
-require 'active_support/hash_with_indifferent_access'
+require 'active_record'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'action_controller'
 
 # Manage application specific business logic.
 #
@@ -10,41 +12,46 @@ require 'active_support/hash_with_indifferent_access'
 module ActiveInteraction
 end
 
-require 'active_interaction/version'
-require 'active_interaction/errors'
-
-require 'active_interaction/concerns/active_modelable'
-require 'active_interaction/concerns/active_recordable'
-require 'active_interaction/concerns/hashable'
-require 'active_interaction/concerns/missable'
-require 'active_interaction/concerns/runnable'
-
-require 'active_interaction/grouped_input'
-require 'active_interaction/inputs'
-
-require 'active_interaction/modules/validation'
-
-require 'active_interaction/filter_column'
-require 'active_interaction/filter'
-require 'active_interaction/filters/interface_filter'
-require 'active_interaction/filters/abstract_date_time_filter'
-require 'active_interaction/filters/abstract_numeric_filter'
-require 'active_interaction/filters/array_filter'
-require 'active_interaction/filters/boolean_filter'
-require 'active_interaction/filters/date_filter'
-require 'active_interaction/filters/date_time_filter'
-require 'active_interaction/filters/decimal_filter'
-require 'active_interaction/filters/file_filter'
-require 'active_interaction/filters/float_filter'
-require 'active_interaction/filters/hash_filter'
-require 'active_interaction/filters/integer_filter'
-require 'active_interaction/filters/object_filter'
-require 'active_interaction/filters/record_filter'
-require 'active_interaction/filters/string_filter'
-require 'active_interaction/filters/symbol_filter'
-require 'active_interaction/filters/time_filter'
-
-require 'active_interaction/base'
+require_relative 'active_interaction/version'
+require_relative 'active_interaction/exceptions'
+require_relative 'active_interaction/errors'
+
+require_relative 'active_interaction/concerns/active_modelable'
+require_relative 'active_interaction/concerns/active_recordable'
+require_relative 'active_interaction/concerns/hashable'
+require_relative 'active_interaction/concerns/missable'
+require_relative 'active_interaction/concerns/runnable'
+
+require_relative 'active_interaction/grouped_input'
+require_relative 'active_interaction/input'
+require_relative 'active_interaction/array_input'
+require_relative 'active_interaction/hash_input'
+require_relative 'active_interaction/inputs'
+
+require_relative 'active_interaction/modules/validation'
+
+require_relative 'active_interaction/filter/column'
+require_relative 'active_interaction/filter/error'
+require_relative 'active_interaction/filter'
+require_relative 'active_interaction/filters/interface_filter'
+require_relative 'active_interaction/filters/abstract_date_time_filter'
+require_relative 'active_interaction/filters/abstract_numeric_filter'
+require_relative 'active_interaction/filters/array_filter'
+require_relative 'active_interaction/filters/boolean_filter'
+require_relative 'active_interaction/filters/date_filter'
+require_relative 'active_interaction/filters/date_time_filter'
+require_relative 'active_interaction/filters/decimal_filter'
+require_relative 'active_interaction/filters/file_filter'
+require_relative 'active_interaction/filters/float_filter'
+require_relative 'active_interaction/filters/hash_filter'
+require_relative 'active_interaction/filters/integer_filter'
+require_relative 'active_interaction/filters/object_filter'
+require_relative 'active_interaction/filters/record_filter'
+require_relative 'active_interaction/filters/string_filter'
+require_relative 'active_interaction/filters/symbol_filter'
+require_relative 'active_interaction/filters/time_filter'
+
+require_relative 'active_interaction/base'
 
 I18n.load_path.unshift(
   *Dir.glob(