validrb 0.5.0

data/lib/validrb/field.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+module Validrb
+  # Represents a field definition with type, constraints, and options
+  class Field
+    # Sentinel for missing values (distinguishes from nil)
+    MISSING = Object.new.tap do |obj|
+      def obj.inspect
+        "MISSING"
+      end
+
+      def obj.to_s
+        "MISSING"
+      end
+    end.freeze
+
+    attr_reader :name, :type, :constraints, :options, :refinements
+
+    def initialize(name, type, **options)
+      @name = name.to_sym
+      @type = resolve_type(type, options)
+      @constraints = build_constraints(options)
+      @refinements = build_refinements(options)
+      @options = extract_options(options)
+      @transform = options[:transform]
+      @preprocess = options[:preprocess]
+      @message = options[:message]
+      @coerce = options.fetch(:coerce, true)
+      @when_condition = options[:when]
+      @unless_condition = options[:unless]
+      freeze
+    end
+
+    def optional?
+      @options[:optional] == true
+    end
+
+    def required?
+      !optional?
+    end
+
+    def nullable?
+      @options[:nullable] == true
+    end
+
+    def has_default?
+      @options.key?(:default)
+    end
+
+    def default_value
+      value = @options[:default]
+      value.respond_to?(:call) ? value.call : value
+    end
+
+    def conditional?
+      !@when_condition.nil? || !@unless_condition.nil?
+    end
+
+    # Validate a value for this field
+    # Returns [coerced_value, errors_array]
+    # @param value - the value to validate
+    # @param path - the path prefix for error messages
+    # @param data - the full input data (for conditional validation)
+    # @param context - optional validation context
+    def call(value, path: [], data: nil, context: nil)
+      field_path = path + [@name]
+
+      # Check conditional validation (when:/unless:)
+      if conditional? && !should_validate?(data, context)
+        # Skip validation - treat as optional
+        return [nil, []] if value.equal?(MISSING) || value.nil?
+
+        # Still process the value if present (preprocess + transform)
+        value = apply_preprocess(value, context) unless value.equal?(MISSING)
+        return [apply_transform(value, context), []]
+      end
+
+      # Handle missing values
+      if value.equal?(MISSING)
+        return handle_missing_value(field_path, context)
+      end
+
+      # Apply preprocessing BEFORE type coercion
+      value = apply_preprocess(value, context)
+
+      # Handle nil values - nullable fields accept nil
+      if value.nil?
+        return [nil, []] if nullable?
+
+        return handle_missing_value(field_path, context)
+      end
+
+      # Type coercion and validation
+      coerced, type_errors = coerce_value(value, field_path)
+      return [nil, apply_custom_message(type_errors)] unless type_errors.empty?
+
+      # Constraint validation
+      constraint_errors = validate_constraints(coerced, field_path)
+      return [nil, apply_custom_message(constraint_errors)] unless constraint_errors.empty?
+
+      # Refinement validation
+      refinement_errors = validate_refinements(coerced, field_path, context)
+      return [nil, apply_custom_message(refinement_errors)] unless refinement_errors.empty?
+
+      # Apply transform if present
+      coerced = apply_transform(coerced, context)
+
+      [coerced, []]
+    end
+
+    private
+
+    def resolve_type(type, options)
+      # Handle literal types
+      if options[:literal]
+        return Types::Literal.new(values: options[:literal])
+      end
+
+      # Handle union types
+      if options[:union]
+        return Types::Union.new(types: options[:union])
+      end
+
+      case type
+      when Symbol
+        type_options = extract_type_options(type, options)
+        Types.build(type, **type_options)
+      when Types::Base
+        type
+      when Class
+        type.new
+      else
+        raise ArgumentError, "Invalid type: #{type.inspect}"
+      end
+    end
+
+    def extract_type_options(type, options)
+      case type
+      when :array
+        { of: options[:of] }.compact
+      when :object, :hash
+        { schema: options[:schema] }.compact
+      when :discriminated_union
+        {
+          discriminator: options[:discriminator],
+          mapping: options[:mapping]
+        }.compact
+      else
+        {}
+      end
+    end
+
+    def build_constraints(options)
+      constraints = []
+
+      # Min constraint
+      constraints << Constraints::Min.new(options[:min]) if options.key?(:min)
+
+      # Max constraint
+      constraints << Constraints::Max.new(options[:max]) if options.key?(:max)
+
+      # Length constraint
+      if options.key?(:length)
+        length_opts = options[:length]
+        case length_opts
+        when Integer
+          constraints << Constraints::Length.new(exact: length_opts)
+        when Range
+          constraints << Constraints::Length.new(range: length_opts)
+        when Hash
+          constraints << Constraints::Length.new(**length_opts)
+        end
+      end
+
+      # Format constraint
+      constraints << Constraints::Format.new(options[:format]) if options.key?(:format)
+
+      # Enum constraint
+      constraints << Constraints::Enum.new(options[:enum]) if options.key?(:enum)
+
+      constraints.freeze
+    end
+
+    def build_refinements(options)
+      refinements = []
+
+      # Handle refine: option (single or array of procs/hashes)
+      if options.key?(:refine)
+        refine_opts = options[:refine]
+        # Normalize to array - be careful with Hash (don't use Array())
+        refine_opts = [refine_opts] unless refine_opts.is_a?(::Array)
+
+        refine_opts.each do |refine_opt|
+          case refine_opt
+          when Proc
+            refinements << { check: refine_opt, message: "failed refinement" }
+          when Hash
+            refinements << {
+              check: refine_opt[:check] || refine_opt[:if],
+              message: refine_opt[:message] || "failed refinement"
+            }
+          end
+        end
+      end
+
+      refinements.freeze
+    end
+
+    def extract_options(options)
+      {
+        optional: options[:optional] || false,
+        nullable: options[:nullable] || false,
+        default: options[:default]
+      }.tap { |h| h.delete(:default) unless options.key?(:default) }.freeze
+    end
+
+    def handle_missing_value(path, context = nil)
+      # Apply default if present
+      if has_default?
+        value = default_value
+        value = apply_preprocess(value, context) if @preprocess
+        value = apply_transform(value, context) if @transform
+        return [value, []]
+      end
+
+      # Optional fields can be missing
+      if optional?
+        return [nil, []]
+      end
+
+      # Required field is missing
+      message = @message || I18n.t(:required)
+      error = Error.new(path: path, message: message, code: :required)
+      [nil, [error]]
+    end
+
+    def validate_constraints(value, path)
+      errors = []
+      @constraints.each do |constraint|
+        constraint_errors = constraint.call(value, path: path)
+        errors.concat(constraint_errors)
+      end
+      errors
+    end
+
+    def validate_refinements(value, path, context = nil)
+      errors = []
+      @refinements.each do |refinement|
+        check = refinement[:check]
+        # Support context-aware refinements (2 or 3 args)
+        result = if check.arity == 1
+                   check.call(value)
+                 elsif check.arity == 2
+                   check.call(value, context)
+                 else
+                   check.call(value, context)
+                 end
+
+        unless result
+          message = refinement[:message]
+          message = message.call(value) if message.respond_to?(:call)
+          errors << Error.new(path: path, message: message, code: :refinement)
+        end
+      end
+      errors
+    end
+
+    def apply_custom_message(errors)
+      return errors unless @message
+
+      errors.map do |error|
+        Error.new(path: error.path, message: @message, code: error.code)
+      end
+    end
+
+    def apply_transform(value, context = nil)
+      return value unless @transform
+
+      # Support context-aware transforms
+      if @transform.arity == 1
+        @transform.call(value)
+      else
+        @transform.call(value, context)
+      end
+    end
+
+    def apply_preprocess(value, context = nil)
+      return value unless @preprocess
+
+      # Support context-aware preprocessing
+      if @preprocess.arity == 1
+        @preprocess.call(value)
+      else
+        @preprocess.call(value, context)
+      end
+    end
+
+    def coerce_value(value, path)
+      if @coerce
+        @type.call(value, path: path)
+      else
+        # No coercion - just validate the type
+        if @type.valid?(value)
+          [value, []]
+        else
+          [nil, [Error.new(path: path, message: @type.validation_error_message(value), code: :type_error)]]
+        end
+      end
+    end
+
+    def should_validate?(data, context = nil)
+      return true if data.nil?
+
+      # Check when: condition
+      if @when_condition
+        result = evaluate_condition(@when_condition, data, context)
+        return false unless result
+      end
+
+      # Check unless: condition
+      if @unless_condition
+        result = evaluate_condition(@unless_condition, data, context)
+        return false if result
+      end
+
+      true
+    end
+
+    def evaluate_condition(condition, data, context = nil)
+      case condition
+      when Proc
+        # Support context-aware conditions
+        if condition.arity == 1
+          condition.call(data)
+        else
+          condition.call(data, context)
+        end
+      when Symbol
+        # Symbol refers to a field value being truthy
+        !!data[condition]
+      else
+        !!condition
+      end
+    end
+  end
+end

data/lib/validrb/i18n.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Validrb
+  # Simple I18n module for error message translations
+  # Can be configured to use Rails I18n or custom translations
+  module I18n
+    class << self
+      attr_accessor :backend
+
+      # Default English translations
+      DEFAULT_TRANSLATIONS = {
+        en: {
+          required: "is required",
+          type_error: "is invalid",
+          min: "must be at least %{value}",
+          min_length: "length must be at least %{value} (got %{actual})",
+          max: "must be at most %{value}",
+          max_length: "length must be at most %{value} (got %{actual})",
+          length_exact: "length must be exactly %{value} (got %{actual})",
+          length_range: "length must be between %{min} and %{max} (got %{actual})",
+          format: "must match format %{pattern}",
+          format_named: "must be a valid %{name}",
+          enum: "must be one of: %{values}",
+          unknown_key: "is not allowed",
+          union_type_error: "must be one of the allowed types"
+        }
+      }.freeze
+
+      # Current locale
+      def locale
+        @locale ||= :en
+      end
+
+      def locale=(loc)
+        @locale = loc.to_sym
+      end
+
+      # Custom translations storage
+      def translations
+        @translations ||= deep_dup(DEFAULT_TRANSLATIONS)
+      end
+
+      # Add or override translations for a locale
+      def add_translations(locale, trans)
+        translations[locale.to_sym] ||= {}
+        translations[locale.to_sym].merge!(trans)
+      end
+
+      # Translate a key with optional interpolations
+      def t(key, **options)
+        # If using Rails I18n backend
+        if backend == :rails && defined?(::I18n)
+          return ::I18n.t("validrb.errors.#{key}", **options, default: key.to_s)
+        end
+
+        # Use built-in translations
+        message = translations.dig(locale, key) || translations.dig(:en, key) || key.to_s
+
+        # Interpolate values
+        options.each do |k, v|
+          message = message.gsub("%{#{k}}", v.to_s)
+        end
+
+        message
+      end
+
+      # Reset to defaults
+      def reset!
+        @locale = :en
+        @translations = deep_dup(DEFAULT_TRANSLATIONS)
+        @backend = nil
+      end
+
+      # Configure the I18n module
+      def configure
+        yield self
+      end
+
+      private
+
+      def deep_dup(hash)
+        hash.transform_values do |v|
+          v.is_a?(Hash) ? deep_dup(v) : v.dup
+        end
+      end
+    end
+  end
+end

data/lib/validrb/introspection.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Validrb
+  # Schema introspection methods
+  class Schema
+    # Get field names
+    def field_names
+      @fields.keys
+    end
+
+    # Get a field by name
+    def field(name)
+      @fields[name.to_sym]
+    end
+
+    # Check if field exists
+    def field?(name)
+      @fields.key?(name.to_sym)
+    end
+
+    # Get required field names (excludes fields with defaults since they won't fail validation)
+    def required_fields
+      @fields.select { |_, f| f.required? && !f.conditional? && !f.has_default? }.keys
+    end
+
+    # Get optional field names
+    def optional_fields
+      @fields.select { |_, f| f.optional? }.keys
+    end
+
+    # Get conditional field names
+    def conditional_fields
+      @fields.select { |_, f| f.conditional? }.keys
+    end
+
+    # Get fields with defaults
+    def fields_with_defaults
+      @fields.select { |_, f| f.has_default? }.keys
+    end
+
+    # Get schema structure as a hash (for documentation/debugging)
+    def to_schema_hash
+      {
+        fields: @fields.transform_values { |f| field_to_hash(f) },
+        options: @options,
+        validators_count: @validators.size
+      }
+    end
+
+    # Generate JSON Schema (subset of JSON Schema Draft-07)
+    def to_json_schema
+      {
+        "$schema" => "https://json-schema.org/draft-07/schema#",
+        "type" => "object",
+        "properties" => @fields.transform_values { |f| field_to_json_schema(f) }.transform_keys(&:to_s),
+        "required" => required_fields.map(&:to_s),
+        "additionalProperties" => @options[:passthrough] || !@options[:strict]
+      }
+    end
+
+    private
+
+    def field_to_hash(field)
+      {
+        type: field.type.type_name,
+        optional: field.optional?,
+        nullable: field.nullable?,
+        has_default: field.has_default?,
+        conditional: field.conditional?,
+        constraints: field.constraints.map { |c| constraint_to_hash(c) }
+      }
+    end
+
+    def constraint_to_hash(constraint)
+      case constraint
+      when Constraints::Min
+        { type: :min, value: constraint.value }
+      when Constraints::Max
+        { type: :max, value: constraint.value }
+      when Constraints::Length
+        { type: :length, options: constraint.options }
+      when Constraints::Format
+        { type: :format, pattern: constraint.pattern.to_s }
+      when Constraints::Enum
+        { type: :enum, values: constraint.values }
+      else
+        { type: constraint.class.name }
+      end
+    end
+
+    def field_to_json_schema(field)
+      schema = {}
+
+      # Map type to JSON Schema type
+      type_mapping = type_to_json_schema(field.type)
+      schema.merge!(type_mapping)
+
+      # Handle nullable
+      if field.nullable?
+        if schema["type"].is_a?(::Array)
+          schema["type"] << "null" unless schema["type"].include?("null")
+        elsif schema["type"]
+          schema["type"] = [schema["type"], "null"]
+        end
+      end
+
+      # Handle default
+      schema["default"] = field.default_value if field.has_default?
+
+      # Handle constraints
+      field.constraints.each do |constraint|
+        case constraint
+        when Constraints::Min
+          if %w[integer number].include?(schema["type"]) || (schema["type"].is_a?(::Array) && (schema["type"] & %w[integer number]).any?)
+            schema["minimum"] = constraint.value
+          else
+            schema["minLength"] = constraint.value
+          end
+        when Constraints::Max
+          if %w[integer number].include?(schema["type"]) || (schema["type"].is_a?(::Array) && (schema["type"] & %w[integer number]).any?)
+            schema["maximum"] = constraint.value
+          else
+            schema["maxLength"] = constraint.value
+          end
+        when Constraints::Length
+          opts = constraint.options
+          schema["minLength"] = opts[:min] if opts[:min]
+          schema["maxLength"] = opts[:max] if opts[:max]
+          if opts[:exact]
+            schema["minLength"] = opts[:exact]
+            schema["maxLength"] = opts[:exact]
+          end
+        when Constraints::Format
+          # Only add pattern for regex formats
+          schema["pattern"] = constraint.pattern.source if constraint.pattern.is_a?(Regexp)
+        when Constraints::Enum
+          schema["enum"] = constraint.values
+        end
+      end
+
+      schema
+    end
+
+    def type_to_json_schema(type)
+      case type
+      when Types::String
+        { "type" => "string" }
+      when Types::Integer
+        { "type" => "integer" }
+      when Types::Float, Types::Decimal
+        { "type" => "number" }
+      when Types::Boolean
+        { "type" => "boolean" }
+      when Types::Array
+        schema = { "type" => "array" }
+        schema["items"] = type_to_json_schema(type.item_type) if type.respond_to?(:item_type) && type.item_type
+        schema
+      when Types::Object
+        if type.respond_to?(:schema) && type.schema
+          type.schema.to_json_schema.tap { |s| s.delete("$schema") }
+        else
+          { "type" => "object" }
+        end
+      when Types::Date, Types::DateTime, Types::Time
+        { "type" => "string", "format" => "date-time" }
+      when Types::Union
+        { "oneOf" => type.types.map { |t| type_to_json_schema(t) } }
+      when Types::Literal
+        { "enum" => type.values }
+      else
+        { "type" => "string" }
+      end
+    end
+  end
+
+  # Field introspection
+  class Field
+    # Get constraint by type
+    def constraint(type)
+      @constraints.find { |c| c.is_a?(type) }
+    end
+
+    # Check if field has a specific constraint type
+    def has_constraint?(type)
+      @constraints.any? { |c| c.is_a?(type) }
+    end
+
+    # Get all constraint values as a hash
+    def constraint_values
+      @constraints.each_with_object({}) do |c, hash|
+        case c
+        when Constraints::Min
+          hash[:min] = c.value
+        when Constraints::Max
+          hash[:max] = c.value
+        when Constraints::Length
+          hash[:length] = c.options
+        when Constraints::Format
+          hash[:format] = c.pattern
+        when Constraints::Enum
+          hash[:enum] = c.values
+        end
+      end
+    end
+  end
+end