rails_param 0.10.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86a75a7469730b59de76372987ffe4a28f4ebfc5f4b2956a0052af6b70c32bf9
-  data.tar.gz: fe6a7b5bf1dd8ba1615243c07dfb215d4714b4236674146333ecf42ce2539f6f
+  metadata.gz: d0d3e366d59b97f9e8453e2721f975afe0cbed9b29de26c35e786552707a3586
+  data.tar.gz: ed1a7c052cd69b75e2551cce07c2004094b0b95307490d72b88185a0da693c79
 SHA512:
-  metadata.gz: f0af1329f2b47c1267b87dc3c850760e223c85177202b0a1d2b4c6d2fdb6e8fdaff055b3500182862f3be52ac760679673a879329b4f2fd1b9a1b61155fbfd12
-  data.tar.gz: b1483e1c051a615a6517e93d6209194d1da6911f277acf46163485a8be15b88a1ca6258bf64ae3cc52a9cc732861c02733dc710183da49f6ec020a1abfde3011
+  metadata.gz: f70757e8463748ec31be8f61176a80fb1da2460af184c8a096a2abf928cf1c3507d77290e4a7f38f979829bad259e850afc4a1f0c31fd0f5bcd3fccad46834f4
+  data.tar.gz: 12074dad3f21ba4d0e1afd8bbc9db9ad827486dbe014f930c89d7fcc07ebed7c192da0aa31fe8b85041947541e1410d600d7ee630a5128522fc4da98b8bfd809

data/README.md

@@ -26,6 +26,10 @@ All the credits go to [@mattt](https://twitter.com/mattt).
 
 It has all the features of the sinatra-param gem, I used bang methods (like param!) to indicate that they are destructive as they change the controller params object and may raise an exception.
 
+## Upgrading
+
+Find a list of breaking changes in [UPGRADING](UPGRADING.md).
+
 ## Installation
 
 As usual, in your Gemfile...
@@ -67,7 +71,7 @@ By declaring parameter types, incoming parameters will automatically be transfor
 
 ### Validations
 
-Encapsulate business logic in a consistent way with validations. If a parameter does not satisfy a particular condition, an exception (RailsParam::Param::InvalidParameterError) is raised.
+Encapsulate business logic in a consistent way with validations. If a parameter does not satisfy a particular condition, an exception (RailsParam::InvalidParameterError) is raised.
 You may use the [rescue_from](http://api.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from) method in your controller to catch this kind of exception.
 
 - `required`
@@ -75,6 +79,7 @@ You may use the [rescue_from](http://api.rubyonrails.org/classes/ActiveSupport/R
 - `is`
 - `in`, `within`, `range`
 - `min` / `max`
+- `min_length` / `max_length`
 - `format`
 
 Customize exception message with option `:message`

data/lib/rails_param/coercion/array_param.rb

@@ -0,0 +1,18 @@
+module RailsParam
+  class Coercion
+    class ArrayParam < VirtualParam
+      def coerce
+        return param if param.is_a?(Array)
+
+        Array(param.split(options[:delimiter] || ","))
+      end
+
+      private
+
+      def argument_validation
+        raise ArgumentError unless type == Array
+        raise ArgumentError unless param.respond_to?(:split)
+      end
+    end
+  end
+end

data/lib/rails_param/coercion/big_decimal_param.rb

@@ -0,0 +1,17 @@
+module RailsParam
+  class Coercion
+    class BigDecimalParam < VirtualParam
+      DEFAULT_PRECISION = 14
+
+      def coerce
+        stripped_param = if param.is_a?(String)
+                            param.delete('$,').strip.to_f
+                          else
+                            param
+                          end
+
+        BigDecimal(stripped_param, options[:precision] || DEFAULT_PRECISION)
+      end
+    end
+  end
+end

data/lib/rails_param/coercion/boolean_param.rb

@@ -0,0 +1,15 @@
+module RailsParam
+  class Coercion
+    class BooleanParam < VirtualParam
+      FALSEY = /^(false|f|no|n|0)$/i.freeze
+      TRUTHY = /^(true|t|yes|y|1)$/i.freeze
+
+      def coerce
+        return false if FALSEY === param.to_s
+        return true if TRUTHY === param.to_s
+
+        raise ArgumentError
+      end
+    end
+  end
+end

data/lib/rails_param/coercion/float_param.rb

@@ -0,0 +1,9 @@
+module RailsParam
+  class Coercion
+    class FloatParam < VirtualParam
+      def coerce
+        Float(param)
+      end
+    end
+  end
+end

data/lib/rails_param/coercion/hash_param.rb

@@ -0,0 +1,18 @@
+module RailsParam
+  class Coercion
+    class HashParam < VirtualParam
+      def coerce
+        return param if param.is_a?(ActionController::Parameters)
+        raise ArgumentError unless param.respond_to?(:split)
+
+        Hash[param.split(options[:delimiter] || ",").map { |c| c.split(options[:separator] || ":") }]
+      end
+
+      private
+
+      def argument_validation
+        raise ArgumentError unless type == Hash
+      end
+    end
+  end
+end

data/lib/rails_param/coercion/integer_param.rb

@@ -0,0 +1,9 @@
+module RailsParam
+  class Coercion
+    class IntegerParam < VirtualParam
+      def coerce
+        Integer(param)
+      end
+    end
+  end
+end

data/lib/rails_param/coercion/string_param.rb

@@ -0,0 +1,9 @@
+module RailsParam
+  class Coercion
+    class StringParam < VirtualParam
+      def coerce
+        String(param)
+      end
+    end
+  end
+end

data/lib/rails_param/coercion/time_param.rb

@@ -0,0 +1,17 @@
+module RailsParam
+  class Coercion
+    class TimeParam < VirtualParam
+      def coerce
+        return type.strptime(param, options[:format]) if options[:format].present?
+
+        type.parse(param)
+      end
+
+      private
+
+      def argument_validation
+        raise ArgumentError unless type.respond_to?(:parse)
+      end
+    end
+  end
+end

data/lib/rails_param/coercion/virtual_param.rb

@@ -0,0 +1,24 @@
+module RailsParam
+  class Coercion
+    class VirtualParam
+      attr_reader :param, :options, :type
+
+      def initialize(param:, options: nil, type: nil)
+        @param = param
+        @options = options
+        @type = type
+        argument_validation
+      end
+
+      def coerce
+        nil
+      end
+
+      private
+
+      def argument_validation
+        nil
+      end
+    end
+  end
+end

data/lib/rails_param/coercion.rb

@@ -0,0 +1,41 @@
+module RailsParam
+  class Coercion
+    attr_reader :coercion, :param
+
+    PARAM_TYPE_MAPPING = {
+      Integer => IntegerParam,
+      Float => FloatParam,
+      String => StringParam,
+      Array => ArrayParam,
+      Hash => HashParam,
+      BigDecimal => BigDecimalParam,
+      Date => TimeParam,
+      DateTime => TimeParam,
+      Time => TimeParam,
+      TrueClass => BooleanParam,
+      FalseClass => BooleanParam,
+      boolean: BooleanParam
+    }.freeze
+
+    TIME_TYPES = [Date, DateTime, Time].freeze
+    BOOLEAN_TYPES = [TrueClass, FalseClass, :boolean].freeze
+
+    def initialize(param, type, options)
+      @param = param
+      @coercion = klass_for(type).new(param: param, options: options, type: type)
+    end
+
+    def klass_for(type)
+      klass = PARAM_TYPE_MAPPING[type]
+      return klass if klass
+
+      raise TypeError
+    end
+
+    def coerce
+      return nil if param.nil?
+
+      coercion.coerce
+    end
+  end
+end

data/lib/rails_param/invalid_parameter_error.rb

@@ -0,0 +1,17 @@
+module RailsParam
+  class InvalidParameterError < StandardError
+    attr_accessor :param, :options
+
+    def initialize(message, param: nil, options: {})
+      self.param = param
+      self.options = options
+      super(message)
+    end
+
+    def message
+      return options[:message] if options.is_a?(Hash) && options.key?(:message)
+
+      super
+    end
+  end
+end

data/lib/rails_param/param.rb

@@ -1,173 +1,5 @@
 module RailsParam
-  module Param
-
-    DEFAULT_PRECISION = 14
-    TIME_TYPES = [Date, DateTime, Time].freeze
-    STRING_OR_TIME_TYPES = ([String] + TIME_TYPES).freeze
-
-    class InvalidParameterError < StandardError
-      attr_accessor :param, :options
-
-      def message
-        return options[:message] if options.is_a?(Hash) && options.key?(:message)
-        super
-      end
-    end
-
-    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.include?(name) || check_param_presence?(options[:default]) || options[:required]
-
-      begin
-        params[name] = coerce(params[name], type, options)
-
-        # set default
-        if options[:default].respond_to?(:call)
-          params[name] = options[:default].call
-        elsif params[name].nil? && check_param_presence?(options[:default])
-          params[name] = options[:default]
-        end
-
-        # apply tranformation
-        if params.include?(name) && options[:transform]
-          params[name] = options[:transform].to_proc.call(params[name])
-        end
-
-        # validate
-        validate!(params[name], name, options)
-
-        if block_given?
-          if type == Array
-            params[name].each_with_index do |element, i|
-              if element.is_a?(Hash) || element.is_a?(ActionController::Parameters)
-                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
-        exception.param ||= name
-        exception.options ||= options
-        raise exception
-      end
-    end
-
-    # TODO: should we reintegrate this method?
-    # def one_of!(*names)
-    #   count = 0
-    #   names.each do |name|
-    #     if params[name] and params[name].present?
-    #       count += 1
-    #       next unless count > 1
-    #
-    #       error = "Parameters #{names.join(', ')} are mutually exclusive"
-    #       if content_type and content_type.match(mime_type(:json))
-    #         error = {message: error}.to_json
-    #       end
-    #
-    #       # do something with error object
-    #     end
-    #   end
-    # end
-
-    private
-
-    def check_param_presence? param
-      not param.nil?
-    end
-
-    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 = {})
-      begin
-        return nil if param.nil?
-        return param if (param.is_a?(type) rescue false)
-        if (param.is_a?(Array) && type != Array) || ((param.is_a?(Hash) || param.is_a?(ActionController::Parameters)) && type != Hash)
-          raise InvalidParameterError, "'#{param}' is not a valid #{type}"
-        end
-        return param if (param.is_a?(ActionController::Parameters) && type == Hash rescue false)
-        return Integer(param) if type == Integer
-        return Float(param) if type == Float
-        return String(param) if type == String
-        if TIME_TYPES.include? type
-          if options[:format].present?
-            return type.strptime(param, options[:format])
-          else
-            return type.parse(param)
-          end
-        end
-        return Array(param.split(options[:delimiter] || ",")) if type == Array
-        return Hash[param.split(options[:delimiter] || ",").map { |c| c.split(options[:separator] || ":") }] if type == Hash
-        if type == TrueClass || type == FalseClass || type == :boolean
-          return false if /^(false|f|no|n|0)$/i === param.to_s
-          return true if /^(true|t|yes|y|1)$/i === param.to_s
-
-          raise ArgumentError
-        end
-        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
-      rescue ArgumentError
-        raise InvalidParameterError, "'#{param}' is not a valid #{type}"
-      end
-    end
-
-    def validate!(param, param_name, options)
-      options.each do |key, value|
-        case key
-          when :required
-            raise InvalidParameterError, "Parameter #{param_name} is required" if value && param.nil?
-          when :blank
-            raise InvalidParameterError, "Parameter #{param_name} cannot be blank" if !value && case param
-                                                                                    when String
-                                                                                      !(/\S/ === param)
-                                                                                    when Array, Hash
-                                                                                      param.empty?
-                                                                                    else
-                                                                                      param.nil?
-                                                                                  end
-          when :format
-            raise InvalidParameterError, "Parameter #{param_name} must be a string if using the format validation" unless STRING_OR_TIME_TYPES.any? { |cls| param.kind_of? cls }
-            raise InvalidParameterError, "Parameter #{param_name} must match format #{value}" if param.kind_of?(String) && param !~ value
-          when :is
-            raise InvalidParameterError, "Parameter #{param_name} must be #{value}" unless param === value
-          when :in, :within, :range
-            raise InvalidParameterError, "Parameter #{param_name} must be within #{value}" unless param.nil? || case value
-                                                                                                    when Range
-                                                                                                      value.include?(param)
-                                                                                                    else
-                                                                                                      Array(value).include?(param)
-                                                                                                  end
-          when :min
-            raise InvalidParameterError, "Parameter #{param_name} cannot be less than #{value}" unless param.nil? || value <= param
-          when :max
-            raise InvalidParameterError, "Parameter #{param_name} cannot be greater than #{value}" unless param.nil? || value >= param
-          when :min_length
-            raise InvalidParameterError, "Parameter #{param_name} cannot have length less than #{value}" unless param.nil? || value <= param.length
-          when :max_length
-            raise InvalidParameterError, "Parameter #{param_name} cannot have length greater than #{value}" unless param.nil? || value >= param.length
-        end
-      end
-    end
-
+  def param!(name, type, options = {}, &block)
+    ParamEvaluator.new(params).param!(name, type, options, &block)
   end
 end

data/lib/rails_param/param_evaluator.rb

@@ -0,0 +1,90 @@
+module RailsParam
+  class ParamEvaluator
+    attr_accessor :params
+
+    def initialize(params)
+      @params = params
+    end
+
+    def param!(name, type, options = {}, &block)
+      name = name.is_a?(Integer)? name : name.to_s
+      return unless params.include?(name) || check_param_presence?(options[:default]) || options[:required]
+
+      # coerce value
+      coerced_value = coerce(
+        params[name],
+        type,
+        options
+      )
+      parameter = RailsParam::Parameter.new(
+        name: name,
+        value: coerced_value,
+        type: type,
+        options: options,
+        &block
+      )
+
+      parameter.set_default if parameter.should_set_default?
+
+      # validate presence
+      if params[name].nil? && options[:required]
+        raise InvalidParameterError.new(
+          "Parameter #{name} is required",
+          param: name,
+          options: options
+        )
+      end
+
+      recurse_on_parameter(parameter, &block) if block_given?
+
+      # apply transformation
+      parameter.transform if params.include?(name) && options[:transform]
+
+      # validate
+      validate!(parameter)
+
+      # set params value
+      params[name] = parameter.value
+    end
+
+    private
+
+    def recurse_on_parameter(parameter, &block)
+      if parameter.type == Array
+        parameter.value.each_with_index do |element, i|
+          if element.is_a?(Hash) || element.is_a?(ActionController::Parameters)
+            recurse element, &block
+          else
+            parameter.value[i] = recurse({ i => element }, i, &block) # supply index as key unless value is hash
+          end
+        end
+      else
+        recurse parameter.value, &block
+      end
+    end
+
+    def recurse(element, index = nil)
+      raise InvalidParameterError, 'no block given' unless block_given?
+
+      yield(ParamEvaluator.new(element), index)
+    end
+
+    def check_param_presence? param
+      !param.nil?
+    end
+
+    def coerce(param, type, options = {})
+      begin
+        return param if (param.is_a?(type) rescue false)
+
+        Coercion.new(param, type, options).coerce
+      rescue ArgumentError, TypeError
+        raise InvalidParameterError, "'#{param}' is not a valid #{type}"
+      end
+    end
+
+    def validate!(param)
+      param.validate
+    end
+  end
+end

data/lib/rails_param/parameter.rb

@@ -0,0 +1,37 @@
+module RailsParam
+  class Parameter
+    attr_accessor :name, :value, :options, :type
+
+    TIME_TYPES = [Date, DateTime, Time].freeze
+    STRING_OR_TIME_TYPES = ([String] + TIME_TYPES).freeze
+
+    def initialize(name:, value:, options: {}, type: nil)
+      @name = name
+      @value = value
+      @options = options
+      @type = type
+    end
+
+    def should_set_default?
+      value.nil? && check_param_presence?(options[:default])
+    end
+
+    def set_default
+      self.value = options[:default].respond_to?(:call) ? options[:default].call : options[:default]
+    end
+
+    def transform
+      self.value = options[:transform].to_proc.call(value)
+    end
+
+    def validate
+      Validator.new(self).validate!
+    end
+
+    private
+
+    def check_param_presence?(param)
+      !param.nil?
+    end
+  end
+end

data/lib/rails_param/validator/blank.rb

@@ -0,0 +1,24 @@
+module RailsParam
+  class Validator
+    class Blank < Validator
+      def valid_value?
+        return false if parameter.options[:blank]
+
+        case value
+        when String
+          (/\S/ === value)
+        when Array, Hash, ActionController::Parameters
+          !value.empty?
+        else
+          !value.nil?
+        end
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot be blank"
+      end
+    end
+  end
+end

data/lib/rails_param/validator/custom.rb

@@ -0,0 +1,13 @@
+module RailsParam
+  class Validator
+    class Custom < Validator
+      def valid_value?
+        !options[:custom].call(value)
+      end
+
+      private
+
+      def error_message; end
+    end
+  end
+end

data/lib/rails_param/validator/format.rb

@@ -0,0 +1,31 @@
+module RailsParam
+  class Validator
+    class Format < Validator
+      def valid_value?
+        matches_time_types? || string_in_format?
+      end
+
+      private
+
+      TIME_TYPES = [Date, DateTime, Time].freeze
+      STRING_OR_TIME_TYPES = ([String] + TIME_TYPES).freeze
+
+      def error_message
+        "Parameter #{name} must be a string if using the format validation" unless matches_string_or_time_types?
+        "Parameter #{name} must match format #{options[:format]}" unless string_in_format?
+      end
+
+      def matches_time_types?
+        TIME_TYPES.any? { |cls| value.is_a? cls }
+      end
+
+      def matches_string_or_time_types?
+        STRING_OR_TIME_TYPES.any? { |cls| value.is_a? cls }
+      end
+
+      def string_in_format?
+        value =~ options[:format] && value.kind_of?(String)
+      end
+    end
+  end
+end

data/lib/rails_param/validator/in.rb

@@ -0,0 +1,20 @@
+module RailsParam
+  class Validator
+    class In < Validator
+      def valid_value?
+        value.nil? || case options[:in]
+                      when Range
+                        options[:in].include?(value)
+                      else
+                        Array(options[:in]).include?(value)
+                      end
+      end
+
+      private
+
+      def error_message
+        "Parameter #{parameter.name} must be within #{parameter.options[:in]}"
+      end
+    end
+  end
+end

data/lib/rails_param/validator/is.rb

@@ -0,0 +1,15 @@
+module RailsParam
+  class Validator
+    class Is < Validator
+      def valid_value?
+        value === options[:is]
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} must be #{options[:is]}"
+      end
+    end
+  end
+end

data/lib/rails_param/validator/max.rb

@@ -0,0 +1,15 @@
+module RailsParam
+  class Validator
+    class Max < Validator
+      def valid_value?
+        value.nil? || options[:max] >= value
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot be greater than #{options[:max]}"
+      end
+    end
+  end
+end

data/lib/rails_param/validator/max_length.rb

@@ -0,0 +1,15 @@
+module RailsParam
+  class Validator
+    class MaxLength < Validator
+      def valid_value?
+        value.nil? || options[:max_length] >= value.length
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot have length greater than #{options[:max_length]}"
+      end
+    end
+  end
+end

data/lib/rails_param/validator/min.rb

@@ -0,0 +1,15 @@
+module RailsParam
+  class Validator
+    class Min < Validator
+      def valid_value?
+        value.nil? || options[:min] <= value
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot be less than #{options[:min]}"
+      end
+    end
+  end
+end

data/lib/rails_param/validator/min_length.rb

@@ -0,0 +1,15 @@
+module RailsParam
+  class Validator
+    class MinLength < Validator
+      def valid_value?
+        value.nil? || options[:min_length] <= value.length
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot have length less than #{options[:min_length]}"
+      end
+    end
+  end
+end

data/lib/rails_param/validator/required.rb

@@ -0,0 +1,15 @@
+module RailsParam
+  class Validator
+    class Required < Validator
+      private
+
+      def valid_value?
+        value.present? && options[:required]
+      end
+
+      def error_message
+        "Parameter #{name} is required"
+      end
+    end
+  end
+end

data/lib/rails_param/validator.rb

@@ -0,0 +1,63 @@
+require 'forwardable'
+
+module RailsParam
+  class Validator
+    extend Forwardable
+
+    attr_reader :parameter
+
+    def_delegators :parameter, :name, :options, :value
+
+    VALIDATABLE_OPTIONS = [
+      :blank,
+      :custom,
+      :format,
+      :in,
+      :is,
+      :max_length,
+      :max,
+      :min_length,
+      :min,
+      :required
+    ].freeze
+
+    def initialize(parameter)
+      @parameter = parameter
+    end
+
+    def validate!
+      options.each_key do |key|
+        next unless VALIDATABLE_OPTIONS.include? key
+
+        class_name = camelize(key)
+        Validator.const_get(class_name).new(parameter).valid!
+      end
+    end
+
+    def valid!
+      return if valid_value?
+
+      raise InvalidParameterError.new(
+        error_message,
+        param: name,
+        options: options
+      )
+    end
+
+    private
+
+    def camelize(term)
+      string = term.to_s
+      string.split('_').collect(&:capitalize).join
+    end
+
+    def error_message
+      nil
+    end
+
+    def valid_value?
+      # Should be overwritten in subclass
+      false
+    end
+  end
+end

data/lib/rails_param/version.rb

@@ -1,3 +1,3 @@
 module RailsParam #:nodoc
-  VERSION = "0.10.2"
+  VERSION = "1.0.0"
 end

data/lib/rails_param.rb

@@ -1,5 +1,8 @@
 require 'rails_param/param'
+Dir[File.join(__dir__, 'rails_param/validator', '*.rb')].sort.each { |file| require file }
+Dir[File.join(__dir__, 'rails_param/coercion', '*.rb')].sort.reverse.each { |file| require file }
+Dir[File.join(__dir__, 'rails_param', '*.rb')].sort.each { |file| require file }
 
 ActiveSupport.on_load(:action_controller) do
-  include RailsParam::Param
+  include RailsParam
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_param
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Nicolas Blanco
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-07 00:00:00.000000000 Z
+date: 2021-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
 description: "\n    Parameter Validation and Type Coercion for Rails\n  "
 email: nicolas@nicolasblanco.fr
 executables: []
@@ -74,7 +88,31 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/rails_param.rb
+- lib/rails_param/coercion.rb
+- lib/rails_param/coercion/array_param.rb
+- lib/rails_param/coercion/big_decimal_param.rb
+- lib/rails_param/coercion/boolean_param.rb
+- lib/rails_param/coercion/float_param.rb
+- lib/rails_param/coercion/hash_param.rb
+- lib/rails_param/coercion/integer_param.rb
+- lib/rails_param/coercion/string_param.rb
+- lib/rails_param/coercion/time_param.rb
+- lib/rails_param/coercion/virtual_param.rb
+- lib/rails_param/invalid_parameter_error.rb
 - lib/rails_param/param.rb
+- lib/rails_param/param_evaluator.rb
+- lib/rails_param/parameter.rb
+- lib/rails_param/validator.rb
+- lib/rails_param/validator/blank.rb
+- lib/rails_param/validator/custom.rb
+- lib/rails_param/validator/format.rb
+- lib/rails_param/validator/in.rb
+- lib/rails_param/validator/is.rb
+- lib/rails_param/validator/max.rb
+- lib/rails_param/validator/max_length.rb
+- lib/rails_param/validator/min.rb
+- lib/rails_param/validator/min_length.rb
+- lib/rails_param/validator/required.rb
 - lib/rails_param/version.rb
 homepage: http://github.com/nicolasblanco/rails_param
 licenses:
@@ -96,8 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Parameter Validation and Type Coercion for Rails