rails_param 0.9.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 372c36387af839acafd00fac76073bcdd666b19e
-  data.tar.gz: 2d9d467a8352bf7f0e671ab8324af3993fcc64f1
+SHA256:
+  metadata.gz: 9a684ef9319b35a00602467f103f2377fdef1b9a2dd3b711ee1d8ca38d01ed8a
+  data.tar.gz: e2682cd56dc1b84939284de6f796cad46f8f015b7de9db72e986a554460dfb48
 SHA512:
-  metadata.gz: c616739e789c723637b6f1b545ecf261a957645f8d92c7bafe456850e49d99420be36d775c3b1af7727ed4d1eac307658390215d94e6e49cfdfec01ee0c66849
-  data.tar.gz: 5079e1ba2ff3c5f1b634ad8cc0e9760633a07fa449d601030e079eeb7505512293de6a45559303885e8ae2e9708bb105e609b89fe132916ef1b2e07ecbfc9cf2
+  metadata.gz: e02a281c85694dc3db8f0862b169800d01d5d4a206341cf49b62536b524cb5b3ce6b992f71b7f8310cf74795e403923ec1bc72b45ded00b7b259540d2666ccc1
+  data.tar.gz: c312758e48df2d5f96f9eea11640e00c991e67faa7aae7a70d7ce705e9132ba2c6947eb40309f0eb3bddd435031ececad9dcd12aa6b46dd9f137d9c9f7373886

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
@@ -14,19 +21,34 @@ module RailsParam
 
     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) || check_param_presence?(options[:default]) || options[:required]
+
+      return unless params.include?(name) || check_param_presence?(options[:default]) || options[:required]
 
       begin
         params[name] = coerce(params[name], type, options)
-        params[name] = (options[:default].call if options[:default].respond_to?(:call)) || options[:default] if params[name].nil? and check_param_presence?(options[:default])
-        params[name] = options[:transform].to_proc.call(params[name]) if params[name] and options[:transform]
-        validate!(params[name], options)
+
+        # set default
+        if params[name].nil? && check_param_presence?(options[:default])
+          params[name] = options[:default].respond_to?(:call) ? options[:default].call : options[:default]
+        end
+
+        # 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
+
+        # 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)
+              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
@@ -80,59 +102,73 @@ 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
 
-    def validate!(param, options)
+    def validate!(param, param_name, options)
       options.each do |key, value|
         case key
-          when :required
-            raise InvalidParameterError, "Parameter is required" if value && param.nil?
           when :blank
-            raise InvalidParameterError, "Parameter cannot be blank" if !value && case param
+            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 must be a string if using the format validation" unless param.kind_of?(String)
-            raise InvalidParameterError, "Parameter 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 must be #{value}" unless param === value
+            raise InvalidParameterError, "Parameter #{param_name} must be #{value}" unless param === value
           when :in, :within, :range
-            raise InvalidParameterError, "Parameter must be within #{value}" unless param.nil? || case value
+            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 cannot be less than #{value}" unless param.nil? || value <= param
+            raise InvalidParameterError, "Parameter #{param_name} cannot be less than #{value}" unless param.nil? || value <= param
           when :max
-            raise InvalidParameterError, "Parameter cannot be greater than #{value}" unless param.nil? || value >= param
+            raise InvalidParameterError, "Parameter #{param_name} cannot be greater than #{value}" unless param.nil? || value >= param
           when :min_length
-            raise InvalidParameterError, "Parameter cannot have length less than #{value}" unless param.nil? || value <= param.length
+            raise InvalidParameterError, "Parameter #{param_name} cannot have length less than #{value}" unless param.nil? || value <= param.length
           when :max_length
-            raise InvalidParameterError, "Parameter cannot have length greater than #{value}" unless param.nil? || value >= param.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.9.0"
+  VERSION = "0.11.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_param
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Nicolas Blanco
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-09-02 00:00:00.000000000 Z
+date: 2020-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -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: []
@@ -80,7 +94,7 @@ homepage: http://github.com/nicolasblanco/rails_param
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -96,9 +110,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.8
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Parameter Validation and Type Coercion for Rails
 test_files: []