active_interaction 0.1.1

data/lib/active_interaction/filter_method.rb

@@ -0,0 +1,17 @@
+module ActiveInteraction
+  # @private
+  class FilterMethod
+    attr_reader :method_name, :attribute, :options, :block
+
+    def initialize(method_name, *args, &block)
+      @method_name, @block = method_name, block
+
+      @attribute = args.shift if args.first.is_a?(Symbol)
+      @options   = (args.first || {}).dup
+
+      if @options.include?(:default)
+        raise ArgumentError, ':default is not supported inside filter blocks'
+      end
+    end
+  end
+end

data/lib/active_interaction/filter_methods.rb

@@ -0,0 +1,26 @@
+module ActiveInteraction
+  # @private
+  class FilterMethods
+    include Enumerable
+    include OverloadHash
+
+    def self.evaluate(&block)
+      me = new
+      me.instance_eval(&block)
+      me
+    end
+
+    def initialize
+      @filter_methods = []
+    end
+
+    def each(&block)
+      @filter_methods.each(&block)
+    end
+
+    def method_missing(filter_type, *args, &block)
+      @filter_methods.push(FilterMethod.new(filter_type, *args, &block))
+    end
+    private :method_missing
+  end
+end

data/lib/active_interaction/filters/array_filter.rb

@@ -0,0 +1,56 @@
+module ActiveInteraction
+  class Base
+    # 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.
+    #
+    # @example
+    #   array :ids
+    #
+    # @example An Array of Integers
+    #   array :ids do
+    #     integer
+    #   end
+    #
+    # @example An Array of Integers where some or all are nil
+    #   array :ids do
+    #     integer allow_nil: true
+    #   end
+    #
+    # @method self.array(*attributes, options = {}, &block)
+  end
+
+  # @private
+  class ArrayFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when Array
+          convert_values(value, &block)
+        else
+          super
+      end
+    end
+
+    def self.convert_values(values, &block)
+      return values.dup unless block_given?
+
+      filter_method = get_filter_method(FilterMethods.evaluate(&block))
+
+      values.map do |value|
+        Filter.factory(filter_method.method_name).prepare(filter_method.attribute, value, filter_method.options, &filter_method.block)
+      end
+    end
+    private_class_method :convert_values
+
+    def self.get_filter_method(filter_methods)
+      if filter_methods.count > 1
+        raise ArgumentError, 'Array filter blocks can only contain one filter.'
+      else
+        filter_method = filter_methods.first
+      end
+    end
+    private_class_method :get_filter_method
+  end
+end

data/lib/active_interaction/filters/boolean_filter.rb

@@ -0,0 +1,30 @@
+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`.
+    #
+    # @macro attribute_method_params
+    #
+    # @example
+    #   boolean :subscribed
+    #
+    # @method self.boolean(*attributes, options = {})
+  end
+
+  # @private
+  class BooleanFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when TrueClass, FalseClass
+          value
+        when '0'
+          false
+        when '1'
+          true
+        else
+          super
+      end
+    end
+  end
+end

data/lib/active_interaction/filters/date_filter.rb

@@ -0,0 +1,31 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are Dates. String values are processed using `parse`.
+    #
+    # @macro attribute_method_params
+    #
+    # @example
+    #   date :birthday
+    #
+    # @method self.date(*attributes, options = {})
+  end
+
+  # @private
+  class DateFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when Date
+          value
+        when String
+          begin
+            Date.parse(value)
+          rescue ArgumentError
+            bad_value
+          end
+        else
+          super
+      end
+    end
+  end
+end

data/lib/active_interaction/filters/date_time_filter.rb

@@ -0,0 +1,31 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are DateTimes. String values are processed using `parse`.
+    #
+    # @macro attribute_method_params
+    #
+    # @example
+    #   date_time :start_date
+    #
+    # @method self.date_time(*attributes, options = {})
+  end
+
+  # @private
+  class DateTimeFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when DateTime
+          value
+        when String
+          begin
+            DateTime.parse(value)
+          rescue ArgumentError
+            bad_value
+          end
+        else
+          super
+      end
+    end
+  end
+end

data/lib/active_interaction/filters/file_filter.rb

@@ -0,0 +1,38 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are Files or TempFiles. It will also extract a file from
+    #   any object with a `tempfile` method. This is useful when passing in Rails
+    #   params that include a file upload.
+    #
+    # @macro attribute_method_params
+    #
+    # @example
+    #   file :image
+    #
+    # @method self.file(*attributes, options = {})
+  end
+
+  # @private
+  class FileFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      value = extract_file(value)
+
+      case value
+        when File, Tempfile
+          value
+        else
+          super
+      end
+    end
+
+    def self.extract_file(value)
+      if value.respond_to?(:tempfile)
+        value = value.tempfile
+      else
+        value
+      end
+    end
+    private_class_method :extract_file
+  end
+end

data/lib/active_interaction/filters/float_filter.rb

@@ -0,0 +1,32 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are Floats. Integer and String values are converted into
+    #   Floats.
+    #
+    # @macro attribute_method_params
+    #
+    # @example
+    #   float :amount
+    #
+    # @method self.float(*attributes, options = {})
+  end
+
+  # @private
+  class FloatFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when Float
+          value
+        when Integer, String
+          begin
+            Float(value)
+          rescue ArgumentError
+            bad_value
+          end
+        else
+          super
+      end
+    end
+  end
+end

data/lib/active_interaction/filters/hash_filter.rb

@@ -0,0 +1,47 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are Hashes.
+    #
+    # @macro attribute_method_params
+    # @param block [Proc] Filter methods to apply for select keys.
+    #
+    # @example
+    #   hash :order
+    #
+    # @example A Hash where certain keys also have their values ensured.
+    #   hash :order do
+    #     model :account
+    #     model :item
+    #     integer :quantity
+    #     boolean :delivered
+    #   end
+    #
+    # @method self.hash(*attributes, options = {}, &block)
+  end
+
+  # @private
+  class HashFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when Hash
+          convert_values(value.dup, &block)
+        else
+          super
+      end
+    end
+
+    def self.convert_values(hash, &block)
+      return hash unless block_given?
+
+      FilterMethods.evaluate(&block).each do |filter_method|
+        key = filter_method.attribute
+
+        hash[key] = Filter.factory(filter_method.method_name).prepare(key, hash[key], filter_method.options, &filter_method.block)
+      end
+
+      hash
+    end
+    private_class_method :convert_values
+  end
+end

data/lib/active_interaction/filters/integer_filter.rb

@@ -0,0 +1,31 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are Integers. String values are converted into Integers.
+    #
+    # @macro attribute_method_params
+    #
+    # @example
+    #   integer :quantity
+    #
+    # @method self.integer(*attributes, options = {})
+  end
+
+  # @private
+  class IntegerFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when Integer
+          value
+        when String
+          begin
+            Integer(value)
+          rescue ArgumentError
+            bad_value
+          end
+        else
+          super
+      end
+    end
+  end
+end

data/lib/active_interaction/filters/model_filter.rb

@@ -0,0 +1,40 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are the correct class.
+    #
+    # @macro attribute_method_params
+    # @option options [Class, String, Symbol] :class (use the attribute name) Class name used to ensure the value.
+    #
+    # @example Ensures that the class is `Account`
+    #   model :account
+    #
+    # @example Ensures that the class is `User`
+    #   model :account, class: User
+    #
+    # @method self.model(*attributes, options = {})
+  end
+
+  # @private
+  class ModelFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      key_class = constantize(options.fetch(:class, key))
+
+      case value
+        when key_class
+          value
+        else
+          super
+      end
+    end
+
+    def self.constantize(constant_name)
+      if constant_name.is_a?(Symbol) || constant_name.is_a?(String)
+        constant_name.to_s.classify.constantize
+      else
+        constant_name
+      end
+    end
+    private_class_method :constantize
+  end
+end

data/lib/active_interaction/filters/string_filter.rb

@@ -0,0 +1,25 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are Strings.
+    #
+    # @macro attribute_method_params
+    #
+    # @example
+    #   string :first_name
+    #
+    # @method self.string(*attributes, options = {})
+  end
+
+  # @private
+  class StringFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when String
+          value
+        else
+          super
+      end
+    end
+  end
+end

data/lib/active_interaction/filters/time_filter.rb

@@ -0,0 +1,44 @@
+module ActiveInteraction
+  class Base
+    # Creates accessors for the attributes and ensures that values passed to
+    #   the attributes are Times. Numeric values are processed using `at`.
+    #   Strings are processed using `parse`. If `Time.zone` is available it will
+    #   be used so that the values are time zone aware.
+    #
+    # @macro attribute_method_params
+    #
+    # @example
+    #   time :start_date
+    #
+    # @method self.time(*attributes, options = {})
+  end
+
+  # @private
+  class TimeFilter < Filter
+    def self.prepare(key, value, options = {}, &block)
+      case value
+        when Time
+          value
+        when String
+          begin
+            time.parse(value)
+          rescue ArgumentError
+            bad_value
+          end
+        when Numeric
+          time.at(value)
+        else
+          super
+      end
+    end
+
+    def self.time
+      if Time.respond_to?(:zone)
+        Time.zone
+      else
+        Time
+      end
+    end
+    private_class_method :time
+  end
+end