active_interaction 4.0.5 → 5.0.0

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.0.5')
+  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(

data/spec/active_interaction/array_input_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe ActiveInteraction::ArrayInput do
+  subject(:input) do
+    described_class.new(filter,
+      value: value,
+      error: error,
+      index_errors: index_errors,
+      children: children
+    )
+  end
+
+  let(:filter) do
+    ActiveInteraction::ArrayFilter.new(:a, &block)
+  end
+  let(:block) { proc { integer } }
+  let(:value) { nil }
+  let(:error) { nil }
+  let(:index_errors) { false }
+  let(:children) { [] }
+
+  describe '#errors' do
+    context 'with no errors' do
+      it 'returns an empty array' do
+        expect(input.errors).to be_empty
+      end
+    end
+
+    context 'with an error on the array' do
+      let(:error) { ActiveInteraction::Filter::Error.new(filter, :invalid_type) }
+
+      it 'returns one error in the array' do
+        expect(input.errors.size).to be 1
+
+        error = input.errors.first
+        expect(error.name).to be filter.name
+        expect(error.type).to be :invalid_type
+      end
+    end
+
+    context 'with children with errors' do
+      let(:child_filter) { ActiveInteraction::IntegerFilter.new(:'') }
+      let(:child_error) { ActiveInteraction::Filter::Error.new(child_filter, :invalid_type) }
+      let(:child1) { ActiveInteraction::Input.new(child_filter, value: 'a', error: child_error) }
+      let(:child2) { ActiveInteraction::Input.new(child_filter, value: 'b', error: child_error) }
+      let(:children) { [child1, child2] }
+
+      context 'with an error on the array' do
+        let(:error) { ActiveInteraction::Filter::Error.new(filter, :invalid_type) }
+
+        it 'returns one error in the array' do
+          expect(input.errors.size).to be 1
+
+          error = input.errors.first
+          expect(error.name).to be filter.name
+          expect(error.type).to be :invalid_type
+        end
+      end
+
+      context 'without :index_errors' do
+        it 'promotes the first child error and returns it in the array' do
+          expect(input.errors.size).to be 1
+
+          error = input.errors.first
+          expect(error.name).to be filter.name
+          expect(error.type).to be :invalid_type
+        end
+      end
+
+      context 'with :index_errors' do
+        let(:index_errors) { true }
+
+        it 'lists all child errors in the array' do
+          expect(input.errors.size).to be 2
+
+          input.errors.each_with_index do |error, i|
+            expect(error.name).to be :"#{filter.name}[#{i}]"
+            expect(error.type).to be :invalid_type
+          end
+        end
+
+        context 'with a nested array' do
+          let(:invalid_value) { Object.new }
+          let(:array_child) do
+            filter = ActiveInteraction::IntegerFilter.new(:'')
+            ActiveInteraction::Input.new(filter,
+              value: invalid_value,
+              error: ActiveInteraction::Filter::Error.new(filter, :invalid_type)
+            )
+          end
+          let(:child_filter) { ActiveInteraction::ArrayFilter.new(:'') { integer } }
+          let(:child) do
+            described_class.new(child_filter,
+              value: [invalid_value],
+              index_errors: index_errors,
+              children: [array_child]
+            )
+          end
+          let(:children) { [child] }
+
+          it 'returns the error' do
+            expect(input.errors.size).to be 1
+
+            error = input.errors.first
+            expect(error.name).to be :"#{filter.name}[0][0]"
+            expect(error.type).to be :invalid_type
+          end
+        end
+
+        context 'with a nested hash' do
+          let(:hash_child_a) do
+            filter = ActiveInteraction::IntegerFilter.new(:a)
+            ActiveInteraction::Input.new(filter,
+              value: nil,
+              error: ActiveInteraction::Filter::Error.new(filter, :missing)
+            )
+          end
+          let(:hash_child_b) do
+            filter = ActiveInteraction::IntegerFilter.new(:b)
+            ActiveInteraction::Input.new(filter,
+              value: nil,
+              error: ActiveInteraction::Filter::Error.new(filter, :missing)
+            )
+          end
+          let(:child_filter) { ActiveInteraction::HashFilter.new(:'') { integer :a, :b } }
+          let(:child) do
+            ActiveInteraction::HashInput.new(child_filter, value: {}, children: { a: hash_child_a, b: hash_child_b })
+          end
+          let(:children) { [child] }
+
+          it 'list all child errors' do
+            expect(input.errors.size).to be 2
+
+            error = input.errors.first
+            expect(error.name).to be :"#{filter.name}[0].a"
+            expect(error.type).to be :missing
+
+            error = input.errors.last
+            expect(error.name).to be :"#{filter.name}[0].b"
+            expect(error.type).to be :missing
+          end
+
+          context 'with an invalid hash' do
+            let(:child_filter) { ActiveInteraction::HashFilter.new(:'') }
+            let(:child) do
+              ActiveInteraction::HashInput.new(child_filter,
+                value: Object.new,
+                error: ActiveInteraction::Filter::Error.new(child_filter, :invalid_type),
+                children: {}
+              )
+            end
+            let(:children) { [child] }
+
+            it 'list all child errors' do
+              expect(input.errors.size).to be 1
+
+              error = input.errors.first
+              expect(error.name).to be :"#{filter.name}[0]"
+              expect(error.type).to be :invalid_type
+            end
+          end
+        end
+      end
+    end
+  end
+end