request_params_validation 0.1.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 532c37904a1c0cbab6d818039ebeabe0886eae35f2f8b7f911931ca41b323712
-  data.tar.gz: ea982841155186b8a46de89b449c30031aa1fdb0017f7f748becdd1225235427
+  metadata.gz: 2d0b040bc6ef9353a9c6d8e4f48c195cebb4e2547bd66c6c709e57605cf6c18d
+  data.tar.gz: e226a8483f9655aacb337de251363e23c24ef517d4005f577ca470a5e7bd8fd5
 SHA512:
-  metadata.gz: 6187c851e82740b4e00f47c0b9f40b2930312eb349467b6e6e2197d50134c27e3cd4bdc77a53778881c68b08caafcd897257e4d25412f86213cbaa8d519f687d
-  data.tar.gz: 91bb251b9af8c43b901c1709abb4ff0590dade190ffe2be320db5f86691e648f42c93610b469e948ec17b5defaca078865b93c5c755f880982a62469bee64d86
+  metadata.gz: d9e496129c0335c2ef2bb2ba9ee5c0715f4d49ca3890d428d8200e329d7e5dcbaf8fd45625fa3325132e95967c7e496eaff6f5234f7b5a867f8972f31083e520
+  data.tar.gz: ba5c464e0fe423f287a7c5808b401f884a7288520b328f8bfac2f54cd9b5d835f3f255ab6974252fb8d7136ccf5b267959f8f46d163aa69bc8697b0eae772d1f

data/README.md

@@ -1,7 +1,9 @@
 # RequestParamsValidation
 _Request parameters validations, type coercion and filtering for Rails params_
 
+[![Gem Version](https://badge.fury.io/rb/request_params_validation.svg)](https://badge.fury.io/rb/request_params_validation)
 [![CircleCI](https://circleci.com/gh/felipefava/request_params_validation.svg?style=shield&circle-token=a404cb4fd87e219299caeb36e1685ab75d335b84)](https://circleci.com/gh/felipefava/request_params_validation)
+[![Codacy Quality Badge](https://api.codacy.com/project/badge/Grade/6ed6582228bd429a94dfabaa82071455)](https://www.codacy.com/manual/felipefava/request_params_validation?utm_source=github.com&utm_medium=referral&utm_content=felipefava/request_params_validation&utm_campaign=Badge_Grade)
 
 ## Introduction
 Validates the request params outside your controller logic in order to get a clean nice code, and
@@ -43,7 +45,7 @@ documentation and allows to keep controllers code clean, ensuring that `params`
 always have the parameters you suppose to receive.
 
 The default path for the definitions files is `app/definitions`, and their names should be the same
-as their respective controller's name, but ending with the suffix `_definition`. They also should
+as their respective controller's name, but ending with the suffix `_definition`. They should also
 respect the folder structure of the controllers folder. Please see the following project structure
 to clarify the idea:
 
@@ -93,15 +95,15 @@ and `notify`:
 
 class UsersController < ApplicationController
   def create
-    ...
+    params # will have only the defined parameters
   end
 
   def notify
-    ...
+    params # will have only the defined parameters
   end
 
   def another_action
-    ...
+    params # will have whatever the user sends
   end
 end
 ```
@@ -111,25 +113,25 @@ Then, we will need to create the definition for the `users` resource:
 ```ruby
 # app/definitions/users_definition.rb
 
-RequestParamsValidation.define do |users|
-  users.action :create do |create|
-    users.request do |params|
-      params.required :user, type: :hash do |user|
-        user.required :first_name, type: :string
-        user.required :last_name, type: :string
-        user.required :emails, type: :array, elements: :email
-        user.required :birth_date,
-                      type: :datetime,
-                      validate: lambda { |value| value <= 18.years.ago.to_date }
+RequestParamsValidation.define do
+  action :create do
+    request do
+      required :user, type: :hash do
+        required :first_name, type: :string
+        required :last_name, type: :string
+        required :emails, type: :array, elements: :email
+        required :birth_date,
+                 type: :datetime,
+                 validate: lambda { |value| value <= 18.years.ago.to_date }
       end
     end
   end
 
-  users.action :notify do |notify|
-    notify.request do |params|
-      params.required :user_id, type: :integer
-      params.required :message, type: :string, length: { min: 10, max: 250 }
-      params.optional :by, inclusion: %w(email text_msg push), default: :email
+  action :notify do
+    request do
+      required :user_id, type: :integer
+      required :message, type: :string, length: { min: 10, max: 250 }
+      optional :by, inclusion: %w(email text_msg push), default: :email
     end
   end
 end
@@ -169,25 +171,25 @@ param. Otherwise use the `optional` method. For default, required parameters don
 values, if you would like to allow them for that parameter, you can use the option `allow_blank`
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1
-  params.required :key_2, allow_blank: true
-  params.optional :key_3
+request do
+  required :key_1
+  required :key_2, allow_blank: true
+  optional :key_3
 end
 ```
 
 ### Types
 The `type` option specified the type of the parameter. The supported types are:
 
-1. hash
-2. array
-3. string
-4. integer
-5. decimal
-6. boolean
-7. date
-9. datetime
-9. email
+1.  hash
+2.  array
+3.  string
+4.  integer
+5.  decimal
+6.  boolean
+7.  date
+8.  datetime
+9.  email
 
 So if this option is present, the gem will validate that the value of the parameter matches with
 the specified type. And if it does, it will convert the value to the right type. This means that
@@ -199,9 +201,9 @@ configuration option `extend.types`. See [here](#configuration) all globals
 configuration options.
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1, type: :boolean
-  params.required :key_2, type: :decimal
+request do
+  required :key_1, type: :boolean
+  required :key_2, type: :decimal
   # ...
 end
 ```
@@ -214,14 +216,14 @@ If no block is passed, the gem will only check that the value of the parameter b
 object, without validating the content of it.
 
 ```ruby
-some_action.request do |params|
+request do
   # Allows any keys and values for the hash
-  params.required :key_1, type: :hash
+  required :key_1, type: :hash
 
   # Only allows the keys nested_key_1 and nested_key_2
-  params.required :key_2, type: :hash do |key_name|
-    key_name.required :nested_key_1, type: :string
-    key_name.required :nested_key_2, type: :integer
+  required :key_2, type: :hash do
+    required :nested_key_1, type: :string
+    required :nested_key_2, type: :integer
   end
 end
 ```
@@ -235,20 +237,20 @@ The value for this option can be a type or a hash. `elements: :integer` is equiv
 `elements: { type: :integer }`.
 
 The second way is useful when you  want to validate other things of the elements than just the
-type. The option elements accepts all validations options.
+type. The option `elements` accepts all validations options.
 
 ```ruby
-some_action.request do |params|
+request do
   # Allows any value for the elements of the array
-  params.required :key_1, type: :array
+  required :key_1, type: :array
 
   # Only allows decimals with a value less than 1_000 for the elements of the array
-  params.required :key_2, type: :array, elements: { type: :decimal, value: { max: 1_000 }
+  required :key_2, type: :array, elements: { type: :decimal, value: { max: 1_000 } }
 
   # Only allows objects with a required key 'nested_key' of type 'email' for the
   # elements of the array
-  params.required :key_3, type: :array, elements: :hash do |key_3|
-    key_3.required :nested_key, type: :email
+  required :key_3, type: :array, elements: :hash do
+    required :nested_key, type: :email
   end
 end
 ```
@@ -260,7 +262,7 @@ Any value is a valid string.
 Accepts only valid integers like `5` or `"5"`.
 
 #### Decimal type
-Accepts only valid decimals like `5` or `1.5` or `10.45`. With decimals parameters you can use
+Accepts only valid decimals like `5` or `"1.5"` or `10.45`. With decimals parameters you can use
 the option `precision`. Go [here](#precision) for more details about this option.
 
 #### Boolean type
@@ -282,10 +284,11 @@ will be converter to a Date object like  `Wed, 04 Oct 1995`.
 However, they are cases when you only want to accept a specific format for a date, like
 `"%Y-%m-%e"`. In this cases you have two options.
 
-1. Use the global configuration option `format.date`, so all date types must have the specified
-   format through all the requests. See [here](#configuration) all globals configuration
-   options.
-2. Specify the option `format: "%Y-%m-%e"` locally.
+1.  Use the global configuration option `format.date`, so all date types must have the specified
+    format through all the requests. See [here](#configuration) all globals configuration
+    options.
+
+2.  Specify the option `format: "%Y-%m-%e"` locally.
 
 You can perfectly use both approaches, but the second one will locally override the first one on
 that parameter validation.
@@ -294,9 +297,9 @@ Notice that if no format is specified, the date will be validated using the ruby
 method.
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1, type: :date
-  params.required :key_2, type: :date, format: '%Y-%m-%e'
+request do
+  required :key_1, type: :date
+  required :key_2, type: :date, format: '%Y-%m-%e'
 end
 ```
 
@@ -317,9 +320,9 @@ Besides from the `in` option, you can also use the `message` option for passing
 detail when the parameter is not valid.
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1, type: :string, inclusion: %w(asc desc)
-  params.required :key_2,
+request do
+  required :key_1, type: :string, inclusion: %w(asc desc)
+  required :key_2,
                   type: :string,
                   inclusion: { in: %w(s m l), message: 'Value is not a valid size' }
 end
@@ -335,12 +338,11 @@ Besides from the `min` and `max` options, you can also use the `message` option
 custom error detail when the parameter is not valid.
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1, type: :string, length: 10
-  params.required :key_2, type: :string, length: { min: 5, max: 12 }
-  params.required :key_3, type: :array, elements: :email, length: { max: 3 }
-  params.required :key_4, type: :string, length: { max: 25,
-                                                   message: '25 characters is the maximum allowed' }
+request do
+  required :key_1, type: :string, length: 10
+  required :key_2, type: :string, length: { min: 5, max: 12 }
+  required :key_3, type: :array, elements: :email, length: { max: 3 }
+  required :key_4, type: :string, length: { max: 25, message: '25 characters is the maximum allowed' }
 end
 ```
 
@@ -350,15 +352,15 @@ The `value` option is for validating the value size of numerics parameters.
 The value for this option is a hash with the following options: `min`, `max` and `message`.
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1, type: :integer, value: { min: 0 }
-  params.required :key_2, type: :integer, value: { max: 1_000_000, message: 'Value too big!' }
-  params.required :key_3, type: :decimal, value: { min: 0, max: 1 }
+request do
+  required :key_1, type: :integer, value: { min: 0 }
+  required :key_2, type: :integer, value: { max: 1_000_000, message: 'Value too big!' }
+  required :key_3, type: :decimal, value: { min: 0, max: 1 }
 end
 ```
 
 ### Format
-The `format` option allows to validate de format of the value with a regular expression.
+The `format` option allows to validate the format of the value with a regular expression.
 
 The value for this option is a `regexp`, `string` or a `hash`. The string value is only valid
 when the type is a `date` or a `datetime`. Otherwise, you should use a regexp. The options for
@@ -369,10 +371,10 @@ So, for `date` and `datetime` types, `format: '%u%F'` is equivalent to
 equivalent to `format: { regexp: /^5[1-5]\d{14}$/ }`.
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1, type: :string, format: /^5[1-5]\d{14}$/
-  params.required :key_2, type: :string, format: { regexp: /^1.*/,
-                                                   message: 'Value should start with a 1' }
+request do
+  required :key_1, type: :string, format: /^5[1-5]\d{14}$/
+  required :key_2, type: :string, format: { regexp: /^1.*/,
+                                            message: 'Value should start with a 1' }
 end
 ```
 
@@ -385,9 +387,9 @@ This option accepts a Proc as value or a hash. For example,
 also accepts the `message` option.
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1, type: :date, validate: { function: lambda { |value| value >= Date.today },
-                                                   message: 'The date can not be in the past' }
+request do
+  required :key_1, type: :date, validate: { function: lambda { |value| value >= Date.today },
+                                            message: 'The date can not be in the past' }
 end
 ```
 
@@ -398,14 +400,14 @@ the specified type.
 
 If you want to set a precision value to all `decimal` parameters, you can use the global
 configuration option `format.decimal_precision`. Keep in mind that if you set the `precision`
-option on a parameter, it will locally override the global configuration. See here for all
-globals configuration options.
+option on a parameter, it will locally override the global configuration. See [here](#configuration)
+for all globals configuration options.
 
 This option accepts an integer as value.
 
 ```ruby
-some_action.request do |params|
-  params.required :key_1, type: :decimal, precision: 2
+request do
+  required :key_1, type: :decimal, precision: 2
 end
 ```
 
@@ -416,9 +418,9 @@ present.
 The value for the option `default` could be anything, including a proc.
 
 ```ruby
-some_action.request do |params|
-  params.optional :key_1, type: :string, default: 'Jane'
-  params.optional :key_2, type: :string, default: lambda { Date.today.strftime('%A') }
+request do
+  optional :key_1, type: :string, default: 'Jane'
+  optional :key_2, type: :string, default: lambda { Date.today.strftime('%A') }
 end
 ```
 
@@ -432,17 +434,54 @@ specified in the definition. So, `transform: :strip` is equivalent to
 `transform: lambda { |value| value.strip }`.
 
 ```ruby
-some_action.request do |params|
-  params.optional :key_1, type: :string, transform: :strip
-  params.optional :key_2,
-                  type: :string,
-                  format: /^\d{3}-\d{3}-\d{3}$/,
-                  transform: lambda { |value| value.gsub(/-/, '') }
+request do
+  optional :key_1, type: :string, transform: :strip
+  optional :key_2,
+           type: :string,
+           format: /^\d{3}-\d{3}-\d{3}$/,
+           transform: lambda { |value| value.gsub(/-/, '') }
 end
 ```
 
+### Rename Parameters
+You can rename parameters using the `as` option.
+
+```ruby
+request do
+  required :email_address, type: :email, as: :email
+end
+```
+
+This means that in the request params you expect a valid email value in the key `email_address`,
+but in your controller you will access with the key `email`.
+
+### Dependent Parameters
+If you want to receive and validate a parameter only if another one is given, you can use
+the `is_given` option.
+
+```ruby
+request do
+  optional :label, type: :string
+  required :description, type: :string, if_given: :label
+  #...
+  required :card_type, inclusion: %w(credit_card debit_card)
+  required :ccv, if_given: { card_type: lambda { |value| value == 'credit_card' } }
+end
+```
+
+On the example above, the param `description` will be only validated if the param `label` is present.
+RequestParamsValidation will use the method `blank?` to check that. On the other hand, the param
+`ccv` will only be validated if the param `type_card` is equal to the string `credit_card`.
+
+Notice that if the global option `filter_params` is set to `true` (default behaviour), then the
+dependent parameters will be filtered from the `params object` if they haven't beeen validated.
+This way we make sure to only receive those parameters that have been validated against our request
+definitions.
+
+Be aware that if you rename a param, then you should use the new name in the `if_given` option.
+
 ---
-**NOTE**
+### NOTE
 
 RequestParamsValidation will start validating the presence of the parameters. Then, if the value is
 not present and the parameter has a default value, it will assign that value and not execute any
@@ -450,8 +489,8 @@ further validation. Otherwise, it will validate the type, convert it to the righ
 continue with the others validations. So, all others validations will be executed with the parameter
 value already converter to the specified type, so keep in mind that at defining the validations.
 
-
 ## Errors & Messages
+
 For default, when a required parameter failed the presence validation, the exception
 `RequestParamsValidation::MissingParameterError` will be raised. If it failed for any of the others
 validations, the raised exception will be `RequestParamsValidation::InvalidParameterValueError`
@@ -502,17 +541,15 @@ an element of an array or not. If you **have specified the `message` option in t
 definition**, then the details will be that value, otherwise it will took a default value from
 the table below:
 
-
-| Failure                   | Default Message                                      |
-| ------------------------- | ---------------------------------------------------- |
-| Missing parameter         | N/A                                                  |
-| Invalid type              | - `Value should be a valid %{param_type}` <br> - `All elements of the array should be a valid %{type}` <br> If has `date` or `datetime` type with specified `format`: <br> &nbsp;&nbsp;&nbsp; - ` with the format %{format}` is added to the message |
-| Invalid inclusion         | - `Value should be in %{include_in}` <br> - `All elements values of the array should have be in %{include_in}` |
-| Invalid length            | - `Length should be greater or equal than %{min}` <br> - `Length should be less or equal than %{max}`  <br> - `Length should be equal to %{min/max}` </br> - `Length should be between %{min} and %{max}` <br> - `All elements of the array should have a length ...` |
-| Invalid value size        | - `Value should be greater or equal than %{min}` <br> - `Value should be less or equal than %{max}` <br> - `Value should be between %{min} and %{max}` <br> - `All elements of the array should have a value ...` |
-| Invalid format            | - `Value format is invalid` <br> - `An element of the array has an invalid format` |
-| Invalid custom validation | N/A                                                  |
-
+| Failure                   | Default Message                                                                                                                                                                                                                                                      |
+| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Missing parameter         | N/A                                                                                                                                                                                                                                                                  |
+| Invalid type              | - `Value should be a valid %{param_type}` <br> - `All elements of the array should be a valid %{type}` <br> If has `date` or `datetime` type with specified `format`: <br> &nbsp;&nbsp;&nbsp; - ` with the format %{format}` is added to the message                 |
+| Invalid inclusion         | - `Value should be in %{include_in}` <br> - `All elements values of the array should be in %{include_in}`                                                                                                                                                            |
+| Invalid length            | - `Length should be greater or equal than %{min}` <br> - `Length should be less or equal than %{max}` <br> - `Length should be equal to %{min/max}` </br> - `Length should be between %{min} and %{max}` <br> - `All elements of the array should have a length ...` |
+| Invalid value size        | - `Value should be greater or equal than %{min}` <br> - `Value should be less or equal than %{max}` <br> - `Value should be between %{min} and %{max}` <br> - `All elements of the array should have a value ...`                                                    |
+| Invalid format            | - `Value format is invalid` <br> - `An element of the array has an invalid format`                                                                                                                                                                                   |
+| Invalid custom validation | N/A                                                                                                                                                                                                                                                                  |                                               |
 
 ### Custom Exceptions
 However, if the above is not enough for your app, and you need to fully customize the exceptions
@@ -534,24 +571,16 @@ end
 To see a complete initializer file of the configuration with all the options and their description,
 please see [here](./examples/initializer.rb).
 
-## Future Work
-In the near future the plan is to continue adding features to the gem. Next incoming changes
-could be:
-- Add doc generation from the definitions
-- Add representations for DRY definitions
-- Add more options to the actions definitions
-- Add handler for responses
-
 ## Acknowledgments
 This gem is strongly inspired in a Ruby framework named [Angus](https://github.com/moove-it/angus)
 developed by [Moove It](https://moove-it.com/)
 
 ## Contributing
-1. Fork it
-2. Create your feature branch (git checkout -b my-new-feature)
-3. Commit your changes (git commit -am 'Add some feature')
-4. Push to the branch (git push origin my-new-feature)
-5. Create a Pull Request
+1.  Fork it
+2.  Create your feature branch (git checkout -b my-new-feature)
+3.  Commit your changes (git commit -am 'Add some feature')
+4.  Push to the branch (git push origin my-new-feature)
+5.  Create a Pull Request
 
 ## License
 This software is released under the MIT license. See the MIT-LICENSE file for more info.

data/lib/request_params_validation/definitions.rb

@@ -5,9 +5,9 @@ module RequestParamsValidation
   module Definitions
     @@definitions = {}
 
-    def self.load_all
+    def self.load_all(use_load = false)
       definitions_suffix = RequestParamsValidation.definitions_suffix
-      Dir["#{definitions_path}/**/*#{definitions_suffix}.rb"].each { |file| load file }
+      Dir["#{definitions_path}/**/*#{definitions_suffix}.rb"].each { |f| use_load ? load(f) : require(f) }
     end
 
     def self.register_resource(&block)
@@ -16,7 +16,7 @@ module RequestParamsValidation
       resource_name = resource_name_from_block(&block)
       resource = Resource.new(resource_name)
 
-      block.call(resource)
+      resource.instance_eval(&block)
 
       @@definitions[resource_name] = resource
     end

data/lib/request_params_validation/definitions/action.rb

@@ -9,11 +9,11 @@ module RequestParamsValidation
         @name = name
       end
 
-      def request
+      def request(&block)
         if block_given?
           @request = Request.new
 
-          yield @request
+          @request.instance_eval(&block)
         else
           @request
         end

data/lib/request_params_validation/definitions/param.rb

@@ -1,17 +1,17 @@
 require 'request_params_validation/params'
-require 'request_params_validation/exceptions/definitions_errors'
 
 module RequestParamsValidation
   module Definitions
     class Param
-      attr_reader :key, :required, :allow_blank, :type, :transform, :decimal_precision,
-                  :inclusion, :length, :value, :format, :custom_validation, :elements
+      attr_reader :key, :required, :allow_blank, :type, :rename_as, :transform, :decimal_precision,
+                  :inclusion, :length, :value, :format, :custom_validation, :if_given, :elements
 
       def initialize(options, &block)
         @key         = options[:key]
         @required    = options[:required]
         @allow_blank = options[:allow_blank]
         @type        = options[:type].try(:to_sym)
+        @rename_as   = options[:as].try(:to_sym)
         @default     = options[:default]
 
         @transform          = options[:transform]
@@ -23,6 +23,7 @@ module RequestParamsValidation
         @value              = build_value_option(options[:value])
         @format             = build_format_option(options[:format])
         @custom_validation  = build_custom_validation_option(options[:validate])
+        @if_given           = build_if_given_option(options[:if_given])
 
         @elements           = build_elements_option(options[:elements], &block)
         @sub_definition     = build_sub_definition(&block)
@@ -74,6 +75,26 @@ module RequestParamsValidation
         !!@custom_validation
       end
 
+      def rename?
+        !!@rename_as
+      end
+
+      def transform?
+        !!@transform
+      end
+
+      def skip?(request_params)
+        return false unless @if_given
+
+        if_given_param_value = request_params[@if_given.param]
+
+        if @if_given.function
+          !@if_given.function.call(if_given_param_value)
+        else
+          if_given_param_value.blank?
+        end
+      end
+
       private
 
       def build_inclusion_option(inclusion)
@@ -150,6 +171,20 @@ module RequestParamsValidation
         Struct.new(:function, :message).new(function, message)
       end
 
+      def build_if_given_option(if_given)
+        case if_given
+        when String, Symbol
+          param = if_given.to_sym
+        when Hash
+          param = if_given.first.try(:first)
+          function = if_given.first.try(:last)
+        end
+
+        return unless param
+
+        Struct.new(:param, :function).new(param, function)
+      end
+
       def build_elements_option(elements, &block)
         return unless @type == Params::ARRAY_TYPE
 
@@ -173,7 +208,7 @@ module RequestParamsValidation
 
         request = Request.new
 
-        block.call(request) if block_given?
+        request.instance_eval(&block) if block_given?
 
         request.params
       end

data/lib/request_params_validation/definitions/resource.rb

@@ -11,16 +11,16 @@ module RequestParamsValidation
         @actions = {}
       end
 
-      def action(action_name)
+      def action(action_name, &block)
         unless block_given?
           raise DefinitionArgumentError.new("Expecting block for action '#{action_name}'")
         end
 
-        action_definition = Action.new(action_name.to_s)
+        action = Action.new(action_name.to_s)
 
-        yield action_definition
+        action.instance_eval(&block)
 
-        @actions[action_name.to_s] = action_definition
+        @actions[action_name.to_s] = action
       rescue DefinitionArgumentError => e
         e.resource = name
         raise

data/lib/request_params_validation/engine.rb

@@ -6,12 +6,12 @@ module RequestParamsValidation
     isolate_namespace RequestParamsValidation
 
     initializer 'request_params_validation.load_definitions' do
-      RequestParamsValidation::Definitions.load_all
+      Definitions.load_all
     end
 
     initializer 'request_params_validation.add_helpers' do
       ActiveSupport.on_load :action_controller do
-        include RequestParamsValidation::Helpers
+        include Helpers
       end
     end
   end

data/lib/request_params_validation/params.rb

@@ -7,6 +7,8 @@ module RequestParamsValidation
 
     def self.validate!(definition, params)
       definition.each do |param_definition|
+        next if param_definition.skip?(params)
+
         validate_and_coerce_param(param_definition, params)
       end
 
@@ -16,8 +18,8 @@ module RequestParamsValidation
     def self.filter!(definition, params)
       extra_keys = [:controller, :action] # Keys added by Rails
 
-      filter_params(definition, params, extra_keys).tap do |params|
-        params.permit! if params.respond_to?(:permit!)
+      filter_params(definition, params, extra_keys).tap do |filtered_params|
+        filtered_params.permit! if filtered_params.respond_to?(:permit!)
       end
     end
 
@@ -26,8 +28,14 @@ module RequestParamsValidation
       value = params[key]
 
       value = Validator.new(param_definition, value).validate_and_coerce
+      value = Converter.apply_transformation(param_definition, value) if param_definition.transform?
 
-      params[key] = value
+      if param_definition.rename?
+        params.delete(key)
+        params[param_definition.rename_as] = value
+      else
+        params[key] = value
+      end
     end
     private_class_method :validate_and_coerce_param
 
@@ -36,7 +44,9 @@ module RequestParamsValidation
       return params if definition.empty?
 
       params_keys = definition.map do |param_definition|
-        key = param_definition.key
+        next if param_definition.skip?(params)
+
+        key = param_definition.rename? ? param_definition.rename_as : param_definition.key
 
         if param_definition.sub_definition
           filter_params(param_definition.sub_definition, params[key])

data/lib/request_params_validation/params/converter.rb

@@ -24,8 +24,6 @@ module RequestParamsValidation
       def self.apply_transformation(param, value)
         transform = param.transform
 
-        return value unless transform
-
         transform.respond_to?(:call) ? transform.call(value) : value.send(transform)
       end
     end

data/lib/request_params_validation/params/types/validations.rb

@@ -12,7 +12,7 @@ module RequestParamsValidation
           false
         end
 
-        def valid_string?(value)
+        def valid_string?(_value)
           true
         end
 

data/lib/request_params_validation/params/validator.rb

@@ -45,7 +45,7 @@ module RequestParamsValidation
         validate_format!            if param.validate_format?
         validate_custom_validation! if param.validate_custom_validation?
 
-        @value = Params::Converter.apply_transformation(param, value)
+        @value
       end
 
       private
@@ -57,7 +57,7 @@ module RequestParamsValidation
       end
 
       def iterate_hash
-        Params::validate!(param.sub_definition, value) # recursion for the sub_definition
+        Params.validate!(param.sub_definition, value) # recursion for the sub_definition
       end
 
       def raise_error(exception_type, options = {})

data/lib/request_params_validation/params/validators/presence.rb

@@ -5,7 +5,7 @@ module RequestParamsValidation
         def validate_presence!
           not_present = param.allow_blank ? value.nil? : value.blank?
 
-          raise_error(:on_missing_parameter) if not_present
+          raise_error(:on_missing_parameter) if not_present && value != false
         end
       end
     end

data/lib/request_params_validation/version.rb

@@ -1,3 +1,3 @@
 module RequestParamsValidation
-  VERSION = '0.1.1'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: request_params_validation
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Felipe Fava
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-30 00:00:00.000000000 Z
+date: 2020-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -64,7 +64,7 @@ homepage: https://github.com/felipefava/request_params_validation
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -72,16 +72,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
-signing_key: 
+rubygems_version: 3.0.4
+signing_key:
 specification_version: 4
 summary: Validates rails request params
 test_files: []