rbdantic 0.1.0

data/lib/rbdantic/validators/types/array.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "base"
+
+module Rbdantic
+  module Validators
+    module Types
+      class Array < Base
+        attr_reader :element_type, :item_validator
+
+        def initialize(element_type: nil, **constraints)
+          super(**constraints)
+          @element_type = element_type
+          @item_validator = Types.create_validator(element_type) if element_type
+        end
+
+        def matches_type?(value)
+          value.is_a?(::Array)
+        end
+
+        def expected_type_name
+          "Array"
+        end
+
+        def validate_constraints(value, errors, location, strict: false)
+          validate_length(value, errors, location)
+          validate_unique(value, errors, location)
+          validate_items(value, errors, location, strict: strict)
+        end
+
+        def coerce(value)
+          case value
+          when ::String
+            begin
+              parsed = JSON.parse(value)
+              parsed if parsed.is_a?(::Array)
+            rescue JSON::ParserError; nil
+            end
+          else
+            value.respond_to?(:to_a) ? value.to_a : nil
+          end
+        end
+
+        private
+
+        def validate_length(value, errors, location)
+          if constraints[:min_items] && value.length < constraints[:min_items]
+            errors << error(type: :array_too_short, loc: location, 
+                            msg: "Array must have at least #{constraints[:min_items]} items", input: value)
+          end
+          if constraints[:max_items] && value.length > constraints[:max_items]
+            errors << error(type: :array_too_long, loc: location, 
+                            msg: "Array must have at most #{constraints[:max_items]} items", input: value)
+          end
+        end
+
+        def validate_unique(value, errors, location)
+          if constraints[:unique_items] && value.uniq.length != value.length
+            errors << error(type: :array_items_not_unique, loc: location, msg: "Array items must be unique", 
+                            input: value)
+          end
+        end
+
+        def validate_items(value, errors, location, strict: false)
+          return value unless @item_validator
+
+          value.map.with_index do |item, index|
+            item_errors, coerced_item = @item_validator.validate(item, location + [index], strict: strict)
+            errors.concat(item_errors)
+            coerced_item
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/base.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Rbdantic
+  module Validators
+    module Types
+      # Base class for type validators
+      # Provides common validation pattern with type checking and coercion
+      class Base
+        attr_reader :constraints
+
+        def initialize(**constraints)
+          @constraints = constraints
+        end
+
+        # Main validation entry point
+        # @return [Array<ErrorDetail>, value] tuple of errors and validated/coerced value
+        def validate(value, location = [], strict: false)
+          errors = []
+
+          # Type check with optional coercion
+          unless matches_type?(value)
+            if !strict && !(coerced = coerce(value)).nil?
+              value = coerced
+            else
+              errors << type_error(value, location)
+              return [errors, value]
+            end
+          end
+
+          # Constraint validation (override in subclasses)
+          # Returns potentially transformed value (e.g., for nested type coercion)
+          value = validate_constraints(value, errors, location, strict: strict)
+
+          [errors, value]
+        end
+
+        # Override in subclasses to define type matching
+        # @return [Boolean] true if value matches expected type
+        def matches_type?(value)
+          raise NotImplementedError, "Type validators must implement #matches_type?"
+        end
+
+        # Override in subclasses to define coercion logic
+        # @return [Object, nil] coerced value or nil if cannot coerce
+        def coerce(_value)
+          nil
+        end
+
+        # Override in subclasses to add constraint validation
+        # @param value the validated value
+        # @param errors [Array] error accumulator
+        # @param location [Array] current location path
+        # @param strict [Boolean] strict mode flag
+        # @return [Object] the (potentially transformed) value
+        def validate_constraints(value, _errors, _location, strict: false)
+          value
+        end
+
+        # Expected type name for error messages
+        # @return [String] human-readable type name
+        def expected_type_name
+          raise NotImplementedError, "Type validators must implement #expected_type_name"
+        end
+
+        protected
+
+        def error(type:, loc:, msg:, input: nil)
+          ErrorDetail.new(type: type, loc: loc, msg: msg, input: input)
+        end
+
+        def type_error(value, location)
+          error(type: :type_error, loc: location, msg: "Expected #{expected_type_name}, got #{value.class.name}", 
+                input: value)
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/boolean.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Rbdantic
+  module Validators
+    module Types
+      class Boolean < Base
+        def matches_type?(value)
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        end
+
+        def expected_type_name
+          "Boolean"
+        end
+
+        def coerce(value)
+          return value if value == true || value == false
+
+          case value
+          when ::String
+            str = value.strip.downcase
+            return true if str == "true" || str == "1" || str == "yes" || str == "on"
+            return false if str == "false" || str == "0" || str == "no" || str == "off"
+            nil
+          when ::Integer
+            return true if value == 1
+            return false if value == 0
+            nil
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/float.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "number"
+
+module Rbdantic
+  module Validators
+    module Types
+      class Float < Number
+        def matches_type?(value)
+          value.is_a?(::Float)
+        end
+
+        def expected_type_name
+          "Float"
+        end
+
+        def numeric_type?
+          true
+        end
+
+        def coerce(value)
+          case value
+          when ::Float then value
+          when ::Integer then value.to_f
+          when ::String then Float(value) rescue nil
+          else nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/hash.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "base"
+
+module Rbdantic
+  module Validators
+    module Types
+      class Hash < Base
+        def matches_type?(value)
+          value.is_a?(::Hash)
+        end
+
+        def expected_type_name
+          "Hash"
+        end
+
+        def validate_constraints(value, errors, location, strict: false)
+          validate_size(value, errors, location)
+          value
+        end
+
+        def coerce(value)
+          case value
+          when ::Hash then value
+          when ::Array
+            value.to_h if value.all? { |item| item.is_a?(::Array) && item.length == 2 }
+          when ::String
+            begin
+              parsed = JSON.parse(value)
+              parsed if parsed.is_a?(::Hash)
+            rescue JSON::ParserError; nil
+            end
+          else
+            value.to_h if value.respond_to?(:to_h)
+          end
+        end
+
+        private
+
+        def validate_size(value, errors, location)
+          if constraints[:min_properties] && value.length < constraints[:min_properties]
+            errors << error(type: :hash_too_few_properties, loc: location, 
+                            msg: "Hash must have at least #{constraints[:min_properties]} properties", input: value)
+          end
+          if constraints[:max_properties] && value.length > constraints[:max_properties]
+            errors << error(type: :hash_too_many_properties, loc: location, 
+                            msg: "Hash must have at most #{constraints[:max_properties]} properties", input: value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/integer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "number"
+
+module Rbdantic
+  module Validators
+    module Types
+      class Integer < Number
+        def matches_type?(value)
+          value.is_a?(::Integer)
+        end
+
+        def expected_type_name
+          "Integer"
+        end
+
+        def coerce(value)
+          case value
+          when ::Integer then value
+          when ::Float then value.to_i if value == value.floor
+          when ::String then Integer(value) rescue nil
+          else nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/model.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Rbdantic
+  module Validators
+    module Types
+      # Validator for nested model types
+      class Model < Base
+        attr_reader :model_class
+
+        def initialize(model_class, **constraints)
+          super(**constraints)
+          @model_class = model_class
+        end
+
+        def matches_type?(value)
+          value.is_a?(@model_class)
+        end
+
+        def expected_type_name
+          @model_class.name
+        end
+
+        # Model validation has special handling for nil and Hash
+        # so we override validate entirely
+        def validate(value, location = [], strict: false)
+          return [[], nil] if value.nil?
+
+          if matches_type?(value)
+            return [validate_existing_instance(value, location, strict: strict), value]
+          end
+
+          if value.is_a?(::Hash)
+            if strict
+              return [
+                [error(type: :type_error, loc: location, msg: "Expected #{expected_type_name}, got Hash", input: value)],
+                value
+              ]
+            end
+            begin
+              return [[], @model_class.new(value)]
+            rescue ValidationError => e
+              return [remap_errors(e.errors, location), value]
+            end
+          end
+
+          [
+            [error(type: :type_error, loc: location, msg: "Expected #{expected_type_name}, got #{value.class.name}", input: value)],
+            value
+          ]
+        end
+
+        def validate_constraints(value, _errors, _location, strict: false)
+          value
+        end
+
+        private
+
+        def validate_existing_instance(model, location, strict: false)
+          model.class.new(model.model_dump)
+          []
+        rescue ValidationError => e
+          remap_errors(e.errors, location)
+        end
+
+        def remap_errors(errors, location)
+          errors.map do |err|
+            ErrorDetail.new(type: err.type, loc: location + err.loc, msg: err.msg, input: err.input)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/number.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Rbdantic
+  module Validators
+    module Types
+      # Abstract base for numeric validators (Integer, Float)
+      class Number < Base
+        # Tolerance constants for floating-point comparison
+        FLOAT_TOLERANCE_FACTOR = 1e-9
+        MIN_FLOAT_TOLERANCE = 1e-12
+
+        def matches_type?
+          raise NotImplementedError
+        end
+
+        def expected_type_name
+          raise NotImplementedError
+        end
+
+        def validate_constraints(value, errors, location, strict: false)
+          validate_bounds(value, errors, location)
+          validate_multiple_of(value, errors, location) if constraints[:multiple_of]
+          value
+        end
+
+        private
+
+        def validate_bounds(value, errors, location)
+          if constraints[:gt] && value <= constraints[:gt]
+            errors << error(type: :value_not_greater_than, loc: location, 
+                            msg: "Value must be greater than #{constraints[:gt]}", input: value)
+          end
+          if constraints[:ge] && value < constraints[:ge]
+            errors << error(type: :value_not_greater_than_or_equal, loc: location, 
+                            msg: "Value must be greater than or equal to #{constraints[:ge]}", input: value)
+          end
+          if constraints[:lt] && value >= constraints[:lt]
+            errors << error(type: :value_not_less_than, loc: location, 
+                            msg: "Value must be less than #{constraints[:lt]}", input: value)
+          end
+          if constraints[:le] && value > constraints[:le]
+            errors << error(type: :value_not_less_than_or_equal, loc: location, 
+                            msg: "Value must be less than or equal to #{constraints[:le]}", input: value)
+          end
+        end
+
+        def validate_multiple_of(value, errors, location)
+          multiple = constraints[:multiple_of].abs
+          remainder = value % multiple
+          tolerance = numeric_type? ? [multiple * FLOAT_TOLERANCE_FACTOR, MIN_FLOAT_TOLERANCE].max : 0
+          if remainder > tolerance && remainder < multiple - tolerance
+            errors << error(type: :value_not_multiple_of, loc: location, 
+                            msg: "Value must be a multiple of #{constraints[:multiple_of]}", input: value)
+          end
+        end
+
+        def numeric_type?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/string.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Rbdantic
+  module Validators
+    module Types
+      class String < Base
+        FORMAT_PATTERNS = {
+          email: /\A[^@\s]+@[^@\s]+\z/,
+          uri: /\A[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^\s]+\z/,
+          uuid: /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+        }.freeze
+
+        def matches_type?(value)
+          value.is_a?(::String)
+        end
+
+        def expected_type_name
+          "String"
+        end
+
+        def coerce(value)
+          case value
+          when ::String then value
+          when ::Symbol, Numeric, TrueClass, FalseClass then value.to_s
+          else nil
+          end
+        end
+
+        def validate_constraints(value, errors, location, strict: false)
+          validate_length(value, errors, location)
+          validate_pattern(value, errors, location)
+          validate_format(value, errors, location)
+          value
+        end
+
+        private
+
+        def validate_length(value, errors, location)
+          if constraints[:min_length] && value.length < constraints[:min_length]
+            errors << error(type: :string_too_short, loc: location, 
+                            msg: "String must be at least #{constraints[:min_length]} characters", input: value)
+          end
+
+          if constraints[:max_length] && value.length > constraints[:max_length]
+            errors << error(type: :string_too_long, loc: location, 
+                            msg: "String must be at most #{constraints[:max_length]} characters", input: value)
+          end
+        end
+
+        def validate_pattern(value, errors, location)
+          if constraints[:pattern] && !constraints[:pattern].match?(value)
+            errors << error(type: :string_pattern_mismatch, loc: location, 
+                            msg: "String does not match pattern #{constraints[:pattern].source}", input: value)
+          end
+        end
+
+        def validate_format(value, errors, location)
+          if constraints[:format] && FORMAT_PATTERNS.key?(constraints[:format])
+            unless FORMAT_PATTERNS[constraints[:format]].match?(value)
+              errors << error(type: :string_format_mismatch, loc: location, 
+                              msg: "String does not match format '#{constraints[:format]}'", input: value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/symbol.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Rbdantic
+  module Validators
+    module Types
+      class Symbol < Base
+        MAX_SYMBOL_LENGTH = 256
+
+        def matches_type?(value)
+          value.is_a?(::Symbol)
+        end
+
+        def expected_type_name
+          "Symbol"
+        end
+
+        def coerce(value)
+          case value
+          when ::Symbol then value
+          when ::String
+            value.to_sym if !value.empty? && value.length <= MAX_SYMBOL_LENGTH
+          else nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types/time.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "base"
+
+module Rbdantic
+  module Validators
+    module Types
+      class Time < Base
+        def matches_type?(value)
+          value.is_a?(::Time)
+        end
+
+        def expected_type_name
+          "Time"
+        end
+
+        def coerce(value)
+          case value
+          when ::Time
+            value
+          when ::String
+            ::Time.iso8601(value)
+          when ::Integer, ::Float
+            ::Time.at(value)
+          end
+        rescue ArgumentError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/types.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "types/base"
+require_relative "types/number"
+require_relative "types/string"
+require_relative "types/integer"
+require_relative "types/float"
+require_relative "types/boolean"
+require_relative "types/array"
+require_relative "types/hash"
+require_relative "types/symbol"
+require_relative "types/time"
+require_relative "types/model"
+
+module Rbdantic
+  # Marker class for boolean type validation (since Ruby has TrueClass and FalseClass)
+  class Boolean; end
+
+  module Validators
+    module Types
+      VALIDATOR_CLASSES = {
+        ::String => Validators::Types::String,
+        ::Integer => Validators::Types::Integer,
+        ::Float => Validators::Types::Float,
+        Rbdantic::Boolean => Validators::Types::Boolean,
+        ::Array => Validators::Types::Array,
+        ::Hash => Validators::Types::Hash,
+        ::Symbol => Validators::Types::Symbol,
+        ::Time => Validators::Types::Time
+      }.freeze
+
+      def self.validator_class_for(type)
+        VALIDATOR_CLASSES[type]
+      end
+
+      # Create validator for type with constraints
+      # @param type [Class] the field type
+      # @param constraints [Hash] constraint options (min_length, gt, etc.)
+      # @return [Base, nil] validator instance
+      def self.create_validator(type, **constraints)
+        return nil if type.nil?
+
+        if nested_model?(type)
+          return Validators::Types::Model.new(type, **constraints)
+        end
+
+        validator_class = VALIDATOR_CLASSES[type]
+        raise ArgumentError, "Unsupported field type: #{type}" unless validator_class
+
+        validator_class.new(**constraints)
+      end
+
+      def self.has_validator?(type)
+        VALIDATOR_CLASSES.key?(type)
+      end
+
+      # Check if type is a nested model
+      def self.nested_model?(type)
+        type.is_a?(Class) && type < Rbdantic::BaseModel && !type.equal?(Rbdantic::BaseModel)
+      end
+    end
+  end
+end

data/lib/rbdantic/validators/validator_context.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Rbdantic
+  module Validators
+    # Context object passed to validators during validation
+    class ValidatorContext
+      attr_reader :field_name, :field_info, :model_class, :model_instance, :data
+
+      def initialize(
+        field_name: nil,
+        field_info: nil,
+        model_class: nil,
+        model_instance: nil,
+        data: {}
+      )
+        @field_name = field_name
+        @field_info = field_info
+        @model_class = model_class
+        @model_instance = model_instance
+        @data = data
+      end
+
+      # Create an error detail object
+      def create_error(type:, msg:, input: nil)
+        ErrorDetail.new(
+          type: type,
+          loc: [@field_name],
+          msg: msg,
+          input: input
+        )
+      end
+
+      # Access other field values (for cross-field validation)
+      def field_value(name)
+        if @data.key?(name)
+          @data[name]
+        else
+          @model_instance&.instance_variable_get("@#{name}")
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rbdantic
+  VERSION = "0.1.0"
+end