active_interaction 3.8.2 → 4.0.3

data/lib/active_interaction/filter_column.rb

@@ -1,10 +1,7 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
   # A minimal implementation of an `ActiveRecord::ConnectionAdapters::Column`.
-  #
-  # @since 1.2.0
   class FilterColumn
     # @return [nil]
     attr_reader :limit

data/lib/active_interaction/filters/abstract_date_time_filter.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
@@ -8,61 +7,64 @@ module ActiveInteraction
   #   objects.
   #
   # @private
-  class AbstractDateTimeFilter < AbstractFilter
-    alias _cast cast
-    private :_cast
-
-    def cast(value, context)
-      case value
-      when String
-        convert(value, context)
-      when GroupedInput
-        convert(stringify(value), context)
-      when *klasses
-        value
-      else
-        super
-      end
-    end
-
+  class AbstractDateTimeFilter < Filter
     def database_column_type
       self.class.slug
     end
 
+    def accepts_grouped_inputs?
+      true
+    end
+
     private
 
-    def convert(value, context)
+    def klasses
+      [klass]
+    end
+
+    def matches?(value)
+      klasses.any? { |klass| value.is_a?(klass) }
+    rescue NoMethodError # BasicObject
+      false
+    end
+
+    def convert(value)
+      if value.respond_to?(:to_str)
+        value = value.to_str
+        value.blank? ? send(__method__, nil) : convert_string(value)
+      elsif value.is_a?(GroupedInput)
+        convert_grouped_input(value)
+      else
+        super
+      end
+    rescue ArgumentError
+      value
+    rescue NoMethodError # BasicObject
+      super
+    end
+
+    def convert_string(value)
       if format?
         klass.strptime(value, format)
       else
         klass.parse(value) ||
           (raise ArgumentError, "no time information in #{value.inspect}")
       end
-    rescue ArgumentError
-      _cast(value, context)
     end
 
-    # @return [String]
+    def convert_grouped_input(value)
+      date = %w[1 2 3].map { |key| value[key] }.join('-')
+      time = %w[4 5 6].map { |key| value[key] }.join(':')
+
+      convert_string("#{date} #{time}")
+    end
+
     def format
       options.fetch(:format)
     end
 
-    # @return [Boolean]
     def format?
       options.key?(:format)
     end
-
-    # @return [Array<Class>]
-    def klasses
-      [klass]
-    end
-
-    # @return [String]
-    def stringify(value)
-      date = %w[1 2 3].map { |key| value[key] }.join('-')
-      time = %w[4 5 6].map { |key| value[key] }.join(':')
-
-      "#{date} #{time}"
-    end
   end
 end

data/lib/active_interaction/filters/abstract_numeric_filter.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
@@ -7,31 +6,42 @@ module ActiveInteraction
   # Common logic for filters that handle numeric objects.
   #
   # @private
-  class AbstractNumericFilter < AbstractFilter
-    alias _cast cast
-    private :_cast
+  class AbstractNumericFilter < Filter
+    def database_column_type
+      self.class.slug
+    end
+
+    private
+
+    def matches?(value)
+      value.is_a?(klass)
+    rescue NoMethodError # BasicObject
+      false
+    end
 
-    def cast(value, context)
-      case value
-      when klass
-        value
-      when Numeric, String
-        convert(value, context)
+    def convert(value)
+      if value.is_a?(Numeric)
+        safe_converter(value)
+      elsif value.respond_to?(:to_int)
+        safe_converter(value.to_int)
+      elsif value.respond_to?(:to_str)
+        value = value.to_str
+        value.blank? ? send(__method__, nil) : safe_converter(value)
       else
         super
       end
+    rescue NoMethodError # BasicObject
+      super
     end
 
-    def database_column_type
-      self.class.slug
+    def converter(value)
+      Kernel.public_send(klass.name, value)
     end
 
-    private
-
-    def convert(value, context)
-      Kernel.public_send(klass.name, value)
+    def safe_converter(value)
+      converter(value)
     rescue ArgumentError
-      _cast(value, context)
+      value
     end
   end
 end

data/lib/active_interaction/filters/array_filter.rb

@@ -1,8 +1,7 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!method self.array(*attributes, options = {}, &block)
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Arrays.
@@ -26,63 +25,87 @@ module ActiveInteraction
   class ArrayFilter < Filter
     include Missable
 
+    # The array starts with the class override key and then contains any
+    # additional options which halt explicit setting of the class.
+    FILTER_NAME_OR_OPTION = {
+      'ActiveInteraction::ObjectFilter' => [:class].freeze,
+      'ActiveInteraction::RecordFilter' => [:class].freeze,
+      'ActiveInteraction::InterfaceFilter' => %i[from methods].freeze
+    }.freeze
+    private_constant :FILTER_NAME_OR_OPTION
+
     register :array
 
-    def cast(value, context)
-      case value
-      when *classes
-        return value if filters.empty?
+    private
 
-        filter = filters.values.first
-        value.map { |e| filter.clean(e, context) }
-      else
-        super
+    def klasses
+      %w[
+        ActiveRecord::Relation
+        ActiveRecord::Associations::CollectionProxy
+      ].each_with_object([Array]) do |name, result|
+        next unless (klass = name.safe_constantize)
+
+        result.push(klass)
       end
     end
 
-    def method_missing(*, &block) # rubocop:disable Style/MethodMissing
-      super do |klass, names, options|
-        filter = klass.new(name.to_s.singularize.to_sym, options, &block)
+    def matches?(value)
+      klasses.any? { |klass| value.is_a?(klass) }
+    rescue NoMethodError # BasicObject
+      false
+    end
 
-        validate!(filter, names)
+    def adjust_output(value, context)
+      return value if filters.empty?
+
+      filter = filters.values.first
+      value.map { |e| filter.clean(e, context) }
+    end
+
+    def convert(value)
+      if value.respond_to?(:to_ary)
+        value.to_ary
+      else
+        super
+      end
+    rescue NoMethodError # BasicObject
+      super
+    end
 
-        filters[filter.name] = filter
+    def add_option_in_place_of_name(klass, options)
+      if (keys = FILTER_NAME_OR_OPTION[klass.to_s]) && (keys && options.keys).empty?
+        options.merge(
+          "#{keys.first}": name.to_s.singularize.camelize.to_sym
+        )
+      else
+        options
       end
     end
 
-    private
+    # rubocop:disable Style/MissingRespondToMissing
+    def method_missing(*, &block)
+      super do |klass, names, options|
+        options = add_option_in_place_of_name(klass, options)
 
-    # @return [Array<Class>]
-    def classes
-      result = [Array]
+        filter = klass.new(names.first || '', options, &block)
 
-      %w[
-        ActiveRecord::Relation
-        ActiveRecord::Associations::CollectionProxy
-      ].each do |name|
-        next unless (klass = name.safe_constantize)
-        result.push(klass)
-      end
+        filters[filters.size.to_s.to_sym] = filter
 
-      result
+        validate!(filter, names)
+      end
     end
+    # rubocop:enable Style/MissingRespondToMissing
 
     # @param filter [Filter]
     # @param names [Array<Symbol>]
     #
     # @raise [InvalidFilterError]
     def validate!(filter, names)
-      unless filters.empty?
-        raise InvalidFilterError, 'multiple filters in array block'
-      end
+      raise InvalidFilterError, 'multiple filters in array block' if filters.size > 1
 
-      unless names.empty?
-        raise InvalidFilterError, 'attribute names in array block'
-      end
+      raise InvalidFilterError, 'attribute names in array block' unless names.empty?
 
-      if filter.default?
-        raise InvalidDefaultError, 'default values in array block'
-      end
+      raise InvalidDefaultError, 'default values in array block' if filter.default?
 
       nil
     end

data/lib/active_interaction/filters/boolean_filter.rb

@@ -1,13 +1,12 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!method self.boolean(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
-    #     the attributes are Booleans. The strings `"1"` and `"true"`
-    #     (case-insensitive) are converted to `true` while the strings `"0"`
-    #     and `"false"` are converted to `false`.
+    #     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`.
     #
     #   @!macro filter_method_params
     #
@@ -19,19 +18,34 @@ module ActiveInteraction
   class BooleanFilter < Filter
     register :boolean
 
-    def cast(value, _interaction)
+    def database_column_type
+      self.class.slug
+    end
+
+    private
+
+    def matches?(value)
+      value.is_a?(TrueClass) || value.is_a?(FalseClass)
+    rescue NoMethodError # BasicObject
+      false
+    end
+
+    def convert(value)
+      if value.respond_to?(:to_str)
+        value = value.to_str
+        value = nil if value.blank?
+      end
+
       case value
-      when FalseClass, /\A(?:0|false|off)\z/i
+      when /\A(?:0|false|off)\z/i
         false
-      when TrueClass, /\A(?:1|true|on)\z/i
+      when /\A(?:1|true|on)\z/i
         true
       else
         super
       end
-    end
-
-    def database_column_type
-      self.class.slug
+    rescue NoMethodError # BasicObject
+      super
     end
   end
 end

data/lib/active_interaction/filters/date_filter.rb

@@ -1,8 +1,7 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!method self.date(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Dates. String values are processed using `parse`

data/lib/active_interaction/filters/date_time_filter.rb

@@ -1,8 +1,7 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!method self.date_time(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are DateTimes. String values are processed using

data/lib/active_interaction/filters/decimal_filter.rb

@@ -1,10 +1,9 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 require 'bigdecimal'
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!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
@@ -14,46 +13,29 @@ module ActiveInteraction
     #
     #   @example
     #     decimal :amount, digits: 4
-    #
-    #   @since 1.2.0
   end
 
   # @private
   class DecimalFilter < AbstractNumericFilter
     register :decimal
 
-    def cast(value, _interaction)
-      case value
-      when Numeric
-        BigDecimal(value, digits)
-      when String
-        decimal_from_string(value)
-      else
-        super
-      end
-    end
-
     private
 
-    # @return [Integer]
     def digits
       options.fetch(:digits, 0)
     end
 
-    # @param value [String] string that has to be converted
-    #
-    # @return [BigDecimal]
-    #
-    # @raise [InvalidValueError] if given value can not be converted
-    def decimal_from_string(value)
-      Float(value)
-      BigDecimal(value, digits)
-    rescue ArgumentError
-      raise InvalidValueError, "Given value: #{value.inspect}"
-    end
-
     def klass
       BigDecimal
     end
+
+    def converter(value)
+      # Ruby < 2.4 does not throw an error in BigDecimal
+      # for invalid strings. We'll simulate the error by
+      # calling Float.
+      Float(value) if value.is_a?(String)
+
+      BigDecimal(value, digits)
+    end
   end
 end