active_interaction 0.5.0 → 0.6.1

data/lib/active_interaction/errors.rb

@@ -1,7 +1,81 @@
 module ActiveInteraction
-  class InteractionInvalid < ::StandardError; end
-  class InvalidDefaultValue < ::StandardError; end
-  class InvalidNestedValue < ::StandardError; end
-  class InvalidValue < ::StandardError; end
-  class MissingValue < ::StandardError; end
+  # Top-level error class. All other errors subclass this.
+  Error = Class.new(StandardError)
+
+  # Raised if an interaction is invalid.
+  InteractionInvalidError = Class.new(Error)
+
+  # Raised if a class name is invalid.
+  InvalidClassError = Class.new(Error)
+
+  # Raised if a default value is invalid.
+  InvalidDefaultError = Class.new(Error)
+
+  # Raised if a filter has an invalid definition.
+  InvalidFilterError = Class.new(Error)
+
+  # Raised if a user-supplied value is invalid.
+  InvalidValueError = Class.new(Error)
+
+  # Raised if there is no default value.
+  NoDefaultError = Class.new(Error)
+
+  # Raised if a filter cannot be found.
+  MissingFilterError = Class.new(Error)
+
+  # Raised if no value is given.
+  MissingValueError = Class.new(Error)
+
+  # A small extension to provide symbolic error messages to make introspecting
+  #   and testing easier.
+  #
+  # @since 0.6.0
+  class Errors < ActiveModel::Errors
+    # A hash mapping attributes to arrays of symbolic messages.
+    #
+    # @return [Hash{Symbol => Array<Symbol>}]
+    attr_reader :symbolic
+
+    # Adds a symbolic error message to an attribute.
+    #
+    # @param attribute [Symbol] The attribute to add an error to.
+    # @param symbol [Symbol] The symbolic error to add.
+    # @param message [String, Symbol, Proc]
+    # @param options [Hash]
+    #
+    # @example Adding a symbolic error.
+    #   errors.add_sym(:attribute)
+    #   errors.symbolic
+    #   # => {:attribute=>[:invalid]}
+    #   errors.messages
+    #   # => {:attribute=>["is invalid"]}
+    #
+    # @return [Hash{Symbol => Array<Symbol>}]
+    #
+    # @see ActiveModel::Errors#add
+    def add_sym(attribute, symbol = :invalid, message = nil, options = {})
+      add(attribute, message || symbol, options)
+
+      symbolic[attribute] ||= []
+      symbolic[attribute] << symbol
+    end
+
+    # @private
+    def initialize(*args)
+      @symbolic = {}
+      super
+    end
+
+    # @private
+    def initialize_dup(other)
+      @symbolic = other.symbolic.dup
+      super
+    end
+
+    # @private
+    def clear
+      symbolic.clear
+      super
+    end
+  end
 end

data/lib/active_interaction/filter.rb

@@ -1,32 +1,206 @@
+require 'active_support/inflector'
+
 module ActiveInteraction
-  # @!macro [new] attribute_method_params
-  #   @param *attributes [Symbol] One or more attributes to create.
-  #   @param options [Hash]
-  #   @option options [Boolean] :allow_nil Allow a `nil` value.
-  #   @option options [Object] :default Value to use if `nil` is given.
+  # @!macro [new] filter_method_params
+  #   @param *attributes [Array<Symbol>] attributes to create
+  #   @param options [Hash{Symbol => Object}]
+  #
+  #   @option options [Object] :default fallback value if `nil` is given
 
-  # @private
+  # Describes an input filter for an interaction.
+  #
+  # @since 0.6.0
   class Filter
-    def self.factory(type)
-      klass = "#{type.to_s.camelize}Filter"
+    # @return [Regexp]
+    CLASS_REGEXP = /\AActiveInteraction::([A-Z]\w*)Filter\z/
+    private_constant :CLASS_REGEXP
+
+    # @return [Hash{Symbol => Class}]
+    CLASSES = {}
+    private_constant :CLASSES
+
+    # @return [Filters]
+    attr_reader :filters
+
+    # @return [Symbol]
+    attr_reader :name
+
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
+
+    # Filters that allow sub-filters, like arrays and hashes, must be able to
+    #   use `hash` as a part of their DSL. To keep things consistent, `hash` is
+    #   undefined on all filters. Realistically, {#name} should be unique
+    #   enough to use in place of {#hash}.
+    undef_method :hash
 
-      raise NoMethodError unless ActiveInteraction.const_defined?(klass)
+    class << self
+      # Get the filter associated with a symbol.
+      #
+      # @example
+      #   ActiveInteraction::Filter.factory(:boolean)
+      #   # => ActiveInteraction::BooleanFilter
+      #
+      # @example
+      #   ActiveInteraction::Filter.factory(:invalid)
+      #   # => ActiveInteraction::MissingFilterError: :invalid
+      #
+      # @param slug [Symbol]
+      #
+      # @return [Class]
+      #
+      # @raise [MissingFilterError] if the slug doesn't map to a filter
+      #
+      # @see .slug
+      def factory(slug)
+        CLASSES.fetch(slug)
+      rescue KeyError
+        raise MissingFilterError, slug.inspect
+      end
+
+      # Convert the class name into a short symbol.
+      #
+      # @example
+      #   ActiveInteraction::BooleanFilter.slug
+      #   # => :boolean
+      #
+      # @example
+      #   ActiveInteraction::Filter.slug
+      #   # => ActiveInteraction::InvalidClassError: ActiveInteraction::Filter
+      #
+      # @return [Symbol]
+      #
+      # @raise [InvalidClassError] if the filter doesn't have a valid slug
+      #
+      # @see .factory
+      def slug
+        match = CLASS_REGEXP.match(name)
+        raise InvalidClassError, name unless match
+        match.captures.first.underscore.to_sym
+      end
 
-      ActiveInteraction.const_get(klass)
+      # @param klass [Class]
+      #
+      # @return [nil]
+      #
+      # @private
+      def inherited(klass)
+        begin
+          CLASSES[klass.slug] = klass
+        rescue InvalidClassError
+        end
+
+        super
+      end
     end
 
-    def self.prepare(key, value, options = {}, &block)
+    # @param name [Symbol]
+    # @param options [Hash{Symbol => Object}]
+    #
+    # @option options [Object] :default fallback value to use if `nil` is given
+    def initialize(name, options = {}, &block)
+      @name = name
+      @options = options.dup
+      @filters = Filters.new
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Convert a value into the expected type. If no value is given, fall back
+    #   to the default value.
+    #
+    # @example
+    #   ActiveInteraction::Filter.new(:example).clean(nil)
+    #   # => ActiveInteraction::MissingValueError: example
+    #
+    # @example
+    #   ActiveInteraction::Filter.new(:example).clean(0)
+    #   # => ActiveInteraction::InvalidValueError: example: 0
+    #
+    # @example
+    #   ActiveInteraction::Filter.new(:example, default: nil).clean(nil)
+    #   # => nil
+    #
+    # @example
+    #   ActiveInteraction::Filter.new(:example, default: 0).clean(nil)
+    #   # => ActiveInteraction::InvalidDefault: example: 0
+    #
+    # @param value [Object]
+    #
+    # @return [Object]
+    #
+    # @raise (see #cast)
+    # @raise (see #default)
+    #
+    # @see #default
+    def clean(value)
+      value = cast(value)
+      if value.nil?
+        default
+      else
+        value
+      end
+    end
+
+    # Get the default value.
+    #
+    # @example
+    #   ActiveInteraction::Filter.new(:example, default: nil).default
+    #   # => nil
+    #
+    # @example
+    #   ActiveInteraction::Filter.new(:example, default: 0).default
+    #   # => ActiveInteraction::InvalidDefaultError: example: 0
+    #
+    # @example
+    #   ActiveInteraction::Filter.new(:example).default
+    #   # => ActiveInteraction::NoDefaultError: example
+    #
+    # @return [Object]
+    #
+    # @raise [InvalidDefaultError] if the default value is invalid
+    # @raise [NoDefaultError] if there is no default value
+    def default
+      raise NoDefaultError, name unless has_default?
+
+      cast(options[:default])
+    rescue InvalidValueError, MissingValueError
+      raise InvalidDefaultError, "#{name}: #{options[:default].inspect}"
+    end
+
+    # Tells if this filter has a default value.
+    #
+    # @example
+    #   filter = ActiveInteraction::Filter.new(:example)
+    #   filter.has_default?
+    #   # => false
+    #
+    # @example
+    #   filter = ActiveInteraction::Filter.new(:example, default: nil)
+    #   filter.has_default?
+    #   # => true
+    #
+    # @return [Boolean]
+    def has_default?
+      options.has_key?(:default)
+    end
+
+    # @param value [Object]
+    #
+    # @return [nil]
+    #
+    # @raise [InvalidValueError] if the value is invalid
+    # @raise [MissingValueError] if the value is missing and the input is required
+    #
+    # @private
+    def cast(value)
       case value
-        when NilClass
-          if options[:allow_nil]
-            nil
-          elsif options.has_key?(:default)
-            options[:default]
-          else
-            raise MissingValue
-          end
-        else
-          raise InvalidValue
+      when NilClass
+        raise MissingValueError, name unless has_default?
+
+        nil
+      else
+        raise InvalidValueError, "#{name}: #{value.inspect}"
       end
     end
   end

data/lib/active_interaction/filters.rb

@@ -0,0 +1,26 @@
+module ActiveInteraction
+  # A collection of {Filter}s.
+  #
+  # @since 0.6.0
+  class Filters
+    include Enumerable
+
+    def initialize
+      @filters = []
+    end
+
+    # @return [Enumerator]
+    def each(&block)
+      @filters.each(&block)
+    end
+
+    # @param filter [Filter]
+    #
+    # @return [Filters]
+    def add(filter)
+      @filters << filter
+
+      self
+    end
+  end
+end

data/lib/active_interaction/filters/array_filter.rb

@@ -3,8 +3,8 @@ module ActiveInteraction
     # Creates accessors for the attributes and ensures that values passed to
     #   the attributes are Arrays.
     #
-    # @macro attribute_method_params
-    # @param block [Proc] A filter method to apply to each element.
+    # @macro filter_method_params
+    # @param block [Proc] filter method to apply to each element
     #
     # @example
     #   array :ids
@@ -16,43 +16,40 @@ module ActiveInteraction
     #
     # @example An Array of Integers where some or all are nil
     #   array :ids do
-    #     integer allow_nil: true
+    #     integer default: nil
     #   end
     #
+    # @since 0.1.0
+    #
     # @method self.array(*attributes, options = {}, &block)
   end
 
   # @private
   class ArrayFilter < Filter
-    def self.prepare(key, value, options = {}, &block)
+    include MethodMissing
+
+    def cast(value)
       case value
-        when Array
-          convert_values(value, &block)
-        else
-          super
+      when Array
+        return value if filters.none?
+
+        filter = filters.first
+        value.map { |e| filter.clean(e) }
+      else
+        super
       end
     end
 
-    def self.convert_values(values, &block)
-      return values.dup unless block_given?
+    def method_missing(*args, &block)
+      super do |klass, names, options|
+        filter = klass.new(name, options, &block)
 
-      method = get_filter_method(FilterMethods.evaluate(&block))
-      values.map do |value|
-        Filter.factory(method.method_name).
-          prepare(method.attribute, value, method.options, &method.block)
-      end
-    rescue InvalidValue, MissingValue
-      raise InvalidNestedValue
-    end
-    private_class_method :convert_values
+        raise InvalidFilterError, 'multiple nested filters' if filters.any?
+        raise InvalidFilterError, 'nested name' unless names.empty?
+        raise InvalidDefaultError, 'nested default' if filter.has_default?
 
-    def self.get_filter_method(filter_methods)
-      if filter_methods.count > 1
-        raise ArgumentError, 'Array filter blocks can only contain one filter.'
-      else
-        filter_methods.first
+        filters.add(filter)
       end
     end
-    private_class_method :get_filter_method
   end
 end

data/lib/active_interaction/filters/boolean_filter.rb

@@ -1,29 +1,29 @@
 module ActiveInteraction
   class Base
     # Creates accessors for the attributes and ensures that values passed to
-    #   the attributes are Arrays. The String `"1"` is converted to `true` and
-    #   `"0"` is converted to `false`.
+    #   the attributes are Booleans. The String `"1"` is converted to `true`
+    #   and `"0"` is converted to `false`.
     #
-    # @macro attribute_method_params
+    # @macro filter_method_params
     #
     # @example
     #   boolean :subscribed
     #
+    # @since 0.1.0
+    #
     # @method self.boolean(*attributes, options = {})
   end
 
   # @private
   class BooleanFilter < Filter
-    def self.prepare(key, value, options = {}, &block)
+    def cast(value)
       case value
-        when TrueClass, FalseClass
-          value
-        when '0'
-          false
-        when '1'
-          true
-        else
-          super
+      when FalseClass, '0'
+        false
+      when TrueClass, '1'
+        true
+      else
+        super
       end
     end
   end