anyvali 0.0.1

data/lib/anyvali/interchange/importer.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "json"
+
+module AnyVali
+  module Interchange
+    module Importer
+      module_function
+
+      def import(doc)
+        doc = JSON.parse(doc) if doc.is_a?(String)
+
+        # Build definitions first (needed for refs)
+        definitions = {}
+        if doc["definitions"]
+          doc["definitions"].each do |name, node|
+            definitions[name] = node_to_schema(node)
+          end
+        end
+
+        root_schema = node_to_schema(doc["root"])
+        context = ValidationContext.new(definitions: definitions)
+        [root_schema, context, definitions]
+      end
+
+      def import_schema(doc)
+        schema, context, definitions = import(doc)
+        schema
+      end
+
+      def node_to_schema(node)
+        kind = node["kind"]
+
+        case kind
+        when "string"
+          build_string(node)
+        when "number", "float32", "float64"
+          build_number(node, kind)
+        when "int", "int8", "int16", "int32", "int64",
+             "uint8", "uint16", "uint32", "uint64"
+          build_int(node, kind)
+        when "bool"
+          build_bool(node)
+        when "null"
+          NullSchema.new
+        when "any"
+          AnySchema.new
+        when "unknown"
+          UnknownSchema.new
+        when "never"
+          NeverSchema.new
+        when "literal"
+          LiteralSchema.new(value: node["value"])
+        when "enum"
+          EnumSchema.new(values: node["values"])
+        when "array"
+          build_array(node)
+        when "tuple"
+          build_tuple(node)
+        when "object"
+          build_object(node)
+        when "record"
+          build_record(node)
+        when "union"
+          build_union(node)
+        when "intersection"
+          build_intersection(node)
+        when "optional"
+          OptionalSchema.new(schema: node_to_schema(node["schema"]))
+        when "nullable"
+          build_nullable(node)
+        when "ref"
+          RefSchema.new(ref: node["ref"])
+        else
+          raise ValidationError, [
+            ValidationIssue.new(
+              code: IssueCodes::UNSUPPORTED_SCHEMA_KIND,
+              expected: "known schema kind",
+              received: kind.to_s
+            )
+          ]
+        end
+      end
+
+      def build_string(node)
+        constraints = {}
+        %w[minLength maxLength pattern startsWith endsWith includes format].each do |k|
+          constraints[k] = node[k] if node.key?(k)
+        end
+        coerce = node["coerce"]
+        default_val = node["default"]
+        has_default = node.key?("default")
+        StringSchema.new(
+          constraints: constraints,
+          coerce_config: coerce,
+          default_value: default_val,
+          has_default: has_default
+        )
+      end
+
+      def build_number(node, kind)
+        constraints = {}
+        %w[min max exclusiveMin exclusiveMax multipleOf].each do |k|
+          constraints[k] = node[k] if node.key?(k)
+        end
+        coerce = node["coerce"]
+        default_val = node["default"]
+        has_default = node.key?("default")
+        NumberSchema.new(
+          kind: kind,
+          constraints: constraints,
+          coerce_config: coerce,
+          default_value: default_val,
+          has_default: has_default
+        )
+      end
+
+      def build_int(node, kind)
+        constraints = {}
+        %w[min max exclusiveMin exclusiveMax multipleOf].each do |k|
+          constraints[k] = node[k] if node.key?(k)
+        end
+        coerce = node["coerce"]
+        default_val = node["default"]
+        has_default = node.key?("default")
+        IntSchema.new(
+          kind: kind,
+          constraints: constraints,
+          coerce_config: coerce,
+          default_value: default_val,
+          has_default: has_default
+        )
+      end
+
+      def build_bool(node)
+        coerce = node["coerce"]
+        default_val = node["default"]
+        has_default = node.key?("default")
+        BoolSchema.new(
+          coerce_config: coerce,
+          default_value: default_val,
+          has_default: has_default
+        )
+      end
+
+      def build_array(node)
+        items = node_to_schema(node["items"])
+        constraints = {}
+        %w[minItems maxItems].each do |k|
+          constraints[k] = node[k] if node.key?(k)
+        end
+        ArraySchema.new(items: items, constraints: constraints)
+      end
+
+      def build_tuple(node)
+        elements = node["elements"].map { |e| node_to_schema(e) }
+        TupleSchema.new(elements: elements)
+      end
+
+      def build_object(node)
+        props = {}
+        (node["properties"] || {}).each do |k, v|
+          props[k] = node_to_schema(v)
+        end
+        required = node["required"] || []
+        unknown_keys = node["unknownKeys"] || "reject"
+        ObjectSchema.new(
+          properties: props,
+          required: required,
+          unknown_keys: unknown_keys
+        )
+      end
+
+      def build_record(node)
+        values = node_to_schema(node["values"])
+        RecordSchema.new(values: values)
+      end
+
+      def build_union(node)
+        variants = node["variants"].map { |v| node_to_schema(v) }
+        UnionSchema.new(variants: variants)
+      end
+
+      def build_intersection(node)
+        all_of = node["allOf"].map { |v| node_to_schema(v) }
+        IntersectionSchema.new(all_of: all_of)
+      end
+
+      def build_nullable(node)
+        inner = node_to_schema(node["schema"])
+        default_val = node["default"]
+        has_default = node.key?("default")
+        NullableSchema.new(
+          schema: inner,
+          default_value: default_val,
+          has_default: has_default
+        )
+      end
+    end
+  end
+end

data/lib/anyvali/issue_codes.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AnyVali
+  module IssueCodes
+    INVALID_TYPE = "invalid_type"
+    REQUIRED = "required"
+    UNKNOWN_KEY = "unknown_key"
+    TOO_SMALL = "too_small"
+    TOO_LARGE = "too_large"
+    INVALID_STRING = "invalid_string"
+    INVALID_NUMBER = "invalid_number"
+    INVALID_LITERAL = "invalid_literal"
+    INVALID_UNION = "invalid_union"
+    CUSTOM_VALIDATION_NOT_PORTABLE = "custom_validation_not_portable"
+    UNSUPPORTED_EXTENSION = "unsupported_extension"
+    UNSUPPORTED_SCHEMA_KIND = "unsupported_schema_kind"
+    COERCION_FAILED = "coercion_failed"
+    DEFAULT_INVALID = "default_invalid"
+  end
+end

data/lib/anyvali/parse/coercion.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module AnyVali
+  module Coercion
+    module_function
+
+    def apply(value, config, kind)
+      configs = config.is_a?(Array) ? config : [config]
+      current = value
+
+      configs.each do |c|
+        result = apply_single(current, c, kind)
+        return result unless result[:success]
+        current = result[:value]
+      end
+
+      { success: true, value: current }
+    end
+
+    def apply_single(value, config, kind)
+      case config
+      when "string->int"
+        coerce_string_to_int(value)
+      when "string->number"
+        coerce_string_to_number(value)
+      when "string->bool"
+        coerce_string_to_bool(value)
+      when "trim"
+        coerce_trim(value)
+      when "lower"
+        coerce_lower(value)
+      when "upper"
+        coerce_upper(value)
+      else
+        { success: false, value: value }
+      end
+    end
+
+    def coerce_string_to_int(value)
+      return { success: true, value: value } if value.is_a?(Integer)
+      return { success: false, value: value } unless value.is_a?(String)
+
+      stripped = value.strip
+      if stripped.match?(/\A-?\d+\z/)
+        { success: true, value: stripped.to_i }
+      else
+        { success: false, value: value }
+      end
+    end
+
+    def coerce_string_to_number(value)
+      return { success: true, value: value } if value.is_a?(Numeric)
+      return { success: false, value: value } unless value.is_a?(String)
+
+      stripped = value.strip
+      begin
+        f = Float(stripped)
+        { success: true, value: f }
+      rescue ArgumentError
+        { success: false, value: value }
+      end
+    end
+
+    def coerce_string_to_bool(value)
+      return { success: true, value: value } if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      return { success: false, value: value } unless value.is_a?(String)
+
+      case value.strip.downcase
+      when "true", "1"
+        { success: true, value: true }
+      when "false", "0"
+        { success: true, value: false }
+      else
+        { success: false, value: value }
+      end
+    end
+
+    def coerce_trim(value)
+      return { success: true, value: value } unless value.is_a?(String)
+      { success: true, value: value.strip }
+    end
+
+    def coerce_lower(value)
+      return { success: true, value: value } unless value.is_a?(String)
+      { success: true, value: value.downcase }
+    end
+
+    def coerce_upper(value)
+      return { success: true, value: value } unless value.is_a?(String)
+      { success: true, value: value.upcase }
+    end
+  end
+end

data/lib/anyvali/parse/coercion_config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AnyVali
+  module CoercionConfig
+    PORTABLE_COERCIONS = %w[
+      string->int
+      string->number
+      string->bool
+      trim
+      lower
+      upper
+    ].freeze
+
+    def self.portable?(config)
+      configs = config.is_a?(Array) ? config : [config]
+      configs.all? { |c| PORTABLE_COERCIONS.include?(c) }
+    end
+  end
+end

data/lib/anyvali/parse/defaults.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module AnyVali
+  module Defaults
+    module_function
+
+    # Check if a default value is JSON-serializable (portable)
+    def portable?(value)
+      case value
+      when NilClass, TrueClass, FalseClass, Integer, Float, String
+        true
+      when Array
+        value.all? { |v| portable?(v) }
+      when Hash
+        value.all? { |k, v| k.is_a?(String) && portable?(v) }
+      else
+        false
+      end
+    end
+  end
+end

data/lib/anyvali/parse_result.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class ParseResult
+    attr_reader :value, :issues
+
+    def initialize(value:, issues:)
+      @value = value
+      @issues = issues.freeze
+      freeze
+    end
+
+    def success?
+      @issues.empty?
+    end
+
+    def failure?
+      !success?
+    end
+  end
+end

data/lib/anyvali/schema.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class Schema
+    attr_reader :kind, :constraints, :coerce_config, :default_value, :has_default,
+                :custom_validators
+
+    def initialize(kind:, constraints: {}, coerce_config: nil, default_value: nil, has_default: false, custom_validators: [])
+      @kind = kind
+      @constraints = constraints.freeze
+      @coerce_config = coerce_config
+      @default_value = default_value
+      @has_default = has_default
+      @custom_validators = custom_validators.freeze
+    end
+
+    def parse(input)
+      result = safe_parse(input)
+      raise ValidationError, result.issues if result.failure?
+      result.value
+    end
+
+    def safe_parse(input, path: [], context: nil)
+      context ||= ValidationContext.new
+      value = input
+      issues = []
+
+      # Step 1: Coercion (if present and configured)
+      if @coerce_config && !value.nil?
+        coerced = Coercion.apply(value, @coerce_config, @kind)
+        if coerced[:success]
+          value = coerced[:value]
+        else
+          issues << ValidationIssue.new(
+            code: IssueCodes::COERCION_FAILED,
+            path: path,
+            expected: @kind,
+            received: value.is_a?(String) ? value : value.to_s
+          )
+          return ParseResult.new(value: nil, issues: issues)
+        end
+      end
+
+      # Step 2: Validate
+      validate(value, path, issues, context)
+
+      # Step 3: Custom validators
+      if issues.empty? && !@custom_validators.empty?
+        @custom_validators.each do |validator|
+          validator_issues = validator.call(value, path)
+          issues.concat(validator_issues) if validator_issues
+        end
+      end
+
+      if issues.empty?
+        ParseResult.new(value: value, issues: [])
+      else
+        ParseResult.new(value: nil, issues: issues)
+      end
+    end
+
+    def default(value)
+      dup_with(default_value: value, has_default: true)
+    end
+
+    def coerce(config)
+      dup_with(coerce_config: config)
+    end
+
+    def refine(&block)
+      dup_with(custom_validators: @custom_validators + [block])
+    end
+
+    def portable?
+      @custom_validators.empty?
+    end
+
+    def export(mode: :portable)
+      if mode == :portable && !portable?
+        raise ValidationError, [
+          ValidationIssue.new(
+            code: IssueCodes::CUSTOM_VALIDATION_NOT_PORTABLE,
+            expected: "portable schema",
+            received: "schema with custom validators"
+          )
+        ]
+      end
+      doc = AnyValiDocument.new(root: self)
+      doc.to_h
+    end
+
+    def to_node
+      node = { "kind" => @kind }
+      @constraints.each { |k, v| node[k] = v }
+      node["coerce"] = @coerce_config if @coerce_config
+      node["default"] = @default_value if @has_default
+      node
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      raise NotImplementedError, "Subclasses must implement validate"
+    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
+
+    # Helper to get the JSON type name for a Ruby value
+    def self.type_name(value)
+      case value
+      when NilClass then "null"
+      when TrueClass, FalseClass then "boolean"
+      when Integer then "number"
+      when Float then "number"
+      when String then "string"
+      when Array then "array"
+      when Hash then "object"
+      else value.class.name.downcase
+      end
+    end
+  end
+end

data/lib/anyvali/schemas/any_schema.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class AnySchema < Schema
+    def initialize(**kwargs)
+      super(kind: "any", **kwargs)
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      # any accepts everything
+    end
+  end
+end

data/lib/anyvali/schemas/array_schema.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class ArraySchema < Schema
+    attr_reader :items_schema
+
+    def initialize(items:, constraints: {}, **kwargs)
+      @items_schema = items
+      super(kind: "array", constraints: constraints, **kwargs)
+    end
+
+    def min_items(n)
+      dup_with(constraints: @constraints.merge("minItems" => n))
+    end
+
+    def max_items(n)
+      dup_with(constraints: @constraints.merge("maxItems" => n))
+    end
+
+    def to_node
+      node = super
+      node["items"] = @items_schema.to_node
+      node
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      unless value.is_a?(Array)
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: "array",
+          received: Schema.type_name(value)
+        )
+        return
+      end
+
+      if @constraints["minItems"] && value.length < @constraints["minItems"]
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_SMALL,
+          path: path,
+          expected: @constraints["minItems"].to_s,
+          received: value.length.to_s
+        )
+      end
+
+      if @constraints["maxItems"] && value.length > @constraints["maxItems"]
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_LARGE,
+          path: path,
+          expected: @constraints["maxItems"].to_s,
+          received: value.length.to_s
+        )
+      end
+
+      value.each_with_index do |item, i|
+        result = @items_schema.safe_parse(item, path: path + [i], context: context)
+        issues.concat(result.issues) if result.failure?
+      end
+    end
+
+    def dup_with(**overrides)
+      items = overrides.delete(:items) || @items_schema
+      attrs = {
+        items: items,
+        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/bool_schema.rb

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

data/lib/anyvali/schemas/enum_schema.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class EnumSchema < Schema
+    attr_reader :values
+
+    def initialize(values:, **kwargs)
+      @values = values.freeze
+      super(kind: "enum", **kwargs)
+    end
+
+    def to_node
+      node = super
+      node["values"] = @values
+      node
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      match = @values.any? { |v| v.class == value.class && v == value }
+      # Special nil handling
+      match ||= @values.include?(nil) && value.nil?
+
+      unless match
+        enum_str = @values.map(&:to_s).join(",")
+        received_str = value.nil? ? "null" : value.to_s
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: "enum(#{enum_str})",
+          received: received_str
+        )
+      end
+    end
+
+    def dup_with(**overrides)
+      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

data/lib/anyvali/schemas/int_schema.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class IntSchema < NumberSchema
+    def initialize(kind: "int", **kwargs)
+      super(kind: kind, **kwargs)
+    end
+  end
+end