active_interaction 3.7.1 → 4.0.0

data/lib/active_interaction.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 require 'active_model'
@@ -7,8 +6,6 @@ require 'active_model'
 #
 # @author Aaron Lasseigne <aaron.lasseigne@gmail.com>
 # @author Taylor Fausak <taylor@fausak.me>
-#
-# @since 1.0.0
 module ActiveInteraction
 end
 
@@ -22,13 +19,12 @@ require 'active_interaction/concerns/missable'
 require 'active_interaction/concerns/runnable'
 
 require 'active_interaction/grouped_input'
+require 'active_interaction/inputs'
 
-require 'active_interaction/modules/input_processor'
 require 'active_interaction/modules/validation'
 
 require 'active_interaction/filter_column'
 require 'active_interaction/filter'
-require 'active_interaction/filters/abstract_filter'
 require 'active_interaction/filters/interface_filter'
 require 'active_interaction/filters/abstract_date_time_filter'
 require 'active_interaction/filters/abstract_numeric_filter'
@@ -49,8 +45,6 @@ require 'active_interaction/filters/time_filter'
 
 require 'active_interaction/base'
 
-require 'active_interaction/backports'
-
 I18n.load_path.unshift(
   *Dir.glob(
     File.expand_path(

data/lib/active_interaction/base.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 require 'active_support/core_ext/hash/indifferent_access'
@@ -74,9 +73,7 @@ module ActiveInteraction
       # @return [String, nil] The description.
       def desc(desc = nil)
         if desc.nil?
-          unless instance_variable_defined?(:@_interaction_desc)
-            @_interaction_desc = nil
-          end
+          @_interaction_desc = nil unless instance_variable_defined?(:@_interaction_desc)
         else
           @_interaction_desc = desc
         end
@@ -88,17 +85,21 @@ module ActiveInteraction
       #
       # @return [Hash{Symbol => Filter}]
       def filters
+        # rubocop:disable Naming/MemoizedInstanceVariableName
         @_interaction_filters ||= {}
+        # rubocop:enable Naming/MemoizedInstanceVariableName
       end
 
       # @private
-      def method_missing(*args, &block) # rubocop:disable Style/MethodMissing
+      # rubocop:disable Style/MissingRespondToMissing
+      def method_missing(*args, &block)
         super do |klass, names, options|
           raise InvalidFilterError, 'missing attribute name' if names.empty?
 
           names.each { |name| add_filter(klass, name, options, &block) }
         end
       end
+      # rubocop:enable Style/MissingRespondToMissing
 
       private
 
@@ -106,9 +107,7 @@ module ActiveInteraction
       # @param name [Symbol]
       # @param options [Hash]
       def add_filter(klass, name, options, &block)
-        if InputProcessor.reserved?(name)
-          raise InvalidFilterError, %("#{name}" is a reserved name)
-        end
+        raise InvalidFilterError, %("#{name}" is a reserved name) if ActiveInteraction::Inputs.reserved?(name)
 
         initialize_filter(klass.new(name, options, &block))
       end
@@ -133,7 +132,7 @@ module ActiveInteraction
         other_filters.select! { |k, _| [*only].include?(k) } if only
         other_filters.reject! { |k, _| [*except].include?(k) } if except
 
-        other_filters.values.each { |filter| initialize_filter(filter) }
+        other_filters.each_value { |filter| initialize_filter(filter) }
       end
 
       # @param klass [Class]
@@ -146,13 +145,10 @@ module ActiveInteraction
       # @param filter [Filter]
       def initialize_filter(filter)
         attribute = filter.name
-        if filters.key?(attribute)
-          warn "WARNING: Redefining #{name}##{attribute} filter"
-        end
+        warn "WARNING: Redefining #{name}##{attribute} filter" if filters.key?(attribute)
         filters[attribute] = filter
 
         attr_accessor attribute
-        define_method("#{attribute}?") { !public_send(attribute).nil? }
 
         eagerly_evaluate_default(filter)
       end
@@ -195,15 +191,17 @@ module ActiveInteraction
     #
     # @return [Hash{Symbol => Object}] All inputs passed to {.run} or {.run!}.
     def inputs
-      self.class.filters.keys.each_with_object({}) do |name, h|
-        h[name] = public_send(name)
-      end
+      @inputs ||= self.class.filters
+        .each_key.with_object(ActiveInteraction::Inputs.new) do |name, h|
+          h[name] = public_send(name)
+        end.freeze
     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.
+    # by passing them in series. Arrays can be checked in the same manor as
+    # hashes by passing an index.
     #
     # @example
     #   class Example < ActiveInteraction::Base
@@ -219,32 +217,49 @@ module ActiveInteraction
     #     hash :x, default: {} do
     #       integer :y, default: nil
     #     end
-    #     def execute; given?(:x, :y) 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
-    def given?(input, *rest) # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable all
+    def given?(input, *rest)
       filter_level = self.class
       input_level = @_interaction_inputs
 
-      [input, *rest].map(&:to_sym).each do |key|
-        filter_level = filter_level.filters[key]
+      [input, *rest].each do |key_or_index|
+        if key_or_index.is_a?(Symbol) || key_or_index.is_a?(String)
+          key_or_index = key_or_index.to_sym
+          filter_level = filter_level.filters[key_or_index]
+
+          break false if filter_level.nil? || input_level.nil?
+          break false unless input_level.key?(key_or_index) || input_level.key?(key_or_index.to_s)
 
-        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_or_index] || input_level[key_or_index.to_s]
+        else
+          filter_level = filter_level.filters.first.last
+
+          break false if filter_level.nil? || input_level.nil?
+          break false unless key_or_index.between?(-input_level.size, input_level.size - 1)
 
-        input_level = input_level[key] || input_level[key.to_s]
+          input_level = input_level[key_or_index]
+        end
       end && true
     end
+    # rubocop:enable all
 
     protected
 
@@ -276,10 +291,12 @@ module ActiveInteraction
       @_interaction_inputs = inputs
 
       inputs.each do |key, value|
-        populate_reader(key, value) unless InputProcessor.reserved?(key)
+        next if ActiveInteraction::Inputs.reserved?(key)
+
+        populate_reader(key, value)
       end
 
-      populate_filters(InputProcessor.process(inputs))
+      populate_filters(ActiveInteraction::Inputs.process(inputs))
     end
 
     def populate_reader(key, value)
@@ -288,18 +305,16 @@ module ActiveInteraction
 
     def populate_filters(inputs)
       self.class.filters.each do |name, filter|
-        begin
-          public_send("#{name}=", filter.clean(inputs[name], self))
-        rescue InvalidValueError, MissingValueError, NoDefaultError
-          nil # #type_check will add errors if appropriate.
-        end
+        public_send("#{name}=", filter.clean(inputs[name], self))
+      rescue InvalidValueError, MissingValueError, NoDefaultError
+        nil # #type_check will add errors if appropriate.
       end
     end
 
     def type_check
       run_callbacks(:type_check) do
-        Validation.validate(self, self.class.filters, inputs).each do |error|
-          errors.add(*error)
+        Validation.validate(self, self.class.filters, inputs).each do |attr, type, kwargs = {}|
+          errors.add(attr, type, **kwargs)
         end
       end
     end

data/lib/active_interaction/concerns/active_modelable.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
@@ -34,8 +33,7 @@ module ActiveInteraction
       false
     end
 
-    #
-    module ClassMethods
+    module ClassMethods # rubocop:disable Style/Documentation
       # @return [Symbol]
       #
       # @see ActiveModel::Translation#i18n_scope

data/lib/active_interaction/concerns/active_recordable.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
@@ -24,8 +23,6 @@ module ActiveInteraction
     #   # => nil
     #
     # @return [FilterColumn, nil]
-    #
-    # @since 1.2.0
     def column_for_attribute(name)
       filter = self.class.filters[name]
       FilterColumn.intern(filter.database_column_type) if filter
@@ -49,9 +46,7 @@ module ActiveInteraction
     #   # => false
     #
     # @return [Boolean]
-    #
-    # @since 1.5.0
-    def has_attribute?(name) # rubocop:disable Style/PredicateName
+    def has_attribute?(name) # rubocop:disable Naming/PredicateName
       self.class.filters.key?(name.to_sym)
     end
   end

data/lib/active_interaction/concerns/hashable.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction

data/lib/active_interaction/concerns/missable.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction

data/lib/active_interaction/concerns/runnable.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
@@ -46,9 +45,7 @@ module ActiveInteraction
 
     # @return [Boolean]
     def valid?(*)
-      if instance_variable_defined?(:@_interaction_valid)
-        return @_interaction_valid
-      end
+      return @_interaction_valid if instance_variable_defined?(:@_interaction_valid)
 
       super
     end
@@ -71,24 +68,15 @@ module ActiveInteraction
 
     # @return (see #result=)
     # @return [nil]
-    def run # rubocop:disable MethodLength
-      self.result =
-        if valid?
-          run_callbacks(:execute) do
-            result_or_errors =
-              begin
-                execute
-              rescue Interrupt => interrupt
-                interrupt.errors
-              end
-
-            if result_or_errors.is_a?(ActiveInteraction::Errors)
-              errors.merge!(result_or_errors)
-            else
-              result_or_errors
-            end
-          end
-        end
+    def run
+      return self.result = nil unless valid?
+
+      self.result = run_callbacks(:execute) do
+        execute
+      rescue Interrupt => e
+        errors.backtrace = e.errors.backtrace || e.backtrace
+        errors.merge!(e.errors)
+      end
     end
 
     # @return [Object]
@@ -97,15 +85,15 @@ module ActiveInteraction
     def run!
       run
 
-      unless valid?
-        raise InvalidInteractionError, errors.full_messages.join(', ')
-      end
+      return result if valid?
 
-      result
+      e = InvalidInteractionError.new(errors.full_messages.join(', '))
+      e.interaction = self
+      e.set_backtrace(errors.backtrace) if errors.backtrace
+      raise e
     end
 
-    #
-    module ClassMethods
+    module ClassMethods # rubocop:disable Style/Documentation
       def new(*)
         super.tap do |instance|
           {

data/lib/active_interaction/errors.rb

@@ -1,17 +1,15 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-#
 module ActiveInteraction
   # Top-level error class. All other errors subclass this.
   #
   # @return [Class]
   Error = Class.new(StandardError)
 
-  # Raised if a class name is invalid.
+  # Raised if a constant name is invalid.
   #
   # @return [Class]
-  InvalidClassError = Class.new(Error)
+  InvalidNameError = Class.new(Error)
 
   # Raised if a converter is invalid.
   #
@@ -31,7 +29,9 @@ module ActiveInteraction
   # Raised if an interaction is invalid.
   #
   # @return [Class]
-  InvalidInteractionError = Class.new(Error)
+  class InvalidInteractionError < Error
+    attr_accessor :interaction
+  end
 
   # Raised if a user-supplied value is invalid.
   #
@@ -90,6 +90,8 @@ module ActiveInteraction
 
   # An extension that provides the ability to merge other errors into itself.
   class Errors < ActiveModel::Errors
+    attr_accessor :backtrace
+
     # Merge other errors into this one.
     #
     # @param other [Errors]
@@ -147,9 +149,8 @@ module ActiveInteraction
       if attribute?(attribute) || attribute == :base
         options = detail.dup
         error = options.delete(:error)
-        options[:message] = message
 
-        add(attribute, error, options) unless added?(attribute, error, options)
+        add(attribute, error, **options.merge(message: message)) unless added?(attribute, error, **options)
       else
         merge_message!(attribute, message)
       end

data/lib/active_interaction/filter.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 require 'active_support/inflector'
@@ -78,16 +77,16 @@ module ActiveInteraction
     #   to the default value.
     #
     # @example
-    #   ActiveInteraction::Filter.new(:example).clean(nil)
+    #   ActiveInteraction::Filter.new(:example).clean(nil, nil)
     #   # => ActiveInteraction::MissingValueError: example
     # @example
-    #   ActiveInteraction::Filter.new(:example).clean(0)
+    #   ActiveInteraction::Filter.new(:example).clean(0, nil)
     #   # => ActiveInteraction::InvalidValueError: example: 0
     # @example
-    #   ActiveInteraction::Filter.new(:example, default: nil).clean(nil)
+    #   ActiveInteraction::Filter.new(:example, default: nil).clean(nil, nil)
     #   # => nil
     # @example
-    #   ActiveInteraction::Filter.new(:example, default: 0).clean(nil)
+    #   ActiveInteraction::Filter.new(:example, default: 0).clean(nil, nil)
     #   # => ActiveInteraction::InvalidDefaultError: example: 0
     #
     # @param value [Object]
@@ -95,7 +94,9 @@ module ActiveInteraction
     #
     # @return [Object]
     #
-    # @raise (see #cast)
+    # @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)
@@ -120,7 +121,7 @@ module ActiveInteraction
     #
     # @param context [Base, nil]
     #
-    # @return (see #raw_default)
+    # @return [Object]
     #
     # @raise [NoDefaultError] If the default is missing.
     # @raise [InvalidDefaultError] If the default is invalid.
@@ -131,8 +132,8 @@ module ActiveInteraction
       raise InvalidValueError if value.is_a?(GroupedInput)
 
       cast(value, context)
-    rescue InvalidNestedValueError => error
-      raise InvalidDefaultError, "#{name}: #{value.inspect} (#{error})"
+    rescue InvalidNestedValueError => e
+      raise InvalidDefaultError, "#{name}: #{value.inspect} (#{e})"
     rescue InvalidValueError, MissingValueError
       raise InvalidDefaultError, "#{name}: #{value.inspect}"
     end
@@ -162,27 +163,6 @@ module ActiveInteraction
       options.key?(:default)
     end
 
-    # @param value [Object]
-    # @param _interaction [Base, nil]
-    #
-    # @return [Object]
-    #
-    # @raise [MissingValueError] If the value is missing and there is no
-    #   default.
-    # @raise [InvalidValueError] If the value is invalid.
-    #
-    # @private
-    def cast(value, _interaction)
-      case value
-      when NilClass
-        raise MissingValueError, name unless default?
-
-        nil
-      else
-        raise InvalidValueError, "#{name}: #{describe(value)}"
-      end
-    end
-
     # Gets the type of database column that would represent the filter data.
     #
     # @example
@@ -194,25 +174,59 @@ module ActiveInteraction
     #
     # @return [Symbol] A database column type. If no sensible mapping exists,
     #   returns `:string`.
-    #
-    # @since 1.2.0
     def database_column_type
       :string
     end
 
     private
 
-    # @param value [Object]
-    # @return [String]
+    # rubocop:disable Metrics/MethodLength
+    def cast(value, context, convert: 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
+      elsif reconstantize
+        send(__method__, value, context,
+          convert: convert,
+          reconstantize: false
+        )
+      elsif convert
+        send(__method__, convert(value), context,
+          convert: false,
+          reconstantize: reconstantize
+        )
+      else
+        raise InvalidValueError, "#{name}: #{describe(value)}"
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def matches?(_value)
+      false
+    end
+
+    def adjust_output(value, _context)
+      value
+    end
+
+    def convert(value)
+      value
+    end
+
+    def klass
+      @klass ||= Object.const_get(self.class.slug.to_s.camelize, false)
+    end
+
     def describe(value)
       value.inspect
     rescue NoMethodError
       "(Object doesn't support #inspect)"
     end
 
-    # @param context [Base, nil]
-    #
-    # @return [Object]
     def raw_default(context)
       value = options.fetch(:default)
       return value unless value.is_a?(Proc)