anyvali 0.0.1

data/lib/anyvali/schemas/ref_schema.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class RefSchema < Schema
+    attr_reader :ref
+
+    def initialize(ref:, **kwargs)
+      @ref = ref
+      super(kind: "ref", **kwargs)
+    end
+
+    def to_node
+      { "kind" => "ref", "ref" => @ref }
+    end
+
+    def safe_parse(input, path: [], context: nil)
+      context ||= ValidationContext.new
+      resolved = resolve(context)
+      if resolved.nil?
+        issues = [ValidationIssue.new(
+          code: IssueCodes::UNSUPPORTED_SCHEMA_KIND,
+          path: path,
+          expected: @ref,
+          received: "unresolved ref"
+        )]
+        return ParseResult.new(value: nil, issues: issues)
+      end
+      resolved.safe_parse(input, path: path, context: context)
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      # Handled in safe_parse override
+    end
+
+    def dup_with(**overrides)
+      attrs = {
+        ref: @ref,
+        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
+
+    private
+
+    def resolve(context)
+      # ref format: "#/definitions/Name"
+      name = @ref.sub("#/definitions/", "")
+      context.definitions[name]
+    end
+  end
+end

data/lib/anyvali/schemas/string_schema.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class StringSchema < Schema
+    def initialize(constraints: {}, **kwargs)
+      super(kind: "string", constraints: constraints, **kwargs)
+    end
+
+    def min_length(n)
+      dup_with(constraints: @constraints.merge("minLength" => n))
+    end
+
+    def max_length(n)
+      dup_with(constraints: @constraints.merge("maxLength" => n))
+    end
+
+    def pattern(re)
+      pat = re.is_a?(Regexp) ? re.source : re
+      dup_with(constraints: @constraints.merge("pattern" => pat))
+    end
+
+    def starts_with(prefix)
+      dup_with(constraints: @constraints.merge("startsWith" => prefix))
+    end
+
+    def ends_with(suffix)
+      dup_with(constraints: @constraints.merge("endsWith" => suffix))
+    end
+
+    def includes(substr)
+      dup_with(constraints: @constraints.merge("includes" => substr))
+    end
+
+    def format(fmt)
+      dup_with(constraints: @constraints.merge("format" => fmt))
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      unless value.is_a?(String)
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_TYPE,
+          path: path,
+          expected: "string",
+          received: Schema.type_name(value)
+        )
+        return
+      end
+
+      if @constraints["minLength"] && value.length < @constraints["minLength"]
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_SMALL,
+          path: path,
+          expected: @constraints["minLength"].to_s,
+          received: value.length.to_s
+        )
+      end
+
+      if @constraints["maxLength"] && value.length > @constraints["maxLength"]
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_LARGE,
+          path: path,
+          expected: @constraints["maxLength"].to_s,
+          received: value.length.to_s
+        )
+      end
+
+      if @constraints["pattern"]
+        re = Regexp.new(@constraints["pattern"])
+        unless re.match?(value)
+          issues << ValidationIssue.new(
+            code: IssueCodes::INVALID_STRING,
+            path: path,
+            expected: @constraints["pattern"],
+            received: value
+          )
+        end
+      end
+
+      if @constraints["startsWith"] && !value.start_with?(@constraints["startsWith"])
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_STRING,
+          path: path,
+          expected: @constraints["startsWith"],
+          received: value
+        )
+      end
+
+      if @constraints["endsWith"] && !value.end_with?(@constraints["endsWith"])
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_STRING,
+          path: path,
+          expected: @constraints["endsWith"],
+          received: value
+        )
+      end
+
+      if @constraints["includes"] && !value.include?(@constraints["includes"])
+        issues << ValidationIssue.new(
+          code: IssueCodes::INVALID_STRING,
+          path: path,
+          expected: @constraints["includes"],
+          received: value
+        )
+      end
+
+      if @constraints["format"]
+        Format::Validators.validate(value, @constraints["format"], path, issues)
+      end
+    end
+  end
+end

data/lib/anyvali/schemas/tuple_schema.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class TupleSchema < Schema
+    attr_reader :element_schemas
+
+    def initialize(elements:, **kwargs)
+      @element_schemas = elements.freeze
+      super(kind: "tuple", **kwargs)
+    end
+
+    def to_node
+      node = super
+      node["elements"] = @element_schemas.map(&: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: "tuple",
+          received: Schema.type_name(value)
+        )
+        return
+      end
+
+      expected_len = @element_schemas.length
+      if value.length < expected_len
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_SMALL,
+          path: path,
+          expected: expected_len.to_s,
+          received: value.length.to_s
+        )
+        return
+      end
+
+      if value.length > expected_len
+        issues << ValidationIssue.new(
+          code: IssueCodes::TOO_LARGE,
+          path: path,
+          expected: expected_len.to_s,
+          received: value.length.to_s
+        )
+        return
+      end
+
+      @element_schemas.each_with_index do |schema, i|
+        result = schema.safe_parse(value[i], path: path + [i], context: context)
+        issues.concat(result.issues) if result.failure?
+      end
+    end
+
+    def dup_with(**overrides)
+      elements = overrides.delete(:elements) || @element_schemas
+      attrs = {
+        elements: elements,
+        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/union_schema.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class UnionSchema < Schema
+    attr_reader :variant_schemas
+
+    def initialize(variants:, **kwargs)
+      @variant_schemas = variants.freeze
+      super(kind: "union", **kwargs)
+    end
+
+    def to_node
+      node = super
+      node["variants"] = @variant_schemas.map(&:to_node)
+      node
+    end
+
+    protected
+
+    def validate(value, path, issues, context)
+      @variant_schemas.each do |schema|
+        result = schema.safe_parse(value, path: path, context: context)
+        return if result.success?
+      end
+
+      # No variant matched
+      expected = @variant_schemas.map(&:kind).join(" | ")
+      issues << ValidationIssue.new(
+        code: IssueCodes::INVALID_UNION,
+        path: path,
+        expected: expected,
+        received: Schema.type_name(value)
+      )
+    end
+
+    def dup_with(**overrides)
+      variants = overrides.delete(:variants) || @variant_schemas
+      attrs = {
+        variants: variants,
+        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/unknown_schema.rb

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

data/lib/anyvali/validation_context.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class ValidationContext
+    attr_reader :definitions
+
+    def initialize(definitions: {})
+      @definitions = definitions
+    end
+  end
+end

data/lib/anyvali/validation_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class ValidationError < StandardError
+    attr_reader :issues
+
+    def initialize(issues)
+      @issues = issues
+      messages = issues.map { |i| "#{i.code} at #{i.path.inspect}: expected #{i.expected}, received #{i.received}" }
+      super("Validation failed: #{messages.join('; ')}")
+    end
+  end
+end

data/lib/anyvali/validation_issue.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module AnyVali
+  class ValidationIssue
+    attr_reader :code, :message, :path, :expected, :received, :meta
+
+    def initialize(code:, message: nil, path: [], expected: nil, received: nil, meta: nil)
+      @code = code
+      @message = message || default_message(code)
+      @path = path.freeze
+      @expected = expected
+      @received = received
+      @meta = meta
+      freeze
+    end
+
+    def to_h
+      h = { "code" => @code, "path" => @path.dup }
+      h["expected"] = @expected unless @expected.nil?
+      h["received"] = @received unless @received.nil?
+      h["message"] = @message if @message
+      h["meta"] = @meta if @meta
+      h
+    end
+
+    private
+
+    def default_message(code)
+      case code
+      when IssueCodes::INVALID_TYPE then "Invalid type"
+      when IssueCodes::REQUIRED then "Required field missing"
+      when IssueCodes::UNKNOWN_KEY then "Unknown key"
+      when IssueCodes::TOO_SMALL then "Value too small"
+      when IssueCodes::TOO_LARGE then "Value too large"
+      when IssueCodes::INVALID_STRING then "Invalid string"
+      when IssueCodes::INVALID_NUMBER then "Invalid number"
+      when IssueCodes::INVALID_LITERAL then "Invalid literal"
+      when IssueCodes::INVALID_UNION then "Invalid union"
+      when IssueCodes::COERCION_FAILED then "Coercion failed"
+      when IssueCodes::DEFAULT_INVALID then "Default value is invalid"
+      else "Validation failed"
+      end
+    end
+  end
+end

data/lib/anyvali.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative "anyvali/issue_codes"
+require_relative "anyvali/validation_issue"
+require_relative "anyvali/parse_result"
+require_relative "anyvali/validation_error"
+require_relative "anyvali/validation_context"
+require_relative "anyvali/anyvali_document"
+require_relative "anyvali/schema"
+
+require_relative "anyvali/parse/coercion"
+require_relative "anyvali/parse/coercion_config"
+require_relative "anyvali/parse/defaults"
+
+require_relative "anyvali/format/validators"
+
+require_relative "anyvali/schemas/string_schema"
+require_relative "anyvali/schemas/number_schema"
+require_relative "anyvali/schemas/int_schema"
+require_relative "anyvali/schemas/bool_schema"
+require_relative "anyvali/schemas/null_schema"
+require_relative "anyvali/schemas/any_schema"
+require_relative "anyvali/schemas/unknown_schema"
+require_relative "anyvali/schemas/never_schema"
+require_relative "anyvali/schemas/literal_schema"
+require_relative "anyvali/schemas/enum_schema"
+require_relative "anyvali/schemas/array_schema"
+require_relative "anyvali/schemas/tuple_schema"
+require_relative "anyvali/schemas/object_schema"
+require_relative "anyvali/schemas/record_schema"
+require_relative "anyvali/schemas/union_schema"
+require_relative "anyvali/schemas/intersection_schema"
+require_relative "anyvali/schemas/optional_schema"
+require_relative "anyvali/schemas/nullable_schema"
+require_relative "anyvali/schemas/ref_schema"
+
+require_relative "anyvali/interchange/exporter"
+require_relative "anyvali/interchange/importer"
+
+module AnyVali
+  VERSION = "0.0.1"
+
+  module_function
+
+  # Builder methods
+
+  def string
+    StringSchema.new
+  end
+
+  def number
+    NumberSchema.new(kind: "number")
+  end
+
+  def float32
+    NumberSchema.new(kind: "float32")
+  end
+
+  def float64
+    NumberSchema.new(kind: "float64")
+  end
+
+  def int_
+    IntSchema.new(kind: "int")
+  end
+
+  def int8
+    IntSchema.new(kind: "int8")
+  end
+
+  def int16
+    IntSchema.new(kind: "int16")
+  end
+
+  def int32
+    IntSchema.new(kind: "int32")
+  end
+
+  def int64
+    IntSchema.new(kind: "int64")
+  end
+
+  def uint8
+    IntSchema.new(kind: "uint8")
+  end
+
+  def uint16
+    IntSchema.new(kind: "uint16")
+  end
+
+  def uint32
+    IntSchema.new(kind: "uint32")
+  end
+
+  def uint64
+    IntSchema.new(kind: "uint64")
+  end
+
+  def bool
+    BoolSchema.new
+  end
+
+  def null
+    NullSchema.new
+  end
+
+  def any
+    AnySchema.new
+  end
+
+  def unknown
+    UnknownSchema.new
+  end
+
+  def never
+    NeverSchema.new
+  end
+
+  def literal(value)
+    LiteralSchema.new(value: value)
+  end
+
+  def enum_(*values)
+    EnumSchema.new(values: values.flatten)
+  end
+
+  def array(items)
+    ArraySchema.new(items: items)
+  end
+
+  def tuple(*elements)
+    TupleSchema.new(elements: elements.flatten)
+  end
+
+  def object(properties:, required: [], unknown_keys: "reject")
+    ObjectSchema.new(properties: properties, required: required, unknown_keys: unknown_keys)
+  end
+
+  def record(values)
+    RecordSchema.new(values: values)
+  end
+
+  def union(*variants)
+    UnionSchema.new(variants: variants.flatten)
+  end
+
+  def intersection(*schemas)
+    IntersectionSchema.new(all_of: schemas.flatten)
+  end
+
+  def optional(schema)
+    OptionalSchema.new(schema: schema)
+  end
+
+  def nullable(schema)
+    NullableSchema.new(schema: schema)
+  end
+
+  def ref(ref_path)
+    RefSchema.new(ref: ref_path)
+  end
+
+  # Interchange
+
+  def export(schema, mode: :portable, definitions: {})
+    Interchange::Exporter.export(schema, mode: mode, definitions: definitions)
+  end
+
+  def import(doc)
+    Interchange::Importer.import(doc)
+  end
+
+  def import_schema(doc)
+    Interchange::Importer.import_schema(doc)
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: anyvali
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- AnyVali Contributors
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: AnyVali Ruby SDK - native validation with portable schema interchange
+  across 10 languages
+email:
+- hello@anyvali.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/anyvali.rb
+- lib/anyvali/anyvali_document.rb
+- lib/anyvali/format/validators.rb
+- lib/anyvali/interchange/exporter.rb
+- lib/anyvali/interchange/importer.rb
+- lib/anyvali/issue_codes.rb
+- lib/anyvali/parse/coercion.rb
+- lib/anyvali/parse/coercion_config.rb
+- lib/anyvali/parse/defaults.rb
+- lib/anyvali/parse_result.rb
+- lib/anyvali/schema.rb
+- lib/anyvali/schemas/any_schema.rb
+- lib/anyvali/schemas/array_schema.rb
+- lib/anyvali/schemas/bool_schema.rb
+- lib/anyvali/schemas/enum_schema.rb
+- lib/anyvali/schemas/int_schema.rb
+- lib/anyvali/schemas/intersection_schema.rb
+- lib/anyvali/schemas/literal_schema.rb
+- lib/anyvali/schemas/never_schema.rb
+- lib/anyvali/schemas/null_schema.rb
+- lib/anyvali/schemas/nullable_schema.rb
+- lib/anyvali/schemas/number_schema.rb
+- lib/anyvali/schemas/object_schema.rb
+- lib/anyvali/schemas/optional_schema.rb
+- lib/anyvali/schemas/record_schema.rb
+- lib/anyvali/schemas/ref_schema.rb
+- lib/anyvali/schemas/string_schema.rb
+- lib/anyvali/schemas/tuple_schema.rb
+- lib/anyvali/schemas/union_schema.rb
+- lib/anyvali/schemas/unknown_schema.rb
+- lib/anyvali/validation_context.rb
+- lib/anyvali/validation_error.rb
+- lib/anyvali/validation_issue.rb
+homepage: https://anyvali.com
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/BetterCorp/AnyVali
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Native validation with portable schema interchange
+test_files: []