active_interaction 3.8.3 → 4.0.0

data/lib/active_interaction/filters/float_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.float(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Floats. Integer and String values are converted

data/lib/active_interaction/filters/hash_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.hash(*attributes, options = {}, &block)
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Hashes.
@@ -26,21 +25,46 @@ module ActiveInteraction
 
     register :hash
 
-    def cast(value, context)
-      case value
-      when Hash
-        value = value.with_indifferent_access
-        initial = strip? ? ActiveSupport::HashWithIndifferentAccess.new : value
+    private
 
-        filters.each_with_object(initial) do |(name, filter), h|
-          clean_value(h, name.to_s, filter, value, context)
-        end
+    def matches?(value)
+      value.is_a?(Hash)
+    rescue NoMethodError # BasicObject
+      false
+    end
+
+    def clean_value(hash, name, filter, value, context)
+      hash[name] = filter.clean(value[name], context)
+    rescue InvalidValueError, MissingValueError
+      raise InvalidNestedValueError.new(name, value[name])
+    end
+
+    def strip?
+      options.fetch(:strip, true)
+    end
+
+    def adjust_output(value, context)
+      value = value.to_hash.with_indifferent_access
+
+      initial = strip? ? ActiveSupport::HashWithIndifferentAccess.new : value
+
+      filters.each_with_object(initial) do |(name, filter), hash|
+        clean_value(hash, name.to_s, filter, value, context)
+      end
+    end
+
+    def convert(value)
+      if value.respond_to?(:to_hash)
+        value.to_hash
       else
         super
       end
+    rescue NoMethodError # BasicObject
+      super
     end
 
-    def method_missing(*args, &block) # rubocop:disable Style/MethodMissing
+    # rubocop:disable Style/MissingRespondToMissing
+    def method_missing(*args, &block)
       super(*args) do |klass, names, options|
         raise InvalidFilterError, 'missing attribute name' if names.empty?
 
@@ -49,28 +73,14 @@ module ActiveInteraction
         end
       end
     end
-
-    private
-
-    def clean_value(h, name, filter, value, context)
-      h[name] = filter.clean(value[name], context)
-    rescue InvalidValueError, MissingValueError
-      raise InvalidNestedValueError.new(name, value[name])
-    end
+    # rubocop:enable Style/MissingRespondToMissing
 
     def raw_default(*)
       value = super
 
-      if value.is_a?(Hash) && !value.empty?
-        raise InvalidDefaultError, "#{name}: #{value.inspect}"
-      end
+      raise InvalidDefaultError, "#{name}: #{value.inspect}" if value.is_a?(Hash) && !value.empty?
 
       value
     end
-
-    # @return [Boolean]
-    def strip?
-      options.fetch(:strip, true)
-    end
   end
 end

data/lib/active_interaction/filters/integer_filter.rb

@@ -1,14 +1,16 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!method self.integer(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Integers. String values are converted into
     #     Integers.
     #
     #   @!macro filter_method_params
+    #   @option options [Integer] :base (10) The base used to convert strings
+    #     into integers. When set to `0` it will honor radix indicators (i.e.
+    #     0, 0b, and 0x).
     #
     #   @example
     #     integer :quantity
@@ -20,15 +22,12 @@ module ActiveInteraction
 
     private
 
-    # @return [Integer]
     def base
-      options.fetch(:base, 0)
+      options.fetch(:base, 10)
     end
 
-    def convert(value, context)
-      Integer(value, base)
-    rescue ArgumentError
-      _cast(value, context)
+    def converter(value)
+      Integer(value, value.is_a?(String) ? base : 0)
     end
   end
 end

data/lib/active_interaction/filters/interface_filter.rb

@@ -1,18 +1,24 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  class Base # rubocop:disable Lint/EmptyClass
     # @!method self.interface(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
-    #   the attributes implement an interface.
+    #   the attributes implement an interface. An interface can be based on a
+    #   set of methods or the existance of a class or module in the ancestors
+    #   of the passed value.
     #
     #   @!macro filter_method_params
-    #   @option options [Array<String,Symbol>] :methods ([]) the methods that
+    #   @option options [Constant, String, Symbol] :from (use the attribute
+    #     name) The class or module representing the interface to check for.
+    #   @option options [Array<String, Symbol>] :methods ([]) the methods that
     #     objects conforming to this interface should respond to
     #
     #   @example
-    #     interface :anything
+    #     interface :concern
+    #   @example
+    #     interface :person,
+    #       from: Manageable
     #   @example
     #     interface :serializer,
     #       methods: %i[dump load]
@@ -22,24 +28,52 @@ module ActiveInteraction
   class InterfaceFilter < Filter
     register :interface
 
-    def cast(value, _interaction)
-      matches?(value) ? value : super
+    def initialize(name, options = {}, &block)
+      if options.key?(:methods) && options.key?(:from)
+        raise InvalidFilterError,
+          'method and from options cannot both be passed'
+      end
+
+      super
     end
 
     private
 
-    # @param object [Object]
-    #
-    # @return [Boolean]
+    def from
+      const_name = options.fetch(:from, name).to_s.camelize
+      Object.const_get(const_name)
+    rescue NameError
+      raise InvalidNameError,
+        "constant #{const_name.inspect} does not exist"
+    end
+
     def matches?(object)
-      methods.all? { |method| object.respond_to?(method) }
+      return matches_methods?(object) if options.key?(:methods)
+
+      const = from
+      if checking_class_inheritance?(object, const)
+        class_inherits_from?(object, const)
+      else
+        singleton_ancestor?(object, const)
+      end
     rescue NoMethodError
       false
     end
 
-    # @return [Array<Symbol>]
-    def methods
-      options.fetch(:methods, [])
+    def matches_methods?(object)
+      options.fetch(:methods, []).all? { |method| object.respond_to?(method) }
+    end
+
+    def checking_class_inheritance?(object, from)
+      object.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)
     end
   end
 end

data/lib/active_interaction/filters/object_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.object(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are the correct class.
@@ -29,69 +28,43 @@ module ActiveInteraction
   class ObjectFilter < Filter
     register :object
 
-    # rubocop:disable Metrics/MethodLength
-    def cast(value, context, reconstantize: true, convert: true)
-      @klass ||= klass
-
-      if matches?(value)
-        value
-      elsif reconstantize
-        @klass = klass
-        public_send(__method__, value, context,
-          reconstantize: false,
-          convert: convert
-        )
-      elsif !value.nil? && convert && (converter = options[:converter])
-        value = convert(klass, value, converter)
-        public_send(__method__, value, context,
-          reconstantize: reconstantize,
-          convert: false
-        )
-      else
-        super(value, context)
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
     private
 
-    # @return [Class]
-    #
-    # @raise [InvalidClassError]
     def klass
       klass_name = options.fetch(:class, name).to_s.camelize
       Object.const_get(klass_name)
     rescue NameError
-      raise InvalidClassError, "class #{klass_name.inspect} does not exist"
+      raise InvalidNameError, "class #{klass_name.inspect} does not exist"
     end
 
-    # @param value [Object]
-    #
-    # @return [Boolean]
     def matches?(value)
-      @klass === value || # rubocop:disable Style/CaseEquality
-        value.is_a?(@klass)
+      value.class <= klass
+    rescue NoMethodError
+      false
     end
 
-    def convert(klass, value, converter) # rubocop:disable Metrics/MethodLength
-      result =
-        case converter
-        when Proc
-          converter.call(value)
-        when Symbol
-          klass.public_send(converter, value)
-        else
-          raise InvalidConverterError,
-            "#{converter.inspect} is not a valid converter"
-        end
-
-      raise InvalidValueError if result.nil?
-
-      result
+    def convert(value)
+      converter(value).tap do |result|
+        raise InvalidValueError if result.nil?
+      end
     rescue StandardError => e
       raise e if e.is_a?(InvalidConverterError)
 
       raise InvalidValueError
     end
+
+    def converter(value)
+      return value unless (converter = options[:converter])
+
+      case converter
+      when Proc
+        converter.call(value)
+      when Symbol
+        klass.public_send(converter, value)
+      else
+        raise InvalidConverterError,
+          "#{converter.inspect} is not a valid converter"
+      end
+    end
   end
 end

data/lib/active_interaction/filters/record_filter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveInteraction
-  class Base
+  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.
@@ -28,49 +28,24 @@ module ActiveInteraction
   class RecordFilter < Filter
     register :record
 
-    # rubocop:disable Metrics/MethodLength
-    def cast(value, context, reconstantize: true, convert: true)
-      @klass ||= klass
-
-      if matches?(value)
-        value
-      elsif reconstantize
-        @klass = klass
-        public_send(__method__, value, context,
-          reconstantize: false,
-          convert: convert
-        )
-      elsif !value.nil? && convert
-        finder = options.fetch(:finder, :find)
-        value = find(klass, value, finder)
-        public_send(__method__, value, context,
-          reconstantize: reconstantize,
-          convert: false
-        )
-      else
-        super(value, context)
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
     private
 
-    # @return [Class]
-    #
-    # @raise [InvalidClassError]
     def klass
       klass_name = options.fetch(:class, name).to_s.camelize
       Object.const_get(klass_name)
     rescue NameError
-      raise InvalidClassError, "class #{klass_name.inspect} does not exist"
+      raise InvalidNameError, "class #{klass_name.inspect} does not exist"
     end
 
-    # @param value [Object]
-    #
-    # @return [Boolean]
     def matches?(value)
-      @klass === value || # rubocop:disable Style/CaseEquality
-        value.is_a?(@klass)
+      value.class <= klass
+    rescue NoMethodError
+      false
+    end
+
+    def convert(value)
+      finder = options.fetch(:finder, :find)
+      find(klass, value, finder)
     end
 
     def find(klass, value, finder)

data/lib/active_interaction/filters/string_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.string(*attributes, options = {})
     #   Creates accessors for the attributes and ensures that values passed to
     #     the attributes are Strings.
@@ -21,20 +20,30 @@ module ActiveInteraction
   class StringFilter < Filter
     register :string
 
-    def cast(value, _interaction)
-      case value
-      when String
-        strip? ? value.strip : value
-      else
-        super
-      end
-    end
-
     private
 
-    # @return [Boolean]
     def strip?
       options.fetch(:strip, true)
     end
+
+    def matches?(value)
+      value.is_a?(String)
+    rescue NoMethodError # BasicObject
+      false
+    end
+
+    def adjust_output(value, _context)
+      strip? ? value.strip : value
+    end
+
+    def convert(value)
+      if value.respond_to?(:to_str)
+        value.to_str
+      else
+        super
+      end
+    rescue NoMethodError # BasicObject
+      super
+    end
   end
 end