validate-params 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7626ebe2f24591c008739bce05f28938e39094dc057ce65b227e7f99130c21cc
-  data.tar.gz: 10f86e031e06e0c8723792d399881d4cc9baa64d9841eca1a1123c13606519ea
+  metadata.gz: 5c5bfbff5338d3dc78e35032adb08de2f63d43e3205cc636e8657c9385ecdc11
+  data.tar.gz: 43d7c4db9adc552528f72de7a7d09ace99a12120860f9fc721ee8476bc201e7f
 SHA512:
-  metadata.gz: b90773a69bdb7d7a8f65df932f78c3c0da3b4937540d4da8ca89695a0113548dffbe45760ff49ee0d6e89b718fb1d689c3f778a0887562290d2e5092956e13a7
-  data.tar.gz: 18a1f5f2d8b0aec4210e8ad50f9d1a715e6f1aa01ab7cf74af77c4fffdbbe4b1f0c16a38b9b57a1df2a83cb3834bb7a9d908ff1b981a71206131e2c4ffaa7726
+  metadata.gz: 508ac950bf308b164b8724bf07687a3473a32b25d4eec3d2cec109bafe5b59eb23454838aa35e1e2a48da3cce011cd0def8168221316e51ec67b1aa595f2ad02
+  data.tar.gz: 36797b8c27c56aea0786cbc4fd9fee79933ff3b5762adc2de6c3a052ed48a380e20f6aa52e1afd9d7bb48988d151aee0af36c2a1ba00f5f04e5cec5121cdfe0f

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.8.0] - 2023-05-30
+
+- Added support for passing array of actions into validate_params_for to run on multiple actions
+- Added support for Array type to use option reject_blank: true to remove blank values from array
+
 ## [0.7.0] - 2023-05-30
 
 - Added type support for casting params into types

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    validate-params (0.7.0)
+    validate-params (0.8.0)
       activesupport (>= 6.1.0)
       i18n (>= 1.6)
 

data/README.md

@@ -27,7 +27,7 @@ class TestController < ActionController::Base
     p.param :occurred_on, Date, required: true, default: proc { Date.today }
     p.param :quantity, Integer, required: true, in: [1, 2, 3]
     p.param :user_ids, Array, of: Integer, default: [1, 2, 3]
-    p.param :states, Array, of: String, default: ["active", "inactive"]
+    p.param :states, Array, of: String, default: ["active", "inactive"], reject_blank: true
     p.param :date_of_birth, Hash do |pp|
       pp.param :gt, Date
       pp.param :lt, Date
@@ -48,6 +48,18 @@ end
 
 If the parameters are valid, the controller action will be executed as normal. If the parameters are invalid, a **400 Bad Request** response will be returned with a JSON body containing the errors, or an empty HTML response.
 
+```json
+{
+    "success": false,
+    "errors": [
+        {
+            "message": "hired_on must be a valid Date"
+        },
+      
+    ]
+}
+```
+
 ## Format
 
 By default responses are returned in JSON format. To return responses as an empty HTML response, change the :format options in the validate_params methods to :html.

data/lib/validate_params/param_builder.rb

@@ -3,17 +3,27 @@
 module ValidateParams
   module Validatable
     class ParamBuilder
-      def initialize(parent_field = nil)
+      def initialize(parent_field: nil, validations:)
         @parent_field = parent_field
-        @params_validations = []
+        @validations = validations
       end
 
-      def param(field, type, options = {})
-        return { field: field, type: type, options: options } if @parent_field.nil?
-
-        @params_validations << { field: { @parent_field => field }, type: type, options: options }
-        @params_validations
+      def param(field, type, options = {}, &block)
+        if block
+          yield(ParamBuilder.new(parent_field: field, validations: @validations))
+        else
+          @validations << build_config(field, type, options)
+        end
       end
+
+      private
+        def build_config(field, type, options)
+          if @parent_field.nil?
+            { field: field, type: type, options: options }
+          else
+            { field: { @parent_field => field }, type: type, options: options }
+          end
+        end
     end
   end
 end

data/lib/validate_params/param_validator.rb

@@ -61,7 +61,7 @@ module ValidateParams
         end
 
         def validate_inclusion
-          return if @options[:in].include?(value)
+          return if @options[:in].include?(@value)
 
           @errors << {
             message: I18n.t("validate_params.invalid_in", param: error_param_name),

data/lib/validate_params/types/array.rb

@@ -12,13 +12,17 @@ module ValidateParams
         end
       end
 
-      def self.cast(raw_value, of: String)
-        case of.to_s
-        when "Integer"
-          raw_value.map { |item| Types::Integer.cast(item) }
-        else
-          raw_value
-        end
+      def self.cast(raw_value, of: String, reject_blank: false, **)
+        value =
+          case of.to_s
+          when "Integer"
+            raw_value.map { |item| Types::Integer.cast(item) }
+          else
+            raw_value
+          end
+
+        value.reject!(&:blank?) if reject_blank
+        value
       end
     end
   end

data/lib/validate_params/types/date.rb

@@ -20,7 +20,7 @@ module ValidateParams
         true
       end
 
-      def self.cast(raw_value)
+      def self.cast(raw_value, **)
         return raw_value if raw_value.is_a?(::Date)
 
         ::Date.strptime(raw_value.to_s, FORMAT)

data/lib/validate_params/types/date_time.rb

@@ -10,7 +10,7 @@ module ValidateParams
         false
       end
 
-      def self.cast(raw_value)
+      def self.cast(raw_value, **)
         return raw_value if raw_value.is_a?(::Time)
 
         Time.at(Integer(raw_value))

data/lib/validate_params/types/integer.rb

@@ -7,7 +7,7 @@ module ValidateParams
         /\A[-+]?\d+\z/ === value.to_s
       end
 
-      def self.cast(raw_value)
+      def self.cast(raw_value, **)
         raw_value.to_i
       end
     end

data/lib/validate_params/types/string.rb

@@ -3,7 +3,7 @@
 module ValidateParams
   class Types
     class String
-      def self.cast(raw_value)
+      def self.cast(raw_value, **)
         raw_value.to_s
       end
     end

data/lib/validate_params/validatable.rb

@@ -14,145 +14,121 @@ module ValidateParams
     extend ::ActiveSupport::Concern
 
     included do
-      before_action :set_params_defaults
       before_action :perform_validate_params
     end
 
     class_methods do
-      attr_accessor :params_validations, :method
+      attr_reader :params_validations
 
-      def param(field, type, options = {}, &block)
-        @params_validations ||= []
+      def validate_params_for(action, options = {}, &block)
+        options[:format] ||= :json
+        @params_validations ||= {}
 
-        if block
-          param_builder = ParamBuilder.new(field)
-          @params_validations += yield(param_builder)
-        else
-          @params_validations << ParamBuilder.new.param(field, type, options)
-        end
-      end
-
-      def validate_params_for(controller_action, options = {}, &block)
-        @controller_action = controller_action
-        @response_format = options[:format] || :json
+        Array(action).each do |act|
+          @params_validations[act] ||= {options: options, validations: []}
 
-        yield(self) if block
+          yield(ParamBuilder.new(validations: @params_validations[act][:validations])) if block
+        end
       end
     end
 
     def params_validations
-      self.class.instance_variable_get(:@params_validations) || []
-    end
-
-    def controller_action
-      self.class.instance_variable_get(:@controller_action) || nil
-    end
-
-    def response_format
-      self.class.instance_variable_get(:@response_format) || nil
+      self.class.params_validations || {}
     end
 
     private
-      def set_params_defaults
-        params_validations.each do |params_validation|
-          next unless params_validation[:options].key?(:default)
-
-          if params_validation[:field].is_a?(Hash)
-            params_validation[:field].each_key do |key|
-              # Skip in case hash is configured and string is passed
-              next if params[key].is_a? Hash
-              next if params.dig(key, params_validation[:field][key])
-
-              value = if params_validation[:options][:default].is_a?(Proc)
-                        params_validation[:options][:default].call
-                      else
-                        params_validation[:options][:default]
-                      end
-              params.deep_merge!(key => { params_validation[:field][key] => value })
-            end
-          else
-            value = if params_validation[:options][:default].is_a?(Proc)
-                      params_validation[:options][:default].call
-                    else
-                      params_validation[:options][:default]
-                    end
-
-            params[params_validation[:field]] ||= value
-
-          end
-        end
-      end
-
-      def cast_param_values
-        params_validations.each do |params_validation|
-          if params_validation[:field].is_a?(Hash)
-            params_validation[:field].each_key do |key|
-              next unless params[key].is_a?(Hash)
-
-              value = params.dig(key, params_validation[:field][key])
-              next if value.blank?
-
-              params.deep_merge!(
-                key => {
-                  params_validation[:field][key] => if params_validation[:type].name == "Array"
-                                                      Types.const_get(params_validation[:type].name).cast(value,
-                                                                                                          of: params_validation[:options][:of])
-                                                    else
-                                                      Types.const_get(params_validation[:type].name).cast(value)
-                                                    end
-                }
-              )
-            end
-          else
-            value = params[params_validation[:field]]
-            next if value.blank?
-
-            params[params_validation[:field]] = if params_validation[:type].name == "Array"
-                                                  Types.const_get(params_validation[:type].name).cast(value, of: params_validation[:options][:of])
-                                                else
-                                                  Types.const_get(params_validation[:type].name).cast(value)
-                                                end
-          end
-        end
-      end
-
       def perform_validate_params
-        return unless controller_action.present? && controller_action == action_name.to_sym
+        return unless params_validations.key?(action_name.to_sym)
 
         errors = []
+        config = params_validations[action_name.to_sym]
 
-        params_validations.each do |params_validation|
-          # Skip in case hash is configured and string is passed
-          next if params_validation[:field].is_a?(Hash) &&
-            params[params_validation[:field].keys.first].is_a?(String)
+        config[:validations].each do |validation|
+          apply_default_values(validation)
 
-          parameter_value = if params_validation[:field].is_a? Hash
-                              params.dig(params_validation[:field].keys.first,
-                                         params_validation[:field][params_validation[:field].keys.first])
+          next if validation[:field].is_a?(Hash) &&
+            params[validation[:field].keys.first].is_a?(String)
+
+          parameter_value = if validation[:field].is_a? Hash
+                              params.dig(validation[:field].keys.first,
+                                         validation[:field][validation[:field].keys.first])
                             else
-                              params[params_validation[:field]]
+                              params[validation[:field]]
                             end
 
           ParamValidator.call(
-            type: params_validation[:type],
-            field: params_validation[:field],
+            type: validation[:type],
+            field: validation[:field],
             value: parameter_value,
             errors: errors,
-            options: params_validation[:options]
+            options: validation[:options]
           )
         end
 
         if errors.empty?
-          cast_param_values
+          cast_param_values(config[:validations])
           return
         end
 
-        case response_format
+        case config.dig(:options, :format)
         when :html
           head :bad_request
         else
           render json: { success: false, errors: errors }, status: :bad_request
         end
       end
+
+      def apply_default_values(validation)
+        return unless validation[:options].key?(:default)
+
+        if validation[:field].is_a?(Hash)
+          validation[:field].each_key do |key|
+            # Skip in case hash is configured and string is passed
+            next if hashlike?(params[key])
+            next if params.dig(key, validation[:field][key])
+
+            value = if validation[:options][:default].is_a?(Proc)
+                      validation[:options][:default].call
+                    else
+                      validation[:options][:default]
+                    end
+
+            params[key] ||= {}
+            params[key][validation[:field][key]] = value
+          end
+        else
+          value = if validation[:options][:default].is_a?(Proc)
+                    validation[:options][:default].call
+                  else
+                    validation[:options][:default]
+                  end
+
+          params[validation[:field]] ||= value
+        end
+      end
+
+      def cast_param_values(validations)
+        validations.each do |validation|
+          if validation[:field].is_a?(Hash)
+            validation[:field].each_key do |key|
+              next unless hashlike?(params[key])
+
+              value = params.dig(key, validation[:field][key])
+              next if value.blank?
+
+              params[key][validation[:field][key]] = Types.const_get(validation[:type].name).cast(value, **validation.fetch(:options, {}))
+            end
+          else
+            value = params[validation[:field]]
+            next if value.blank?
+
+            params[validation[:field]] = Types.const_get(validation[:type].name).cast(value, **validation.fetch(:options, {}))
+          end
+        end
+      end
+
+      def hashlike?(obj)
+        obj.is_a?(Hash) || obj.is_a?(ActionController::Parameters)
+      end
   end
 end

data/lib/validate_params/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ValidateParams
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: validate-params
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - dcherevatenko