rails_validation_api 0.1.4 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c8b2ee85dd44f77049f9ea0fdb831032bdbab38cc9136d8f2f4c5f8172fc206
-  data.tar.gz: 9001029cc5ed6f29c384baae405d8c8c5512b54c231972664d62614fbbed881f
+  metadata.gz: b2e0c05e2f9557b374836280b8519994e5975e1863e690cc37ca3371a1124d89
+  data.tar.gz: bc433ab541ae2b18f683c61b2f3070d3e97966b77592ec10bc65cad19d9f27aa
 SHA512:
-  metadata.gz: d843949e5f13289add4f81f971b75d0d72f85ea0e05583ee6382b900c7e243de9e8882bcca6a33fd3958c35b204b276697e8cf95381358be2e593febc5d8e237
-  data.tar.gz: f9c4981c1dd5388cd0ee0f5736907bf0f6fca226fc96a0bacd9dec975f835ca317801d7add913cfc733a0eca9a9e6c101eae6f90dce4e40be126f420bf42a7f8
+  metadata.gz: 88d8a71badbcadf927b7c44768a30843ed4d6c5d4ed333c20d4a9ca410cdc1fa5cec0ddc5229eb0cccf781ab3d78ddb5e611be72179c48ef6e13b1eafbc3ce88
+  data.tar.gz: 9f8cecae3ccc4fb1648e7afaf8e130ad351aa1ca3fe59d647ae8711d40388d9b24b29bc2da763f9bc7e7c1e4034b51c2d17392201225eda53ee4877de5fbdccd

data/lib/rails_validation_api/validator.rb

@@ -2,12 +2,9 @@ require "date"
 require "time"
 require "bigdecimal"
 require "active_support/all"
-require "rails_param"
-
+require "debug"
 module RailsValidationApi
   class Validator
-    include RailsParam
-
     attr_accessor :params
     attr_reader :errors
 
@@ -20,13 +17,13 @@ module RailsValidationApi
     def validate
       return false if @rules.nil? || @rules.empty?
 
-      @rules.each do |rule_name, rule|
-        validate_field(rule_name)
+      @rules.each do |rule, _|
+        validate_field(rule)
       end
       if @errors.any?
-        @errors.each do |error|
-          raise RailsValidationApi::Error.new(error[:field], :unprocessable_entity, error[:message])
-        end
+        # 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])
       end
     end
 
@@ -42,21 +39,37 @@ 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)
 
-        begin
-          param! field, type, **opt
-        rescue RailsParam::InvalidParameterError => e
-          message = (e.message).include?(type.to_s) ? e.message : opt[:message]
+        # 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}"
+          @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 && params[field].is_a?(Hash)
-        validate_nested_items(field, items, params[field])
+      if items && value.is_a?(Hash)
+        validate_nested_items(field, items, value)
       end
     end
 
@@ -72,19 +85,77 @@ module RailsValidationApi
 
         next unless item_field && item_type
 
-        # Create a temporary validator for nested validation
-        temp_validator = self.class.new(nested_params, {})
+        # Validate nested field
+        value = nested_params[item_field]
         item_opts.each do |opt|
           next unless opt.is_a?(Hash)
 
-          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]
+          # 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"
+            @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)
+      case type
+      when String
+        value.is_a?(String)
+      when Integer
+        value.is_a?(Integer)
+      when Float
+        value.is_a?(Float) || value.is_a?(Integer)
+      when Hash
+        value.is_a?(Hash)
+      when Array
+        value.is_a?(Array)
+      when TrueClass, FalseClass
+        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
   end
 end

data/lib/rails_validation_api/version.rb

@@ -1,3 +1,3 @@
 module RailsValidationApi
-  VERSION = "0.1.4"
+  VERSION = "1.2.0"
 end

data/lib/rails_validation_api.rb

@@ -3,8 +3,11 @@
 require "logger"
 require "active_model"
 require "active_support"
-require "rails_param"
 require "active_support/core_ext/hash"
+require "date"
+require "time"
+require "bigdecimal"
+require "rails_param"
 require_relative "rails_validation_api/dsl"
 require_relative "rails_validation_api/validator"
 require "active_support/concern"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_validation_api
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 1.2.0
 platform: ruby
 authors:
 - Linh Nguyen Quang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-04 00:00:00.000000000 Z
+date: 2025-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Rails Validation API provides a powerful DSL for validating request parameters
   in Rails applications. Features include automatic validator loading based on controller/action
   names, nested parameter validation, custom error handling, and seamless integration