rails_validation_api 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4f6763bbc5879669935aedb9a4c25437da3a78c480ee2d0fd89a8c20ba52eec
-  data.tar.gz: d262f3175cb60f276c0f28b286fa2fcf3ccf294275943da75c6eb9e8b5dc8810
+  metadata.gz: 0f8b0173edc6150f0f3da1222f676773aa9546df4eeeeee80e0b0c4807a14a9c
+  data.tar.gz: 31d304de82e0e4e467e4d24bc2fea7fb53904e4aa9a440d9cdc8d5193d429df1
 SHA512:
-  metadata.gz: 0baf32fb6aca2cde5a15c874f5f46d69b3d7e3c0ab00f9f7cb51583359a70c454c2dc259bc981fd22dafe832c08758358d0659b6b4f881c3e8a58ca8a9ebe290
-  data.tar.gz: 737cf138b2137716889652e0155f9dd9905527a4bb3f439b9b0395201db551d01ed9e115eeb3d855d08d7cc30b76c81922b3c11e65f2a4030bc28864bf8bcf29
+  metadata.gz: 4f3e4352a23015c25f7d2dfabf4fcd6354db63222b7a543ffd52497f8f4ab256e1b52b2fea6ad009df82b29421bacb4d797b29605bc45983449dcc265f0ed0f7
+  data.tar.gz: afe6fb7862f8f704bfea8bbabc8dde452e6590f8e64f5acd19b3b8bda7f980d595156c00a5074593b2bc6aa600206161568e3badb0e86eb8c220f28b1c4685d1

data/lib/rails_validation_api/validator.rb

@@ -2,9 +2,12 @@ require "date"
 require "time"
 require "bigdecimal"
 require "active_support/all"
-require "debug"
+require "rails_param"
+
 module RailsValidationApi
   class Validator
+    include RailsParam
+
     attr_accessor :params
     attr_reader :errors
 
@@ -17,13 +20,13 @@ module RailsValidationApi
     def validate
       return false if @rules.nil? || @rules.empty?
 
-      @rules.each do |rule, _|
-        validate_field(rule)
+      @rules.each do |rule_name, rule|
+        validate_field(rule_name)
       end
       if @errors.any?
-        # Only raise the first error to match expected behavior
-        first_error = @errors.first
-        raise RailsValidationApi::Error.new(first_error[:field], :unprocessable_entity, first_error[:message])
+        @errors.each do |error|
+          raise RailsValidationApi::Error.new(error[:field], :unprocessable_entity, error[:message])
+        end
       end
     end
 
@@ -39,37 +42,32 @@ module RailsValidationApi
 
       return unless field && type
 
-      # Get the field value from params
-      value = params[field]
-
       # Validate the main field
       opts.each do |opt|
         next unless opt.is_a?(Hash)
 
-        # Check if field is required and missing
-        if opt[:required] && (value.nil? || (value.is_a?(String) && value.empty?))
-          message = opt[:message] || "Parameter #{field} is required"
-          @errors << { field: field, message: message }
-          next
-        end
-
-        # Skip further validation if field is not required and is nil/empty
-        next if !opt[:required] && (value.nil? || (value.is_a?(String) && value.empty?))
-
-        # Type validation
-        unless value.nil? || valid_type?(value, type)
-          message = opt[:message] || "Parameter #{field} must be of type #{type}"
+        begin
+          if type == Array && opt[:type] # => Nested item type inside Array
+            param! field, Array do |array_param, index|
+              begin
+                array_param.param! index, opt[:type], **opt.except(:type)
+              rescue RailsParam::InvalidParameterError => e
+                message = opt[:message] || e.message ||  "Invalid value at index #{index} for #{field}"
+                @errors << { field: "#{field}[#{index}]", message: message }
+              end
+            end
+          else
+            param! field, type, **opt
+          end
+        rescue RailsParam::InvalidParameterError => e
+          message = (e.message).include?(type.to_s) ? e.message : opt[:message]
           @errors << { field: field, message: message }
-          next
         end
-
-        # Additional validations
-        validate_options(field, value, opt)
       end
 
       # Validate nested items if present (for Hash/Array fields)
-      if items && value.is_a?(Hash)
-        validate_nested_items(field, items, value)
+      if items && params[field].is_a?(Hash)
+        validate_nested_items(field, items, params[field])
       end
     end
 
@@ -85,88 +83,19 @@ module RailsValidationApi
 
         next unless item_field && item_type
 
-        # Validate nested field
-        value = nested_params[item_field]
+        # Create a temporary validator for nested validation
+        temp_validator = self.class.new(nested_params, {})
         item_opts.each do |opt|
           next unless opt.is_a?(Hash)
 
-          # Check if field is required and missing
-          if opt[:required] && (value.nil? || (value.is_a?(String) && value.empty?))
-            message = opt[:message] || "Parameter #{parent_field}.#{item_field} is required"
+          begin
+            temp_validator.param! item_field, item_type, **opt
+          rescue RailsParam::InvalidParameterError => e
+            message = (e.message).include?(item_type.to_s) ? e.message : opt[:message]
             @errors << { field: "#{parent_field}.#{item_field}", message: message }
-            next
           end
-
-          # Skip further validation if field is not required and is nil/empty
-          next if !opt[:required] && (value.nil? || (value.is_a?(String) && value.empty?))
-
-          # Type validation
-          unless value.nil? || valid_type?(value, item_type)
-            message = opt[:message] || "Parameter #{parent_field}.#{item_field} must be of type #{item_type}"
-            @errors << { field: "#{parent_field}.#{item_field}", message: message }
-            next
-          end
-
-          # Additional validations
-          validate_options("#{parent_field}.#{item_field}", value, opt)
         end
       end
     end
-
-    def valid_type?(value, type)
-      value = format_string_to_int(value, type)
-      case type.to_s
-      when String.to_s
-        value.is_a?(String)
-      when Integer.to_s
-        value.is_a?(Integer)
-      when Float.to_s
-        value.is_a?(Float) || value.is_a?(Integer)
-      when Hash.to_s
-        value.is_a?(Hash)
-      when Array.to_s
-        value.is_a?(Array)
-      when TrueClass.to_s, FalseClass.to_s
-        value.is_a?(TrueClass) || value.is_a?(FalseClass)
-      else
-        value.is_a?(type)
-      end
-    end
-
-    def validate_options(field, value, opt)
-      # Handle min validation
-      if opt[:min] && value.respond_to?(:to_i) && value.to_i < opt[:min]
-        message = opt[:message] || "Parameter #{field} must be at least #{opt[:min]}"
-        @errors << { field: field, message: message }
-      end
-
-      # Handle max validation
-      if opt[:max] && value.respond_to?(:to_i) && value.to_i > opt[:max]
-        message = opt[:message] || "Parameter #{field} must be at most #{opt[:max]}"
-        @errors << { field: field, message: message }
-      end
-
-      # Handle format validation
-      if opt[:format] && value.is_a?(String) && !(value =~ opt[:format])
-        message = opt[:message] || "Parameter #{field} format is invalid"
-        @errors << { field: field, message: message }
-      end
-
-      # Handle blank validation
-      if opt[:blank] == false && value.is_a?(String) && value.strip.empty?
-        message = opt[:message] || "Parameter #{field} cannot be blank"
-        @errors << { field: field, message: message }
-      end
-    end
-
-    def format_string_to_int(value, type)
-      return value unless value.is_a?(String)
-
-      return Integer(value) rescue value if type == Integer
-      return Float(value) rescue value if type == Float
-      value
-    rescue ArgumentError
-      value
-    end
   end
 end

data/lib/rails_validation_api/version.rb

@@ -1,3 +1,3 @@
 module RailsValidationApi
-  VERSION = "1.2.2"
+  VERSION = "1.2.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_validation_api
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Linh Nguyen Quang