validate-params 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40dd463b2500f9e2ab704d35c033763aaf80299e71796104889cc5850aaa1c50
-  data.tar.gz: f0ba27d4568a6dab4e3770cd967085654701fcdd24d74e15519e2d5302c5dce0
+  metadata.gz: 29df4493a4e78d2a93b953b423b01a87870e49e9178720971eba9174aa0a5e1e
+  data.tar.gz: 6368b7cbf5240ff8d05ef54a402fc52ec800e181a6104f4219bae02270745b62
 SHA512:
-  metadata.gz: 9c9b40b0a3f57659b9b5c86713888d0ef8d294bbe21505cc065a406548e032626d1a625a72e72236a895dddc9ea03288c62668de03b437d06d0f1c67f76fc467
-  data.tar.gz: 728615aee1a6082e3816bde334fa064ef7462a9bef9833f029d330ebd98409807a367988def4f4c5c984a2afecdd80e2839296ecf12f351c7647d1a0a54f8434
+  metadata.gz: 63379593455a6bf06bb6d8633b8387d170bc602114e53cd5107cbc7e9e5fee524cb66c86d5e7675a9d4e300cc380d982be8cf8739cf34e59e3d4bc76b1c26d0e
+  data.tar.gz: 371f096da45f2eeed375607d1181e227b843b18241c43a9601db90bf8d0357939f65c1413814a7ee031472b504acd776ca72c3d8f1b184a1a05254d938d7de9c

data/Gemfile.lock

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

data/lib/validate_params/param_builder.rb

@@ -3,27 +3,60 @@
 module ValidateParams
   module Validatable
     class ParamBuilder
-      def initialize(parent_field: nil, validations:)
-        @parent_field = parent_field
-        @validations = validations
-      end
+      Validation = Struct.new(:field, :type, :options, :children, :parent) do
+        def valid?(value, errors)
+          ParamValidator.call(
+            validation: self,
+            value: value,
+            errors: errors
+          )
 
-      def param(field, type, options = {}, &block)
-        if block
-          yield(ParamBuilder.new(parent_field: field, validations: @validations))
-        else
-          @validations << build_config(field, type, options)
+          if children.any?
+            case type.to_s
+            when "Hash"
+              # Skip in case hash is configured and string is passed
+              if !value.is_a?(String)
+                children.each { |c| c.valid?(value&.[](c.field), errors) }
+              end
+            when "Array"
+              values = value ? Array.wrap(value) : [nil]
+              values.each do |item|
+                children.each do |child|
+                  child_value = item[child.field] if item.is_a?(Hash) || item.is_a?(Array)
+                  child.valid?(child_value, errors)
+                end
+              end
+            else
+              raise "Unexpected type: #{type}"
+            end
+          end
+
+          errors.empty?
         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 }
+      def initialize(parent: nil, validations: [])
+        @parent = parent
+        @validations = validations
+      end
+
+      def param(field, type, options = {})
+        validation = Validation.new(field, type, options, [], @parent)
+
+        if block_given?
+          if ![Array, Hash].include?(type)
+            raise "#{type} type cannot have nested definitions, only Array or Hash are supported"
           end
+
+          yield ParamBuilder.new(parent: validation)
         end
+
+        if @parent
+          @parent.children << validation
+        else
+          @validations << validation
+        end
+      end
     end
   end
 end

data/lib/validate_params/param_validator.rb

@@ -9,12 +9,13 @@ module ValidateParams
         new(**args).call
       end
 
-      def initialize(type:, field:, value:, errors:, options: {})
-        @type = type
-        @field = field
+      attr_reader :validation
+
+      def initialize(validation:, value:, errors:)
+        @validation = validation
         @value = value
         @errors = errors
-        @options = options
+        @options = validation.options.presence || {}
       end
 
       def call
@@ -25,7 +26,7 @@ module ValidateParams
           return
         end
 
-        send(@type.to_s.underscore)
+        send(validation.type.to_s.underscore)
       end
 
       private
@@ -129,18 +130,15 @@ module ValidateParams
         end
 
         def error_param_name
-          case @field
-          when Array
-            "#{@field[0]}[#{@field[1]}]"
-          when Hash
-            @field.map { |k, v| "#{k}[#{v}]" }.first
+          if validation.parent
+            "#{validation.parent.field}[#{validation.field}]"
           else
-            @field
+            validation.field
           end
         end
 
         def error_message
-          I18n.t("validate_params.invalid_type", param: error_param_name, type: @type)
+          I18n.t("validate_params.invalid_type", param: error_param_name, type: validation.type)
         end
 
         def required_error_message

data/lib/validate_params/types/array.rb

@@ -3,7 +3,7 @@
 module ValidateParams
   class Types
     class Array
-      def self.valid?(value, of: String, reject_blank: false, **)
+      def self.valid?(value, of: ::String, reject_blank: false, **)
         return false unless value.is_a?(::Array)
 
         val = value
@@ -16,12 +16,14 @@ module ValidateParams
           val.all? { |item| Types::Float.valid?(item) }
         when "String"
           val.all? { |item| item.is_a?(::String) }
+        when "Hash"
+          val.all? { |item| item.is_a?(::Hash) }
         else
           true
         end
       end
 
-      def self.cast(raw_value, of: String, reject_blank: false, **)
+      def self.cast(raw_value, of: ::String, reject_blank: false, **)
         value = raw_value
         value.reject!(&:blank?) if reject_blank
 

data/lib/validate_params/validatable.rb

@@ -23,14 +23,17 @@ module ValidateParams
     class_methods do
       attr_reader :params_validations
 
-      def validate_params_for(action, options = {}, &block)
+      def validate_params_for(action, options = {})
         options[:format] ||= :json
         @params_validations ||= {}
 
         Array(action).each do |act|
           @params_validations[act] ||= { options: options, validations: [] }
 
-          yield(ParamBuilder.new(validations: @params_validations[act][:validations])) if block
+          if block_given?
+            param_builder = ParamBuilder.new(validations: @params_validations[act][:validations])
+            yield(param_builder)
+          end
         end
       end
     end
@@ -47,29 +50,15 @@ module ValidateParams
         config = params_validations[action_name.to_sym]
 
         config[:validations].each do |validation|
-          apply_default_values(validation)
-
-          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[validation[:field]]
-                            end
-
-          ParamValidator.call(
-            type: validation[:type],
-            field: validation[:field],
-            value: parameter_value,
-            errors: errors,
-            options: validation[:options]
-          )
+          apply_default_values(params, validation)
+          validation.valid?(params[validation.field], errors)
         end
 
         if errors.empty?
-          cast_param_values(config[:validations])
+          config[:validations].each do |validation|
+            cast_param_values(params, validation)
+          end
+
           return
         end
 
@@ -81,57 +70,57 @@ module ValidateParams
         end
       end
 
-      def apply_default_values(validation)
-        return unless validation[:options].key?(:default)
+      def apply_default_values(params, validation)
+        validation.children.each do |sub_validation|
+          next if sub_validation.options.blank?
 
-        if validation[:field].is_a?(Hash)
-          validation[:field].each_key do |key|
+          if validation.type == Array
+            Array(params[validation.field]).each do |sub_params|
+              apply_default_values(sub_params, sub_validation)
+            end
+          elsif validation.type == Hash
             # 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
+            next if params[validation.field].is_a?(String)
 
-            params[key] ||= {}
-            params[key][validation[:field][key]] = value
+            params[validation.field] ||= {}
+            apply_default_values(params[validation.field], sub_validation)
+          else
+            apply_default_values(params, sub_validation)
           end
-        else
-          value = if validation[:options][:default].is_a?(Proc)
-                    validation[:options][:default].call
-                  else
-                    validation[:options][:default]
-                  end
-
-          params[validation[:field]] ||= value
         end
+
+        return if validation.children.any?
+
+        options = validation.options.presence || {}
+        return if !options.key?(:default)
+
+        value = options[:default].is_a?(Proc) ? options[:default].call : options[:default]
+        params[validation.field] ||= value
       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])
+      def cast_param_values(params, validation)
+        return unless params
 
-              value = params.dig(key, validation[:field][key])
-              next if value.blank?
+        validation.children.each do |sub_validation|
+          if validation.type == Hash
+            # Skip in case hash is configured and string is passed
+            next if params[validation.field].is_a?(String)
 
-              params[key][validation[:field][key]] = Types.const_get(validation[:type].name).cast(value, **validation.fetch(:options, {}))
+            cast_param_values(params[validation.field], sub_validation)
+          elsif validation.type == Array
+            params[validation.field].each do |sub_params|
+              cast_param_values(sub_params, sub_validation)
             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)
+        return if validation.children.any?
+
+        value = params[validation.field]
+        return if value.blank?
+
+        options = validation.options.presence || {}
+        params[validation.field] = Types.const_get(validation.type.name).cast(value, **options)
       end
   end
 end

data/lib/validate_params/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: validate-params
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - dcherevatenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-06 00:00:00.000000000 Z
+date: 2024-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack