validrb 0.5.0

data/lib/validrb/constraints/enum.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Constraints
+    # Validates value is in an allowed list
+    class Enum < Base
+      attr_reader :allowed
+      alias values allowed
+
+      def initialize(allowed)
+        @allowed = Array(allowed).freeze
+        raise ArgumentError, "Enum requires at least one allowed value" if @allowed.empty?
+
+        super()
+      end
+
+      def valid?(input)
+        @allowed.include?(input)
+      end
+
+      def error_message(_input)
+        formatted = @allowed.map(&:inspect).join(", ")
+        "must be one of: #{formatted}"
+      end
+
+      def error_code
+        :enum
+      end
+    end
+
+    register(:enum, Enum)
+  end
+end

data/lib/validrb/constraints/format.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Constraints
+    # Validates value matches a regex or named format
+    class Format < Base
+      NAMED_FORMATS = {
+        email: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i,
+        url: %r{\Ahttps?://[^\s/$.?#].[^\s]*\z}i,
+        uuid: /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i,
+        phone: /\A\+?[\d\s\-().]{7,}\z/,
+        alphanumeric: /\A[a-zA-Z0-9]+\z/,
+        alpha: /\A[a-zA-Z]+\z/,
+        numeric: /\A\d+\z/,
+        hex: /\A[0-9a-fA-F]+\z/,
+        slug: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/
+      }.freeze
+
+      attr_reader :pattern, :format_name
+
+      def initialize(pattern)
+        @format_name = pattern.is_a?(Symbol) ? pattern : nil
+        @pattern = resolve_pattern(pattern)
+        super()
+      end
+
+      def valid?(input)
+        return false unless input.is_a?(String)
+
+        @pattern.match?(input)
+      end
+
+      def error_message(_input)
+        if @format_name
+          "must be a valid #{@format_name}"
+        else
+          "must match format #{@pattern.inspect}"
+        end
+      end
+
+      def error_code
+        :format
+      end
+
+      private
+
+      def resolve_pattern(pattern)
+        case pattern
+        when Regexp
+          pattern
+        when Symbol
+          NAMED_FORMATS.fetch(pattern) do
+            raise ArgumentError, "Unknown format: #{pattern}. Available: #{NAMED_FORMATS.keys.join(", ")}"
+          end
+        else
+          raise ArgumentError, "Format must be a Regexp or Symbol, got #{pattern.class}"
+        end
+      end
+    end
+
+    register(:format, Format)
+  end
+end

data/lib/validrb/constraints/length.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Constraints
+    # Validates exact length, range, or min/max length
+    class Length < Base
+      attr_reader :exact, :min, :max, :range
+
+      def initialize(exact: nil, min: nil, max: nil, range: nil)
+        @exact = exact
+        @min = min
+        @max = max
+        @range = range
+        validate_options!
+        super()
+      end
+
+      def valid?(input)
+        return false unless input.respond_to?(:length)
+
+        len = input.length
+
+        if @exact
+          len == @exact
+        elsif @range
+          @range.include?(len)
+        else
+          (@min.nil? || len >= @min) && (@max.nil? || len <= @max)
+        end
+      end
+
+      def error_message(input)
+        len = input.respond_to?(:length) ? input.length : "N/A"
+
+        if @exact
+          "length must be exactly #{@exact} (got #{len})"
+        elsif @range
+          "length must be between #{@range.min} and #{@range.max} (got #{len})"
+        elsif @min && @max
+          "length must be between #{@min} and #{@max} (got #{len})"
+        elsif @min
+          "length must be at least #{@min} (got #{len})"
+        else
+          "length must be at most #{@max} (got #{len})"
+        end
+      end
+
+      def error_code
+        :length
+      end
+
+      def options
+        {
+          exact: @exact,
+          min: @min,
+          max: @max,
+          range: @range
+        }.compact
+      end
+
+      private
+
+      def validate_options!
+        return if @exact || @min || @max || @range
+
+        raise ArgumentError, "Length constraint requires at least one of: exact, min, max, or range"
+      end
+    end
+
+    register(:length, Length)
+  end
+end

data/lib/validrb/constraints/max.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Constraints
+    # Validates maximum value (numbers) or maximum length (strings/arrays)
+    class Max < Base
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        super()
+      end
+
+      def valid?(input)
+        comparable_value(input) <= @value
+      end
+
+      def error_message(input)
+        if length_based?(input)
+          "length must be at most #{@value} (got #{input.length})"
+        else
+          "must be at most #{@value}"
+        end
+      end
+
+      def error_code
+        :max
+      end
+
+      private
+
+      def comparable_value(input)
+        length_based?(input) ? input.length : input
+      end
+
+      def length_based?(input)
+        input.respond_to?(:length) && !input.is_a?(Numeric)
+      end
+    end
+
+    register(:max, Max)
+  end
+end

data/lib/validrb/constraints/min.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Validrb
+  module Constraints
+    # Validates minimum value (numbers) or minimum length (strings/arrays)
+    class Min < Base
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        super()
+      end
+
+      def valid?(input)
+        comparable_value(input) >= @value
+      end
+
+      def error_message(input)
+        if length_based?(input)
+          "length must be at least #{@value} (got #{input.length})"
+        else
+          "must be at least #{@value}"
+        end
+      end
+
+      def error_code
+        :min
+      end
+
+      private
+
+      def comparable_value(input)
+        length_based?(input) ? input.length : input
+      end
+
+      def length_based?(input)
+        input.respond_to?(:length) && !input.is_a?(Numeric)
+      end
+    end
+
+    register(:min, Min)
+  end
+end

data/lib/validrb/context.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Validrb
+  # Validation context - carries additional data through the validation pipeline
+  # Useful for passing request context, current user, locale, etc.
+  class Context
+    attr_reader :data
+
+    def initialize(**data)
+      @data = data.freeze
+      freeze
+    end
+
+    def [](key)
+      @data[key.to_sym]
+    end
+
+    def key?(key)
+      @data.key?(key.to_sym)
+    end
+
+    def fetch(key, *args, &block)
+      @data.fetch(key.to_sym, *args, &block)
+    end
+
+    def to_h
+      @data.dup
+    end
+
+    # Empty context singleton
+    EMPTY = new.freeze
+
+    def self.empty
+      EMPTY
+    end
+
+    def empty?
+      @data.empty?
+    end
+  end
+end

data/lib/validrb/custom_type.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Validrb
+  # DSL for defining custom types easily
+  # Example:
+  #   Validrb.define_type(:email) do
+  #     coerce { |v| v.to_s.strip.downcase }
+  #     validate { |v| v.match?(/\A[^@\s]+@[^@\s]+\z/) }
+  #     error_message { |v| "must be a valid email address" }
+  #   end
+  module CustomType
+    class Builder
+      def initialize
+        @coercer = nil
+        @validator = nil
+        @error_message_proc = nil
+        @type_name = nil
+      end
+
+      # Define coercion logic
+      def coerce(&block)
+        @coercer = block
+      end
+
+      # Define validation logic
+      def validate(&block)
+        @validator = block
+      end
+
+      # Define custom error message
+      def error_message(&block)
+        @error_message_proc = block
+      end
+
+      # Set the type name for error messages
+      def name(type_name)
+        @type_name = type_name
+      end
+
+      def build(type_sym)
+        coercer = @coercer
+        validator = @validator
+        error_proc = @error_message_proc
+        type_name_val = @type_name || type_sym.to_s
+
+        Class.new(Types::Base) do
+          define_method(:coerce) do |value|
+            return value unless coercer
+
+            begin
+              coercer.call(value)
+            rescue StandardError
+              Types::COERCION_FAILED
+            end
+          end
+
+          define_method(:valid?) do |value|
+            return true unless validator
+
+            validator.call(value)
+          end
+
+          define_method(:type_name) do
+            type_name_val
+          end
+
+          if error_proc
+            define_method(:validation_error_message) do |value|
+              error_proc.call(value)
+            end
+
+            define_method(:coercion_error_message) do |value|
+              error_proc.call(value)
+            end
+          end
+        end
+      end
+    end
+
+    def self.define(type_sym, &block)
+      builder = Builder.new
+      builder.instance_eval(&block)
+      klass = builder.build(type_sym)
+      Types.register(type_sym, klass)
+      klass
+    end
+  end
+
+  class << self
+    # Public API for defining custom types
+    def define_type(type_sym, &block)
+      CustomType.define(type_sym, &block)
+    end
+  end
+end

data/lib/validrb/errors.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Validrb
+  # Represents a single validation error with path tracking
+  class Error
+    attr_reader :path, :message, :code
+
+    def initialize(path:, message:, code: nil)
+      @path = Array(path).freeze
+      @message = message.freeze
+      @code = code&.to_sym
+      freeze
+    end
+
+    def full_path
+      return "" if path.empty?
+
+      path.map(&:to_s).join(".")
+    end
+
+    def to_s
+      prefix = full_path.empty? ? "" : "#{full_path}: "
+      "#{prefix}#{message}"
+    end
+
+    def to_h
+      { path: path, message: message, code: code }.compact
+    end
+
+    def ==(other)
+      other.is_a?(Error) &&
+        path == other.path &&
+        message == other.message &&
+        code == other.code
+    end
+    alias eql? ==
+
+    def hash
+      [path, message, code].hash
+    end
+  end
+
+  # Collection of validation errors with utility methods
+  class ErrorCollection
+    include Enumerable
+
+    def initialize(errors = [])
+      @errors = errors.dup.freeze
+      freeze
+    end
+
+    def each(&block)
+      @errors.each(&block)
+    end
+
+    def [](index)
+      @errors[index]
+    end
+
+    def size
+      @errors.size
+    end
+    alias length size
+    alias count size
+
+    def empty?
+      @errors.empty?
+    end
+
+    def any?
+      @errors.any?
+    end
+
+    def add(error)
+      ErrorCollection.new(@errors + [error])
+    end
+
+    def merge(other)
+      ErrorCollection.new(@errors + other.to_a)
+    end
+
+    def for_path(*path)
+      path = path.flatten
+      ErrorCollection.new(@errors.select { |e| e.path[0...path.size] == path })
+    end
+
+    def messages
+      @errors.map(&:message)
+    end
+
+    def full_messages
+      @errors.map(&:to_s)
+    end
+
+    def to_a
+      @errors.dup
+    end
+
+    def to_h
+      @errors.group_by(&:full_path).transform_values { |errs| errs.map(&:message) }
+    end
+  end
+
+  # Exception raised when parse() fails validation
+  class ValidationError < StandardError
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors.is_a?(ErrorCollection) ? errors : ErrorCollection.new(Array(errors))
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      msgs = @errors.full_messages
+      return "Validation failed" if msgs.empty?
+
+      "Validation failed: #{msgs.join("; ")}"
+    end
+  end
+end