rails_param 0.10.0 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8cbf1f2bda303ead2066ddf49597a4af8b276ced
-  data.tar.gz: c403d8ad4dafd5a1e014e8e8a0b10417e69badcc
+SHA256:
+  metadata.gz: '08178a96aa23b8bdd933adeed68df920615f3dfd23c3419be3e5a3862daf9110'
+  data.tar.gz: 8440cb471e4bde464eb3587031c785fff70a1c0072a219d284bb9a35d75359f1
 SHA512:
-  metadata.gz: 9c509598a1dda1c1fe0a1276fe957c3259862ac9430b3b6302926ab4aecf26636eb6de0d07f3901e8f7ca6aa8ab1c3b1ea61c75af341a4a495bf6c6554b63505
-  data.tar.gz: 7b2c56eff184db82d4497a46b203155c077bfb625178de27b6b38a5a8bc9947a088d29468d889d0ec0fccbeda28ebdfc853f73b4f4023d7170a0eb34dba68e86
+  metadata.gz: eac1db59508ef0c4bf89a59b95ba8685f47c2d55529ce4253581540f7ac0398921651187a203e0c44f9b5416eebf07914a9756918737e344ff499cf728287707
+  data.tar.gz: b91642011d2d51e82c997cecd2cf8e4d9d72ca01cd1ed0b13d6cfa1e3df5f3acd611325984d516389df85169a2f9bea4ffe9c897b3b106d472c3fe027af25514

data/README.md

@@ -1,6 +1,7 @@
-# rails-param
+# rails_param
 _Parameter Validation & Type Coercion for Rails_
 
+[![Gem Version](https://badge.fury.io/rb/rails_param.svg)](https://rubygems.org/gems/rails_param)
 [![Build Status](https://travis-ci.org/nicolasblanco/rails_param.svg?branch=master)](https://travis-ci.org/nicolasblanco/rails_param)
 
 ## Introduction
@@ -74,8 +75,15 @@ 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`
+
+```ruby
+param! :q, String, required: true, message: "Query not specified"
+```
+
 ### Defaults and Transformations
 
 Passing a `default` option will provide a default value for a parameter if none is passed.  A `default` can defined as either a default or as a `Proc`:
@@ -147,4 +155,4 @@ Nicolas Blanco
 
 ## License
 
-rails-param is available under the MIT license. See the LICENSE file for more info.
+rails_param is available under the MIT license. See the LICENSE file for more info.

data/lib/rails_param/param.rb

@@ -2,9 +2,16 @@ 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
@@ -21,14 +28,17 @@ module RailsParam
         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]
+        if params[name].nil? && check_param_presence?(options[:default])
+          params[name] = options[:default].respond_to?(:call) ? options[:default].call : options[:default]
         end
 
-        # apply tranformation
-        if params[name] && options[:transform]
+        # validate presence
+        if params[name].nil? && options[:required]
+          raise InvalidParameterError, "Parameter #{name} is required"
+        end
+
+        # apply transformation
+        if params.include?(name) && options[:transform]
           params[name] = options[:transform].to_proc.call(params[name])
         end
 
@@ -92,22 +102,35 @@ module RailsParam
       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 ArgumentError
+        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
-        return Date.parse(param) if type == Date
-        return Time.parse(param) if type == Time
-        return DateTime.parse(param) if type == DateTime
+        if TIME_TYPES.include? type
+          if options[:format].present?
+            return type.strptime(param, options[:format])
+          else
+            return type.parse(param)
+          end
+        end
+        raise ArgumentError if (type == Array || type == Hash) && !param.respond_to?(:split)
         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 (/^(false|f|no|n|0)$/i === param.to_s ? false : (/^(true|t|yes|y|1)$/i === param.to_s ? true : (raise ArgumentError))) if type == TrueClass || type == FalseClass || type == :boolean
+        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))
+          return BigDecimal(param, (options[:precision] || DEFAULT_PRECISION))
         end
         return nil
-      rescue ArgumentError
+      rescue ArgumentError, TypeError
         raise InvalidParameterError, "'#{param}' is not a valid #{type}"
       end
     end
@@ -115,20 +138,18 @@ module RailsParam
     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
+                                                                                    when Array, Hash, ActionController::Parameters
                                                                                       param.empty?
                                                                                     else
                                                                                       param.nil?
                                                                                   end
           when :format
-            raise InvalidParameterError, "Parameter #{param_name} must be a string if using the format validation" unless param.kind_of?(String)
-            raise InvalidParameterError, "Parameter #{param_name} must match format #{value}" unless param =~ value
+            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
@@ -146,6 +167,8 @@ module RailsParam
             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
+          when :custom
+            value.call(param)
         end
       end
     end

data/lib/rails_param/version.rb

@@ -1,3 +1,3 @@
 module RailsParam #:nodoc
-  VERSION = "0.10.0"
+  VERSION = "0.11.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_param
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.2
 platform: ruby
 authors:
 - Nicolas Blanco
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-12 00:00:00.000000000 Z
+date: 2021-05-15 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: []
@@ -96,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Parameter Validation and Type Coercion for Rails