rbdantic 0.1.0

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/rbdantic/base/access.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Rbdantic
+  class BaseModel
+    # Accessor and serialization methods
+    module Access
+      def model_dump(**options)
+        Serialization::Dumper.dump(self, **options)
+      end
+
+      def model_dump_json(indent: nil, **options)
+        Serialization::JsonSerializer.dump(self, indent: indent, **options)
+      end
+
+      def model_fields_set
+        Set.new(Array(@__fields_set__))
+      end
+
+      def model_extra
+        Array(@__extra_fields__).each_with_object({}) { |name, h| h[name] = instance_variable_get("@#{name}") }
+      end
+
+      def [](name)
+        instance_variable_get("@#{name}")
+      end
+
+      def []=(name, value)
+        raise FrozenError, "cannot modify frozen #{self.class.name}" if self.class.model_config.frozen
+        self.class.fields.key?(name) ? assign_field(name, value) : assign_extra_field(name, value)
+      end
+
+      # Create a copy of the model
+      # @param deep [Boolean] if true, perform deep copy of nested models and collections
+      # @return [BaseModel] a new instance with copied values
+      def copy(deep: false)
+        attributes = deep ? deep_copy_value(model_dump) : model_dump
+        rebuild_instance(attributes, fields_set: Array(@__fields_set__), extra_fields: Array(@__extra_fields__))
+      end
+
+      # Create a new model with updated fields
+      # @param data [Hash] fields to update
+      # @return [BaseModel] a new instance with updated values
+      def update(**data)
+        candidate = self.class.new(model_dump.merge(data))
+        extra_fields = candidate.model_extra.keys
+        declared_fields = (model_fields_set - Set.new(model_extra.keys)) | Set.new(normalized_update_field_names(data))
+        fields_set = declared_fields | Set.new(extra_fields)
+
+        rebuild_instance(candidate.model_dump, fields_set: fields_set.to_a, extra_fields: extra_fields)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && model_dump == other.model_dump
+      end
+
+      alias eql? ==
+
+      def hash
+        model_dump.hash
+      end
+
+      def method_missing(name, *args, &block)
+        return model_extra[name] if args.empty? && block.nil? && model_extra.key?(name)
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        model_extra.key?(name) || super
+      end
+
+      private
+
+      def deep_copy_value(value)
+        case value
+        when BaseModel
+          value.copy(deep: true)
+        when Hash
+          value.transform_values { |v| deep_copy_value(v) }
+        when Array
+          value.map { |v| deep_copy_value(v) }
+        else
+          # Primitive types are immutable, no need to copy
+          value
+        end
+      end
+
+      def rebuild_instance(attributes, fields_set:, extra_fields:)
+        self.class.__build_instance__(attributes, fields_set: fields_set, extra_fields: extra_fields)
+      end
+
+      def normalized_update_field_names(data)
+        alias_map = self.class.fields.each_with_object({}) do |(field_name, field_info), mapping|
+          mapping[field_info.alias_name.to_sym] = field_name if field_info.alias_name
+        end
+
+        data.keys.filter_map do |key|
+          key = key.to_sym
+          self.class.fields.key?(key) ? key : alias_map[key]
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/base/dsl.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Rbdantic
+  class BaseModel
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def model_fields; @__rbdantic_fields__ ||= {}; end
+        alias fields model_fields
+
+        def field_validators; @__rbdantic_field_validators__ ||= {}; end
+        def model_validators; @__rbdantic_model_validators__ ||= []; end
+
+        def field(name, type, metadata = nil, **options)
+          field_info = FieldInfo.from_dsl(name, type, metadata, **options)
+          (@__rbdantic_fields__ ||= {})[name] = field_info
+
+          define_method(name) { instance_variable_get("@#{name}") }
+          define_method("#{name}=") do |value|
+            raise FrozenError, "cannot modify frozen #{self.class.name}" if self.class.model_config.frozen
+            assign_field(name, value)
+          end
+        end
+
+        def model_config(**options)
+          @__rbdantic_model_config__ ||= ModelConfig.new
+          options.empty? ? @__rbdantic_model_config__ : @__rbdantic_model_config__ = @__rbdantic_model_config__.with(**options)
+        end
+
+        def inherited(subclass)
+          subclass.instance_variable_set(:@__rbdantic_fields__, fields.dup)
+          subclass.instance_variable_set(:@__rbdantic_model_config__, model_config.dup)
+          subclass.instance_variable_set(:@__rbdantic_field_validators__, field_validators.each_with_object({}) do |(k, v), h|
+            h[k] = v.dup
+          end)
+          subclass.instance_variable_set(:@__rbdantic_model_validators__, model_validators.dup)
+          super
+        end
+
+        def field_validator(field_name, mode: :after, &block)
+          ((@__rbdantic_field_validators__ ||= {})[field_name] ||= []) << Validators::FieldValidator.new(field_name, 
+                                                                                                         mode: mode, &block)
+        end
+
+        def model_validator(mode: :after, &block)
+          (@__rbdantic_model_validators__ ||= []) << Validators::ModelValidator.new(mode: mode, &block)
+        end
+
+        # Rebuild model fields (useful after inheritance or dynamic changes)
+        # Re-creates field accessors and validators
+        def model_rebuild
+          fields.each do |name, _|
+            define_method(name) { instance_variable_get("@#{name}") }
+            define_method("#{name}=") do |value|
+              raise FrozenError, "cannot modify frozen #{self.class.name}" if self.class.model_config.frozen
+              assign_field(name, value)
+            end
+          end
+          true
+        end
+
+        def model_json_schema(**options); JsonSchema::Generator.generate(self, **options); end
+        def model_validate(data); new(data); end
+
+        def __build_instance__(attributes, fields_set:, extra_fields:)
+          instance = allocate
+          attributes.each { |name, value| instance.instance_variable_set("@#{name}", value) }
+          instance.instance_variable_set(:@__fields_set__, fields_set.map(&:to_sym).uniq)
+          instance.instance_variable_set(:@__extra_fields__, extra_fields.map(&:to_sym).uniq)
+          instance.freeze if model_config.frozen
+          instance
+        end
+      end
+    end
+  end
+end

data/lib/rbdantic/base/validation.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Rbdantic
+  class BaseModel
+    module Validation
+      def initialize(data = {})
+        data = normalize_attributes(data)
+        errors, processed, provided, extra, consumed = [], {}, [], [], []
+
+        # 1. Before model validators (Status Safe)
+        data = run_before_model_validators(data, errors)
+
+        # 2. Process Fields
+        validate_fields(data, processed, errors, provided, consumed)
+
+        # 3. Extra Fields
+        handle_extra_fields(data, processed, extra, errors, consumed)
+
+        raise ValidationError.new(errors) if errors.any?
+
+        # 4. Success - Set state
+        finalize_state(processed, provided, extra)
+
+        # 5. After model validators
+        run_after_model_validators(errors)
+        raise ValidationError.new(errors) if errors.any?
+        freeze if self.class.model_config.frozen
+      end
+
+      private
+
+      def run_before_model_validators(data, errors)
+        current_data = data.dup
+        self.class.model_validators.select { |v| v.mode == :before }.each do |v|
+          begin
+            result = v.call(current_data)
+            raise TypeError, "Before model validators must return a Hash" unless result.is_a?(Hash)
+            current_data = normalize_attributes(result)
+          rescue StandardError => e
+            errors << ErrorDetail.new(type: :model_validation_failed, loc: [], msg: e.message, input: current_data)
+          end
+        end
+        current_data
+      end
+
+      def validate_fields(data, processed, errors, provided, consumed)
+        self.class.fields.each do |name, field|
+          present, input_key, input_value = resolve_input(data, name, field)
+
+          if present
+            provided << name
+            consumed << input_key
+            field_errors, value = field.validate(input_value, self, build_validator_context(name, field, processed))
+            errors.concat(field_errors)
+            processed[name] = value
+          elsif field.has_default?
+            processed[name] = field.get_default
+          elsif field.required?
+            errors << ErrorDetail.new(type: :value_missing, loc: [name], msg: "Field '#{name}' is required", input: nil)
+          end
+        end
+      end
+
+      def handle_extra_fields(data, processed, extra_fields, errors, consumed)
+        (data.keys - consumed).each do |name|
+          case self.class.model_config.extra
+          when :forbid
+            errors << ErrorDetail.new(type: :extra_field_forbidden, loc: [name], 
+                                      msg: "Extra field '#{name}' is not allowed", input: data[name])
+          when :allow
+            extra_fields << name
+            processed[name] = data[name]
+          end
+        end
+      end
+
+      def finalize_state(processed, provided, extra)
+        processed.each { |name, value| instance_variable_set("@#{name}", value) }
+        @__fields_set__ = (provided + extra).uniq
+        @__extra_fields__ = extra.uniq
+      end
+
+      def run_after_model_validators(errors)
+        self.class.model_validators.select { |v| v.mode == :after }.each do |v|
+          errors.concat(v.validate(self))
+        end
+      end
+
+      def normalize_attributes(data)
+        raise ArgumentError, "BaseModel expects a Hash" unless data.is_a?(Hash)
+        data.transform_keys { |k| (k.is_a?(String) || k.is_a?(Symbol)) ? k.to_sym : k }
+      end
+
+      def resolve_input(data, name, field)
+        return [true, name, data[name]] if data.key?(name)
+
+        alias_name = field.alias_name&.to_sym
+        return [false, nil, nil] unless alias_name && data.key?(alias_name)
+
+        [true, alias_name, data[alias_name]]
+      end
+
+      def build_validator_context(name, field_info, data = {})
+        Validators::ValidatorContext.new(field_name: name, field_info: field_info, model_class: self.class, 
+                                         model_instance: self, data: data)
+      end
+
+      def assign_field(name, value)
+        field = self.class.fields[name]
+        unless self.class.model_config.validate_assignment
+          return (instance_variable_set("@#{name}", value);
+                  track_set_field(name); value)
+        end
+
+        errors, processed = field.validate(value, self, build_validator_context(name, field, current_field_data))
+        raise ValidationError.new(errors) if errors.any?
+        
+        previous = instance_variable_get("@#{name}")
+        instance_variable_set("@#{name}", processed)
+        
+        begin
+          model_errors = []
+          run_after_model_validators(model_errors)
+          raise ValidationError.new(model_errors) if model_errors.any?
+        rescue StandardError
+          instance_variable_set("@#{name}", previous)
+          raise
+        end
+        track_set_field(name)
+        processed
+      end
+
+      def assign_extra_field(name, value)
+        case self.class.model_config.extra
+        when :forbid then raise ValidationError.new([ErrorDetail.new(type: :extra_field_forbidden, loc: [name], 
+                                                                     msg: "Extra field '#{name}' is not allowed", input: value)])
+        when :allow then (instance_variable_set("@#{name}", value);
+                          track_set_field(name); track_extra_field(name); value)
+        end
+      end
+
+      def current_field_data
+        self.class.fields.keys.each_with_object({}) do |name, acc|
+          acc[name] = instance_variable_get("@#{name}") if instance_variable_defined?("@#{name}")
+        end
+      end
+
+      def track_set_field(name); (@__fields_set__ ||= []) << name unless @__fields_set__&.include?(name); end
+      def track_extra_field(name); (@__extra_fields__ ||= []) << name unless @__extra_fields__&.include?(name); end
+    end
+  end
+end

data/lib/rbdantic/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+require "set"
+
+require_relative "error_detail"
+require_relative "field"
+require_relative "config"
+require_relative "serialization/dumper"
+require_relative "serialization/json_serializer"
+require_relative "json_schema/generator"
+require_relative "json_schema/types"
+require_relative "json_schema/defs_registry"
+require_relative "validators/field_validator"
+require_relative "validators/model_validator"
+require_relative "validators/validator_context"
+require_relative "validators/types"
+require_relative "base/dsl"
+require_relative "base/validation"
+require_relative "base/access"
+
+module Rbdantic
+  # Base class for data models with field DSL and validation
+  # Similar to Pydantic BaseModel in Python
+  class BaseModel
+    include DSL
+    include Validation
+    include Access
+  end
+end

data/lib/rbdantic/config.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Rbdantic
+  # Model configuration options
+  class ModelConfig
+    VALID_EXTRA_VALUES = %i[forbid ignore allow].freeze
+    VALID_COERCE_MODES = %i[strict coerce].freeze
+
+    attr_reader :strict, :extra, :frozen, :validate_assignment, :coerce_mode
+
+    def initialize(strict: false, extra: :ignore, frozen: false, validate_assignment: true, coerce_mode: nil)
+      @coerce_mode = validate_coerce_mode!(coerce_mode || (strict ? :strict : :coerce))
+      strict = (@coerce_mode == :strict)
+      @strict = strict
+      @extra = validate_extra!(extra)
+      @frozen = frozen
+      @validate_assignment = validate_assignment
+    end
+
+    def to_h
+      {
+        strict: @strict,
+        extra: @extra,
+        frozen: @frozen,
+        validate_assignment: @validate_assignment,
+        coerce_mode: @coerce_mode
+      }
+    end
+
+    def with(**overrides)
+      merged = to_h.merge(overrides)
+
+      if overrides.key?(:strict) && !overrides.key?(:coerce_mode)
+        merged[:coerce_mode] = overrides[:strict] ? :strict : :coerce
+      elsif overrides.key?(:coerce_mode) && !overrides.key?(:strict)
+        merged[:strict] = overrides[:coerce_mode] == :strict
+      end
+
+      self.class.new(**merged)
+    end
+
+    alias merge with
+
+    private
+
+    def validate_extra!(value)
+      unless VALID_EXTRA_VALUES.include?(value)
+        raise ArgumentError, "extra must be one of #{VALID_EXTRA_VALUES.join(", ")}"
+      end
+      value
+    end
+
+    def validate_coerce_mode!(value)
+      unless VALID_COERCE_MODES.include?(value)
+        raise ArgumentError, "coerce_mode must be one of #{VALID_COERCE_MODES.join(", ")}"
+      end
+      value
+    end
+  end
+end

data/lib/rbdantic/error_detail.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rbdantic
+  # Pydantic-compatible error detail structure
+  class ErrorDetail
+    attr_reader :type, :loc, :msg, :input
+
+    def initialize(type:, loc:, msg:, input: nil)
+      @type = type
+      @loc = loc
+      @msg = msg
+      @input = input
+    end
+
+    def to_h
+      { type: @type, loc: @loc, msg: @msg, input: @input }.compact
+    end
+
+    def as_json(*)
+      to_h
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+
+  # Raised when model validation fails
+  class ValidationError < StandardError
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      super(build_message)
+    end
+
+    def error_count
+      @errors.length
+    end
+
+    def as_json(*)
+      { errors: @errors.map(&:as_json), error_count: error_count }
+    end
+
+    alias to_h as_json
+
+    private
+
+    def build_message
+      "#{error_count} validation error(s):\n" +
+        @errors.map { |e| "  - #{e.loc.join(".")}: #{e.msg}" }.join("\n")
+    end
+  end
+end

data/lib/rbdantic/field.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative "validators/types"
+
+module Rbdantic
+  # FieldInfo: Stores field metadata and handles validation pipeline
+  class FieldInfo
+    UNSET = Object.new.freeze
+
+    attr_reader :name, :type, :constraints, :default, :default_factory,
+                :optional, :validators, :default_provided, :type_validator,
+                :alias_name
+
+    CONSTRAINT_KEYS = %i[
+      min_length max_length gt ge lt le pattern format
+      min_items max_items unique_items element_type multiple_of
+      min_properties max_properties
+    ].freeze
+
+    def self.from_dsl(name, type, metadata = nil, **options)
+      meta = case metadata
+             when nil then {}
+             when FieldInfo then { default: metadata.default, default_factory: metadata.default_factory,
+                                   optional: metadata.optional, validators: metadata.validators,
+                                   alias_name: metadata.alias_name, **metadata.constraints }
+             when Hash then metadata
+             else raise ArgumentError, "field metadata must be a Rbdantic::FieldInfo or Hash"
+             end
+
+      opts = meta.merge(options)
+      type, opts = normalize_type(type, opts)
+      new(name: name, type: type, **opts)
+    end
+
+    def self.normalize_type(type, options)
+      return [Array, options.merge(element_type: type.first)] if type.is_a?(Array) && type.length == 1
+      [type, options]
+    end
+
+    def initialize(name: nil, type: nil, default: UNSET, default_factory: nil,
+                   optional: nil, required: nil, validators: nil, alias_name: nil, **constraints)
+      @name = name
+      @type = type
+      @alias_name = alias_name
+      @default = default.equal?(UNSET) ? nil : default
+      @default_provided = !default.equal?(UNSET)
+      @default_factory = default_factory
+      @optional = required == false ? true : (optional || false)
+      @validators = validators || []
+      validate_constraint_keys!(constraints)
+      @constraints = constraints.slice(*CONSTRAINT_KEYS).freeze
+
+      validate_mutable_default! if @default_provided && !@default_factory
+      validate_constraint_compatibility! if @type
+      @type_validator = Validators::Types.create_validator(@type, **@constraints)
+    end
+
+    def has_default?; @default_provided || !@default_factory.nil?; end
+    def get_default; @default_factory ? @default_factory.call : @default; end
+    def required?; !@optional && !has_default?; end
+
+    # Main validation entry point
+    # @param value the value to validate
+    # @param model_instance the model instance being validated
+    # @param context [ValidatorContext] validation context
+    # @return [Array<ErrorDetail>, value] tuple of errors and validated value
+    def validate(value, model_instance, context)
+      return handle_nil_value if value.nil?
+
+      strict = model_instance.class.model_config.strict
+      custom_validators = model_instance.class.field_validators[@name] || []
+
+      errors, value = run_before_validators(value, custom_validators, context)
+      return [errors, value] if errors.any?
+
+      run_main_validation(value, custom_validators, context, strict)
+    end
+
+    private
+
+    # Handle nil values - either allow (optional) or error (required)
+    def handle_nil_value
+      return [[], nil] if @optional
+      [[required_error, nil]]
+    end
+
+    def required_error
+      ErrorDetail.new(type: :type_error, loc: [@name], msg: "Field is required", input: nil)
+    end
+
+    # Run before validators, return errors and potentially transformed value
+    def run_before_validators(value, custom_validators, context)
+      apply_validators_by_mode(value, custom_validators, :before, context)
+    end
+
+    # Main validation: wrap -> plain -> core (in priority order)
+    def run_main_validation(value, custom_validators, context, strict)
+      base_handler = if custom_validators.any? { |validator| validator.mode == :plain }
+                       ->(current_value) { apply_validators_by_mode(current_value, custom_validators, :plain, context) }
+                     else
+                       ->(current_value) { run_core_validation(current_value, custom_validators, context, strict) }
+                     end
+
+      wrap_validators = custom_validators.select { |validator| validator.mode == :wrap }
+      return base_handler.call(value) if wrap_validators.empty?
+
+      handler = wrap_validators.reduce(base_handler) do |next_handler, validator|
+        ->(current_value) { validator.apply(current_value, context, next_handler) }
+      end
+
+      handler.call(value)
+    end
+
+    # Core validation: type -> proc -> after
+    def run_core_validation(value, custom_validators, context, strict)
+      errors, value = run_type_validation(value, strict)
+      return [errors, value] if errors.any?
+
+      errors = run_proc_validators(value)
+      return [errors, value] if errors.any?
+
+      apply_validators_by_mode(value, custom_validators, :after, context)
+    end
+
+    def run_type_validation(value, strict)
+      return [[], value] unless @type_validator
+      @type_validator.validate(value, [@name], strict: strict)
+    end
+
+    def run_proc_validators(value)
+      @validators.each_with_object([]) do |v, errs|
+        next unless v.is_a?(Proc) || v.is_a?(Method)
+        result = v.call(value)
+        errs << proc_error(value, result) if proc_failed?(result)
+      end
+    end
+
+    def proc_failed?(result)
+      result == false || result.is_a?(String)
+    end
+
+    def proc_error(value, result)
+      msg = result.is_a?(String) ? result : "Custom validation failed"
+      ErrorDetail.new(type: :validation_failed, loc: [@name], msg: msg, input: value)
+    end
+
+    def apply_validators_by_mode(value, validators, mode, context)
+      errors, current = [], value
+      validators.select { |v| v.mode == mode }.each do |v|
+        errs, transformed = v.apply(current, context)
+        errors.concat(errs)
+        current = transformed if errs.empty?
+      end
+      [errors, current]
+    end
+
+    def validate_mutable_default!
+      return unless @default.is_a?(::Array) || @default.is_a?(::Hash)
+      raise ArgumentError, "Mutable default '#{@default.class.name}' detected for field '#{@name}'. " \
+                           "Use `default_factory` to avoid shared state."
+    end
+
+    def validate_constraint_keys!(constraints)
+      unknown = constraints.keys - CONSTRAINT_KEYS
+      return if unknown.empty?
+
+      raise ArgumentError, "Unknown constraint(s) for field '#{@name}': #{unknown.join(", ")}"
+    end
+
+    def validate_constraint_compatibility!
+      if @constraints.key?(:multiple_of) && @constraints[:multiple_of].to_f.zero?
+        raise ArgumentError, "multiple_of must not be 0"
+      end
+
+      return unless @constraints[:format]
+      return if @type == ::String && Validators::Types::String::FORMAT_PATTERNS.key?(@constraints[:format])
+
+      if @type == ::String
+        raise ArgumentError, "Unsupported format '#{@constraints[:format]}' for field '#{@name}'"
+      end
+
+      raise ArgumentError, "format is only supported for String fields"
+    end
+  end
+
+  Field = FieldInfo
+  def self.Field(**options); FieldInfo.new(**options); end
+end