validrb 0.5.0

data/lib/validrb/types/date.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Validrb
+  module Types
+    # Date type with coercion from String (ISO8601) and Time/DateTime
+    class Date < Base
+      # Common date formats to try (ISO8601-like formats only to avoid ambiguity)
+      DATE_FORMATS = [
+        "%Y-%m-%d",      # 2024-01-15 (ISO8601)
+        "%Y/%m/%d"       # 2024/01/15
+      ].freeze
+
+      def coerce(value)
+        case value
+        when ::DateTime
+          # DateTime is a subclass of Date, so check it first
+          ::Date.new(value.year, value.month, value.day)
+        when ::Date
+          value
+        when ::Time
+          value.to_date
+        when ::String
+          coerce_string(value)
+        when ::Integer
+          # Unix timestamp
+          ::Time.at(value).to_date
+        else
+          COERCION_FAILED
+        end
+      end
+
+      def valid?(value)
+        value.is_a?(::Date) && !value.is_a?(::DateTime)
+      end
+
+      def type_name
+        "date"
+      end
+
+      private
+
+      def coerce_string(value)
+        stripped = value.strip
+        return COERCION_FAILED if stripped.empty?
+
+        # Try ISO8601 first (most common)
+        begin
+          return ::Date.iso8601(stripped)
+        rescue ArgumentError
+          # Continue to other formats
+        end
+
+        # Try other common formats
+        DATE_FORMATS.each do |format|
+          begin
+            return ::Date.strptime(stripped, format)
+          rescue ArgumentError
+            next
+          end
+        end
+
+        COERCION_FAILED
+      end
+    end
+
+    register(:date, Date)
+  end
+end

data/lib/validrb/types/datetime.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+module Validrb
+  module Types
+    # DateTime type with coercion from String (ISO8601) and Time/Date
+    class DateTime < Base
+      def coerce(value)
+        case value
+        when ::DateTime
+          value
+        when ::Time
+          value.to_datetime
+        when ::Date
+          value.to_datetime
+        when ::String
+          coerce_string(value)
+        when ::Integer
+          # Unix timestamp
+          ::Time.at(value).to_datetime
+        when ::Float
+          # Unix timestamp with fractional seconds
+          ::Time.at(value).to_datetime
+        else
+          COERCION_FAILED
+        end
+      end
+
+      def valid?(value)
+        value.is_a?(::DateTime)
+      end
+
+      def type_name
+        "datetime"
+      end
+
+      private
+
+      def coerce_string(value)
+        stripped = value.strip
+        return COERCION_FAILED if stripped.empty?
+
+        # Try ISO8601 first
+        begin
+          return ::DateTime.iso8601(stripped)
+        rescue ArgumentError
+          # Continue
+        end
+
+        # Try RFC2822 (email date format)
+        begin
+          return ::DateTime.rfc2822(stripped)
+        rescue ArgumentError
+          # Continue
+        end
+
+        # Try Ruby's flexible parsing
+        begin
+          return ::DateTime.parse(stripped)
+        rescue ArgumentError
+          COERCION_FAILED
+        end
+      end
+    end
+
+    register(:datetime, DateTime)
+    register(:date_time, DateTime)
+  end
+end

data/lib/validrb/types/decimal.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Validrb
+  module Types
+    # Decimal type using BigDecimal for precise monetary values
+    class Decimal < Base
+      def coerce(value)
+        case value
+        when ::BigDecimal
+          return COERCION_FAILED unless value.finite?
+
+          value
+        when ::Integer
+          BigDecimal(value)
+        when ::Float
+          return COERCION_FAILED unless value.finite?
+
+          BigDecimal(value, ::Float::DIG)
+        when ::String
+          coerce_string(value)
+        when ::Rational
+          BigDecimal(value, ::Float::DIG)
+        else
+          COERCION_FAILED
+        end
+      end
+
+      def valid?(value)
+        value.is_a?(::BigDecimal) && value.finite?
+      end
+
+      def type_name
+        "decimal"
+      end
+
+      private
+
+      def coerce_string(value)
+        stripped = value.strip
+        return COERCION_FAILED if stripped.empty?
+
+        # Validate format before conversion
+        return COERCION_FAILED unless stripped.match?(/\A-?\d+(\.\d+)?\z/)
+
+        result = BigDecimal(stripped)
+        result.finite? ? result : COERCION_FAILED
+      rescue ArgumentError
+        COERCION_FAILED
+      end
+    end
+
+    register(:decimal, Decimal)
+    register(:bigdecimal, Decimal)
+  end
+end

data/lib/validrb/types/discriminated_union.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Types
+    # Discriminated union type - selects schema based on discriminator field
+    # More efficient than regular unions for object types
+    class DiscriminatedUnion < Base
+      attr_reader :discriminator, :mapping
+
+      # @param discriminator [Symbol] The field to use as discriminator
+      # @param mapping [Hash<value, Schema>] Maps discriminator values to schemas
+      def initialize(discriminator:, mapping:, **options)
+        @discriminator = discriminator.to_sym
+        @mapping = mapping.transform_keys { |k| k.is_a?(Symbol) ? k.to_s : k }.freeze
+        super(**options)
+      end
+
+      def call(value, path: [])
+        unless value.is_a?(Hash)
+          return [nil, [Error.new(path: path, message: "must be an object", code: :type_error)]]
+        end
+
+        # Normalize input
+        normalized = value.transform_keys { |k| k.is_a?(Symbol) ? k.to_s : k }
+        disc_value = normalized[@discriminator.to_s]
+
+        if disc_value.nil?
+          return [nil, [Error.new(
+            path: path + [@discriminator],
+            message: "discriminator field is required",
+            code: :discriminator_missing
+          )]]
+        end
+
+        # Convert symbol to string for lookup
+        lookup_value = disc_value.is_a?(Symbol) ? disc_value.to_s : disc_value
+        schema = @mapping[lookup_value]
+
+        if schema.nil?
+          valid_values = @mapping.keys.map(&:inspect).join(", ")
+          return [nil, [Error.new(
+            path: path + [@discriminator],
+            message: "must be one of: #{valid_values}",
+            code: :invalid_discriminator
+          )]]
+        end
+
+        # Validate with the selected schema
+        result = schema.safe_parse(value, path_prefix: path)
+
+        if result.success?
+          [result.data, []]
+        else
+          [nil, result.errors.to_a]
+        end
+      end
+
+      def coerce(value)
+        value
+      end
+
+      def valid?(value)
+        value.is_a?(Hash)
+      end
+
+      def type_name
+        values = @mapping.keys.map(&:inspect).join(" | ")
+        "discriminated_union<#{@discriminator}: #{values}>"
+      end
+    end
+
+    register(:discriminated_union, DiscriminatedUnion)
+  end
+end

data/lib/validrb/types/float.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Types
+    # Float type with coercion from String/Integer
+    class Float < Base
+      def coerce(value)
+        case value
+        when ::Float
+          return COERCION_FAILED unless value.finite?
+
+          value
+        when ::Integer
+          value.to_f
+        when ::String
+          coerce_string(value)
+        else
+          COERCION_FAILED
+        end
+      end
+
+      def valid?(value)
+        value.is_a?(::Float) && value.finite?
+      end
+
+      def type_name
+        "float"
+      end
+
+      private
+
+      def coerce_string(value)
+        stripped = value.strip
+        return COERCION_FAILED if stripped.empty?
+
+        # Match integer or float format
+        return COERCION_FAILED unless stripped.match?(/\A-?\d+(\.\d+)?\z/)
+
+        result = stripped.to_f
+        result.finite? ? result : COERCION_FAILED
+      end
+    end
+
+    register(:float, Float)
+  end
+end

data/lib/validrb/types/integer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Types
+    # Integer type with coercion from String/Float
+    class Integer < Base
+      def coerce(value)
+        case value
+        when ::Integer
+          value
+        when ::Float
+          # Only coerce whole numbers
+          return COERCION_FAILED unless value.finite? && value == value.to_i
+
+          value.to_i
+        when ::String
+          coerce_string(value)
+        else
+          COERCION_FAILED
+        end
+      end
+
+      def valid?(value)
+        value.is_a?(::Integer)
+      end
+
+      def type_name
+        "integer"
+      end
+
+      private
+
+      def coerce_string(value)
+        stripped = value.strip
+        return COERCION_FAILED if stripped.empty?
+
+        # Try integer parse first
+        if stripped.match?(/\A-?\d+\z/)
+          return stripped.to_i
+        end
+
+        # Try float parse for strings like "42.0"
+        if stripped.match?(/\A-?\d+\.0+\z/)
+          return stripped.to_f.to_i
+        end
+
+        COERCION_FAILED
+      end
+    end
+
+    register(:integer, Integer)
+  end
+end

data/lib/validrb/types/literal.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Types
+    # Literal type for exact value matching
+    # Accepts only specific values (like TypeScript literal types)
+    class Literal < Base
+      attr_reader :values
+
+      def initialize(values:, **options)
+        @values = Array(values).freeze
+        super(**options)
+      end
+
+      def coerce(value)
+        # No coercion for literals - must match exactly
+        value
+      end
+
+      def valid?(value)
+        @values.include?(value)
+      end
+
+      def type_name
+        if @values.size == 1
+          @values.first.inspect
+        else
+          @values.map(&:inspect).join(" | ")
+        end
+      end
+
+      def coercion_error_message(value)
+        "must be #{type_name}, got #{value.inspect}"
+      end
+
+      def validation_error_message(value)
+        "must be #{type_name}, got #{value.inspect}"
+      end
+    end
+
+    register(:literal, Literal)
+  end
+end

data/lib/validrb/types/object.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Types
+    # Object type for nested schema validation
+    class Object < Base
+      attr_reader :schema
+
+      def initialize(schema: nil, **options)
+        @schema = schema
+        super(**options)
+      end
+
+      def coerce(value)
+        return COERCION_FAILED unless value.is_a?(Hash)
+
+        value
+      end
+
+      def valid?(value)
+        value.is_a?(Hash)
+      end
+
+      # Override call to delegate to nested schema
+      def call(value, path: [])
+        coerced = coerce(value)
+
+        if coerced.equal?(COERCION_FAILED)
+          return [nil, [Error.new(path: path, message: coercion_error_message(value), code: :type_error)]]
+        end
+
+        return [coerced, []] unless @schema
+
+        # Delegate to nested schema with path prefix
+        result = @schema.safe_parse(coerced, path_prefix: path)
+
+        if result.success?
+          [result.data, []]
+        else
+          [nil, result.errors.to_a]
+        end
+      end
+
+      def type_name
+        "object"
+      end
+    end
+
+    register(:object, Object)
+    register(:hash, Object)
+  end
+end

data/lib/validrb/types/string.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Types
+    # String type with coercion from Symbol/Numeric
+    class String < Base
+      def coerce(value)
+        case value
+        when ::String
+          value
+        when Symbol, Numeric
+          value.to_s
+        else
+          COERCION_FAILED
+        end
+      end
+
+      def valid?(value)
+        value.is_a?(::String)
+      end
+
+      def type_name
+        "string"
+      end
+    end
+
+    register(:string, String)
+  end
+end

data/lib/validrb/types/time.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Validrb
+  module Types
+    # Time type with coercion from String (ISO8601) and Date/DateTime
+    class Time < Base
+      def coerce(value)
+        case value
+        when ::Time
+          value
+        when ::DateTime
+          value.to_time
+        when ::Date
+          value.to_time
+        when ::String
+          coerce_string(value)
+        when ::Integer
+          # Unix timestamp
+          ::Time.at(value)
+        when ::Float
+          # Unix timestamp with fractional seconds
+          ::Time.at(value)
+        else
+          COERCION_FAILED
+        end
+      end
+
+      def valid?(value)
+        value.is_a?(::Time)
+      end
+
+      def type_name
+        "time"
+      end
+
+      private
+
+      def coerce_string(value)
+        stripped = value.strip
+        return COERCION_FAILED if stripped.empty?
+
+        # Try ISO8601 first
+        begin
+          return ::Time.iso8601(stripped)
+        rescue ArgumentError
+          # Continue
+        end
+
+        # Try RFC2822
+        begin
+          return ::Time.rfc2822(stripped)
+        rescue ArgumentError
+          # Continue
+        end
+
+        # Try Ruby's flexible parsing
+        begin
+          return ::Time.parse(stripped)
+        rescue ArgumentError
+          COERCION_FAILED
+        end
+      end
+    end
+
+    register(:time, Time)
+  end
+end

data/lib/validrb/types/union.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Types
+    # Union type that accepts any of the specified types
+    class Union < Base
+      attr_reader :types
+
+      def initialize(types:, **options)
+        @types = resolve_types(types)
+        super(**options)
+      end
+
+      def coerce(value)
+        # Try each type in order, return first successful coercion
+        @types.each do |type|
+          result = type.coerce(value)
+          return result unless result.equal?(COERCION_FAILED)
+        end
+
+        COERCION_FAILED
+      end
+
+      def valid?(value)
+        @types.any? { |type| type.valid?(value) }
+      end
+
+      # Override call to try each type and return first success
+      def call(value, path: [])
+        errors = []
+
+        @types.each do |type|
+          coerced, type_errors = type.call(value, path: path)
+          return [coerced, []] if type_errors.empty?
+
+          errors.concat(type_errors)
+        end
+
+        # All types failed - return a union-specific error
+        [nil, [Error.new(
+          path: path,
+          message: "must be one of: #{type_names.join(", ")}",
+          code: :union_type_error
+        )]]
+      end
+
+      def type_name
+        "union<#{type_names.join(" | ")}>"
+      end
+
+      private
+
+      def resolve_types(types)
+        types.map do |type|
+          case type
+          when Symbol
+            Types.build(type)
+          when Types::Base
+            type
+          when Class
+            type.new
+          else
+            raise ArgumentError, "Invalid type in union: #{type.inspect}"
+          end
+        end.freeze
+      end
+
+      def type_names
+        @types.map(&:type_name)
+      end
+    end
+
+    register(:union, Union)
+  end
+end

data/lib/validrb/version.rb

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

data/lib/validrb.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "validrb/version"
+require_relative "validrb/i18n"
+require_relative "validrb/errors"
+require_relative "validrb/result"
+require_relative "validrb/context"
+require_relative "validrb/constraints/base"
+require_relative "validrb/constraints/min"
+require_relative "validrb/constraints/max"
+require_relative "validrb/constraints/length"
+require_relative "validrb/constraints/format"
+require_relative "validrb/constraints/enum"
+require_relative "validrb/types/base"
+require_relative "validrb/types/string"
+require_relative "validrb/types/integer"
+require_relative "validrb/types/float"
+require_relative "validrb/types/boolean"
+require_relative "validrb/types/array"
+require_relative "validrb/types/object"
+require_relative "validrb/types/date"
+require_relative "validrb/types/datetime"
+require_relative "validrb/types/time"
+require_relative "validrb/types/decimal"
+require_relative "validrb/types/union"
+require_relative "validrb/types/literal"
+require_relative "validrb/types/discriminated_union"
+require_relative "validrb/field"
+require_relative "validrb/schema"
+require_relative "validrb/custom_type"
+require_relative "validrb/introspection"
+require_relative "validrb/serializer"
+require_relative "validrb/openapi"
+
+module Validrb
+  class << self
+    # Main entry point for creating schemas
+    # Options:
+    #   strict: true - raise error on unknown keys
+    #   passthrough: true - keep unknown keys in output
+    def schema(**options, &block)
+      Schema.new(**options, &block)
+    end
+
+    # Configure I18n settings
+    def configure_i18n(&block)
+      I18n.configure(&block)
+    end
+
+    # Create a validation context
+    def context(**data)
+      Context.new(**data)
+    end
+  end
+end