array validation for primative datatypes

array validation for hashes

lib/rails_param/param.rb

 module RailsParam
 module RailsParam
   module Param
   module Param
 
 
+    DEFAULT_PRECISION = 14
+
     class InvalidParameterError < StandardError
     class InvalidParameterError < StandardError
       attr_accessor :param, :options
       attr_accessor :param, :options
     end
     end
 
 
-    def param!(name, type, options = {})
-      name = name.to_s
+    class MockController
+      include RailsParam::Param
+      attr_accessor :params
+    end
+
+    def param!(name, type, options = {}, &block)
+      name = name.to_s unless name.is_a? Integer # keep index for validating elements
 
 
       return unless params.member?(name) || options[:default].present? || options[:required]
       return unless params.member?(name) || options[:default].present? || options[:required]
 
 
@@ -15,8 +22,23 @@ module RailsParam
         params[name] = (options[:default].call if options[:default].respond_to?(:call)) || options[:default] if params[name].nil? and options[:default]
         params[name] = (options[:default].call if options[:default].respond_to?(:call)) || options[:default] if params[name].nil? and options[:default]
         params[name] = options[:transform].to_proc.call(params[name]) if params[name] and options[:transform]
         params[name] = options[:transform].to_proc.call(params[name]) if params[name] and options[:transform]
         validate!(params[name], options)
         validate!(params[name], options)
+        if block_given?
+          if type == Array
+            params[name].each_with_index do |element, i|
+              if element.is_a?(Hash)
+                recurse element, &block
+              else
+                params[name][i] = recurse({ i => element }, i, &block) # supply index as key unless value is hash
+              end
+            end
+          else
+            recurse params[name], &block
+          end
+        end
+        params[name]
       rescue InvalidParameterError => exception
       rescue InvalidParameterError => exception
-        exception.param, exception.options = name, options
+        exception.param ||= name
+        exception.options ||= options
         raise exception
         raise exception
       end
       end
     end
     end
@@ -41,6 +63,13 @@ module RailsParam
 
 
     private
     private
 
 
+    def recurse(params, index = nil)
+      raise InvalidParameterError, 'no block given' unless block_given?
+      controller = RailsParam::Param::MockController.new
+      controller.params = params
+      yield(controller, index)
+    end
+
     def coerce(param, type, options = {})
     def coerce(param, type, options = {})
       begin
       begin
         return nil if param.nil?
         return nil if param.nil?
@@ -52,8 +81,12 @@ module RailsParam
         return Time.parse(param) if type == Time
         return Time.parse(param) if type == Time
         return DateTime.parse(param) if type == DateTime
         return DateTime.parse(param) if type == DateTime
         return Array(param.split(options[:delimiter] || ",")) if type == Array
         return Array(param.split(options[:delimiter] || ",")) if type == Array
-        return Hash[param.split(options[:delimiter] || ",").map{|c| c.split(options[:separator] || ":")}] if type == Hash
+        return Hash[param.split(options[:delimiter] || ",").map { |c| c.split(options[:separator] || ":") }] if type == Hash
         return (/(false|f|no|n|0)$/i === param.to_s ? false : (/(true|t|yes|y|1)$/i === param.to_s ? true : nil)) if type == TrueClass || type == FalseClass || type == :boolean
         return (/(false|f|no|n|0)$/i === param.to_s ? false : (/(true|t|yes|y|1)$/i === param.to_s ? true : nil)) if type == TrueClass || type == FalseClass || type == :boolean
+        if type == BigDecimal
+          param = param.delete('$,').strip.to_f if param.is_a?(String)
+          return BigDecimal.new(param, (options[:precision] || DEFAULT_PRECISION))
+        end
         return nil
         return nil
       rescue ArgumentError
       rescue ArgumentError
         raise InvalidParameterError, "'#{param}' is not a valid #{type}"
         raise InvalidParameterError, "'#{param}' is not a valid #{type}"