anyvali 0.0.1

data/lib/anyvali/schemas/intersection_schema.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class IntersectionSchema < Schema
+    attr_reader :all_of_schemas
+
+    def initialize(all_of:, **kwargs)
+      @all_of_schemas = all_of.freeze
+      super(kind: "intersection", **kwargs)
+    end
+
+    def to_node
+      node = super
+      node["allOf"] = @all_of_schemas.map(&:to_node)
+      node
+    end
+
+    def safe_parse(input, path: [], context: nil)
+      context ||= ValidationContext.new
+      all_issues = []
+      merged_output = nil
+
+      @all_of_schemas.each do |schema|
+        result = schema.safe_parse(input, path: path, context: context)
+        if result.failure?
+          all_issues.concat(result.issues)
+        else
+          if merged_output.nil?
+            merged_output = result.value
+          elsif merged_output.is_a?(Hash) && result.value.is_a?(Hash)
+            merged_output = merged_output.merge(result.value)
+          else
+            merged_output = result.value
+          end
+        end
+      end
+
+      if all_issues.empty?
+        ParseResult.new(value: merged_output, issues: [])
+      else
+        ParseResult.new(value: nil, issues: all_issues)
+      end
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      # Handled in safe_parse override
+    end
+
+    def dup_with(**overrides)
+      all_of = overrides.delete(:all_of) || @all_of_schemas
+      attrs = {
+        all_of: all_of,
+        kind: @kind,
+        constraints: @constraints,
+        coerce_config: @coerce_config,
+        default_value: @default_value,
+        has_default: @has_default,
+        custom_validators: @custom_validators
+      }.merge(overrides)
+      self.class.new(**attrs)
+    end
+  end
+end

data/lib/anyvali/schemas/literal_schema.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class LiteralSchema < Schema
+    attr_reader :literal_value
+
+    def initialize(value:, **kwargs)
+      @literal_value = value
+      super(kind: "literal", **kwargs)
+    end
+
+    def to_node
+      node = super
+      node["value"] = @literal_value
+      node
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      # Strict equality: must be same type and value
+      unless value.class == @literal_value.class && value == @literal_value
+        # Special case: nil comparisons
+        if @literal_value.nil? && value.nil?
+          return
+        end
+        # Handle Integer/Float comparisons: both are "number" but Integer 42 != Float 42.0 for literal
+        expected_str = @literal_value.nil? ? "null" : @literal_value.to_s
+        received_str = value.nil? ? "null" : value.to_s
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_LITERAL,
+          path: path,
+          expected: expected_str,
+          received: received_str
+        )
+      end
+    end
+
+    def dup_with(**overrides)
+      attrs = {
+        value: @literal_value,
+        kind: @kind,
+        constraints: @constraints,
+        coerce_config: @coerce_config,
+        default_value: @default_value,
+        has_default: @has_default,
+        custom_validators: @custom_validators
+      }.merge(overrides)
+      self.class.new(**attrs)
+    end
+  end
+end

data/lib/anyvali/schemas/never_schema.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class NeverSchema < Schema
+    def initialize(**kwargs)
+      super(kind: "never", **kwargs)
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      issues << ValidationIssue.new(
+        code: IssueCodes::INVALID_TYPE,
+        path: path,
+        expected: "never",
+        received: Schema.type_name(value)
+      )
+    end
+  end
+end

data/lib/anyvali/schemas/null_schema.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class NullSchema < Schema
+    def initialize(**kwargs)
+      super(kind: "null", **kwargs)
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      unless value.nil?
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: "null",
+          received: Schema.type_name(value)
+        )
+      end
+    end
+  end
+end

data/lib/anyvali/schemas/nullable_schema.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class NullableSchema < Schema
+    attr_reader :inner_schema
+
+    def initialize(schema:, **kwargs)
+      @inner_schema = schema
+      super(kind: "nullable", **kwargs)
+    end
+
+    def to_node
+      node = super
+      node["schema"] = @inner_schema.to_node
+      node
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      return if value.nil?
+      result = @inner_schema.safe_parse(value, path: path, context: context)
+      issues.concat(result.issues) if result.failure?
+    end
+
+    def dup_with(**overrides)
+      schema = overrides.delete(:schema) || @inner_schema
+      attrs = {
+        schema: schema,
+        kind: @kind,
+        constraints: @constraints,
+        coerce_config: @coerce_config,
+        default_value: @default_value,
+        has_default: @has_default,
+        custom_validators: @custom_validators
+      }.merge(overrides)
+      self.class.new(**attrs)
+    end
+  end
+end

data/lib/anyvali/schemas/number_schema.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class NumberSchema < Schema
+    FLOAT_KINDS = %w[number float32 float64].freeze
+    INT_KINDS = %w[int int8 int16 int32 int64 uint8 uint16 uint32 uint64].freeze
+
+    INT_RANGES = {
+      "int8"   => [-128, 127],
+      "int16"  => [-32_768, 32_767],
+      "int32"  => [-2_147_483_648, 2_147_483_647],
+      "int64"  => [-9_223_372_036_854_775_808, 9_223_372_036_854_775_807],
+      "uint8"  => [0, 255],
+      "uint16" => [0, 65_535],
+      "uint32" => [0, 4_294_967_295],
+      "uint64" => [0, 18_446_744_073_709_551_615],
+      "int"    => [-9_223_372_036_854_775_808, 9_223_372_036_854_775_807]
+    }.freeze
+
+    FLOAT32_MAX = 3.4028235e+38
+
+    def initialize(kind: "number", constraints: {}, **kwargs)
+      super(kind: kind, constraints: constraints, **kwargs)
+    end
+
+    def min(n)
+      dup_with(constraints: @constraints.merge("min" => n))
+    end
+
+    def max(n)
+      dup_with(constraints: @constraints.merge("max" => n))
+    end
+
+    def exclusive_min(n)
+      dup_with(constraints: @constraints.merge("exclusiveMin" => n))
+    end
+
+    def exclusive_max(n)
+      dup_with(constraints: @constraints.merge("exclusiveMax" => n))
+    end
+
+    def multiple_of(n)
+      dup_with(constraints: @constraints.merge("multipleOf" => n))
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      int_kind = INT_KINDS.include?(@kind)
+      float_kind = FLOAT_KINDS.include?(@kind)
+
+      if int_kind
+        validate_int(value, path, issues)
+      elsif float_kind
+        validate_float(value, path, issues)
+      end
+    end
+
+    private
+
+    def validate_int(value, path, issues)
+      # Must be numeric
+      unless value.is_a?(Integer) || value.is_a?(Float)
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: @kind,
+          received: Schema.type_name(value)
+        )
+        return
+      end
+
+      # Must be a whole number
+      if value.is_a?(Float) && value != value.floor
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: @kind,
+          received: "number"
+        )
+        return
+      end
+
+      int_val = value.is_a?(Float) ? value.to_i : value
+
+      # Width range check
+      if INT_RANGES.key?(@kind)
+        min_val, max_val = INT_RANGES[@kind]
+        if int_val < min_val
+          issues << ValidationIssue.new(
+            code: IssueCodes::TOO_SMALL,
+            path: path,
+            expected: @kind,
+            received: int_val.to_s
+          )
+          return
+        end
+        if int_val > max_val
+          issues << ValidationIssue.new(
+            code: IssueCodes::TOO_LARGE,
+            path: path,
+            expected: @kind,
+            received: int_val.to_s
+          )
+          return
+        end
+      end
+
+      validate_numeric_constraints(int_val, path, issues)
+    end
+
+    def validate_float(value, path, issues)
+      unless value.is_a?(Numeric) && !value.is_a?(Complex)
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: @kind,
+          received: Schema.type_name(value)
+        )
+        return
+      end
+
+      # For booleans (true/false are not Numeric in Ruby, so this is fine)
+      if value == true || value == false
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: @kind,
+          received: "boolean"
+        )
+        return
+      end
+
+      # float32 range check
+      if @kind == "float32"
+        fval = value.to_f
+        if fval.abs > FLOAT32_MAX && !fval.infinite?
+          issues << ValidationIssue.new(
+            code: IssueCodes::TOO_LARGE,
+            path: path,
+            expected: "float32",
+            received: value.to_s
+          )
+          return
+        end
+      end
+
+      validate_numeric_constraints(value, path, issues)
+    end
+
+    def validate_numeric_constraints(value, path, issues)
+      if @constraints["min"] && value < @constraints["min"]
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_SMALL,
+          path: path,
+          expected: @constraints["min"].to_s,
+          received: value.to_s
+        )
+      end
+
+      if @constraints["max"] && value > @constraints["max"]
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_LARGE,
+          path: path,
+          expected: @constraints["max"].to_s,
+          received: value.to_s
+        )
+      end
+
+      if @constraints["exclusiveMin"] && value <= @constraints["exclusiveMin"]
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_SMALL,
+          path: path,
+          expected: @constraints["exclusiveMin"].to_s,
+          received: value.to_s
+        )
+      end
+
+      if @constraints["exclusiveMax"] && value >= @constraints["exclusiveMax"]
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_LARGE,
+          path: path,
+          expected: @constraints["exclusiveMax"].to_s,
+          received: value.to_s
+        )
+      end
+
+      if @constraints["multipleOf"]
+        divisor = @constraints["multipleOf"]
+        remainder = value.to_f % divisor.to_f
+        unless remainder.abs < 1e-10 || (divisor.to_f - remainder.abs).abs < 1e-10
+          issues << ValidationIssue.new(
+            code: IssueCodes::INVALID_NUMBER,
+            path: path,
+            expected: divisor.to_s,
+            received: value.to_s
+          )
+        end
+      end
+    end
+
+    def dup_with(**overrides)
+      attrs = {
+        kind: @kind,
+        constraints: @constraints,
+        coerce_config: @coerce_config,
+        default_value: @default_value,
+        has_default: @has_default,
+        custom_validators: @custom_validators
+      }.merge(overrides)
+      self.class.new(**attrs)
+    end
+  end
+end

data/lib/anyvali/schemas/object_schema.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class ObjectSchema < Schema
+    attr_reader :properties, :required_keys, :unknown_keys
+
+    def initialize(properties:, required: [], unknown_keys: "reject", **kwargs)
+      @properties = properties.freeze
+      @required_keys = required.freeze
+      @unknown_keys = unknown_keys
+      super(kind: "object", **kwargs)
+    end
+
+    def strict
+      dup_with(unknown_keys: "reject")
+    end
+
+    def strip_unknown
+      dup_with(unknown_keys: "strip")
+    end
+
+    def allow_unknown
+      dup_with(unknown_keys: "allow")
+    end
+
+    def to_node
+      node = super
+      props = {}
+      @properties.each do |k, v|
+        props[k] = v.to_node
+      end
+      node["properties"] = props
+      node["required"] = @required_keys
+      node["unknownKeys"] = @unknown_keys
+      node
+    end
+
+    def safe_parse(input, path: [], context: nil)
+      context ||= ValidationContext.new
+      issues = []
+
+      unless input.is_a?(Hash)
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: "object",
+          received: Schema.type_name(input)
+        )
+        return ParseResult.new(value: nil, issues: issues)
+      end
+
+      output = {}
+
+      # Check required fields
+      @required_keys.each do |key|
+        unless input.key?(key)
+          prop_schema = @properties[key]
+          expected = prop_schema ? prop_schema.kind : "unknown"
+          issues << ValidationIssue.new(
+            code: IssueCodes::REQUIRED,
+            path: path + [key],
+            expected: expected,
+            received: "undefined"
+          )
+        end
+      end
+
+      # Validate known properties
+      @properties.each do |key, prop_schema|
+        if input.key?(key)
+          # Value is present
+          val = input[key]
+
+          # Handle default on property schema (value is present, don't apply default)
+          result = prop_schema.safe_parse(val, path: path + [key], context: context)
+          if result.success?
+            output[key] = result.value
+          else
+            issues.concat(result.issues)
+          end
+        elsif prop_schema.has_default
+          # Apply default
+          default_val = prop_schema.default_value
+          # Validate the default value
+          result = prop_schema.safe_parse(default_val, path: path + [key], context: context)
+          if result.success?
+            output[key] = result.value
+          else
+            # Default is invalid
+            issues << ValidationIssue.new(
+              code: IssueCodes::DEFAULT_INVALID,
+              path: path + [key],
+              expected: result.issues.first&.expected || prop_schema.kind,
+              received: default_val.to_s
+            )
+          end
+        elsif prop_schema.is_a?(OptionalSchema)
+          # Optional field absent - OK
+        elsif !@required_keys.include?(key)
+          # Non-required field absent without default - OK
+        end
+      end
+
+      # Handle unknown keys
+      unknown = input.keys - @properties.keys
+      case @unknown_keys
+      when "reject"
+        unknown.each do |key|
+          issues << ValidationIssue.new(
+            code: IssueCodes::UNKNOWN_KEY,
+            path: path + [key],
+            expected: "undefined",
+            received: key
+          )
+        end
+      when "strip"
+        # Just don't include them
+      when "allow"
+        unknown.each { |key| output[key] = input[key] }
+      end
+
+      if issues.empty?
+        ParseResult.new(value: output, issues: [])
+      else
+        ParseResult.new(value: nil, issues: issues)
+      end
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      # Handled in safe_parse override
+    end
+
+    def dup_with(**overrides)
+      attrs = {
+        properties: @properties,
+        required: @required_keys,
+        unknown_keys: @unknown_keys,
+        kind: @kind,
+        constraints: @constraints,
+        coerce_config: @coerce_config,
+        default_value: @default_value,
+        has_default: @has_default,
+        custom_validators: @custom_validators
+      }.merge(overrides)
+      self.class.new(**attrs)
+    end
+  end
+end

data/lib/anyvali/schemas/optional_schema.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class OptionalSchema < Schema
+    attr_reader :inner_schema
+
+    def initialize(schema:, **kwargs)
+      @inner_schema = schema
+      super(kind: "optional", **kwargs)
+    end
+
+    def to_node
+      node = super
+      node["schema"] = @inner_schema.to_node
+      node
+    end
+
+    def safe_parse(input, path: [], context: nil)
+      # When used in objects, absence is handled by ObjectSchema
+      # If called directly with a value, delegate to inner schema
+      context ||= ValidationContext.new
+      @inner_schema.safe_parse(input, path: path, context: context)
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      # Delegate to inner schema
+      result = @inner_schema.safe_parse(value, path: path, context: context)
+      issues.concat(result.issues) if result.failure?
+    end
+
+    def dup_with(**overrides)
+      schema = overrides.delete(:schema) || @inner_schema
+      attrs = {
+        schema: schema,
+        kind: @kind,
+        constraints: @constraints,
+        coerce_config: @coerce_config,
+        default_value: @default_value,
+        has_default: @has_default,
+        custom_validators: @custom_validators
+      }.merge(overrides)
+      self.class.new(**attrs)
+    end
+  end
+end

data/lib/anyvali/schemas/record_schema.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class RecordSchema < Schema
+    attr_reader :values_schema
+
+    def initialize(values:, **kwargs)
+      @values_schema = values
+      super(kind: "record", **kwargs)
+    end
+
+    def to_node
+      node = super
+      node["values"] = @values_schema.to_node
+      node
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      unless value.is_a?(Hash)
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: "record",
+          received: Schema.type_name(value)
+        )
+        return
+      end
+
+      value.each do |k, v|
+        result = @values_schema.safe_parse(v, path: path + [k], context: context)
+        issues.concat(result.issues) if result.failure?
+      end
+    end
+
+    def dup_with(**overrides)
+      values = overrides.delete(:values) || @values_schema
+      attrs = {
+        values: values,
+        kind: @kind,
+        constraints: @constraints,
+        coerce_config: @coerce_config,
+        default_value: @default_value,
+        has_default: @has_default,
+        custom_validators: @custom_validators
+      }.merge(overrides)
+      self.class.new(**attrs)
+    end
+  end
+end