ron-schema-validator

Schema validation for RON (Rusty Object Notation) files. Define the expected structure of your .ron data in a .ronschema file, then validate against it — catching type mismatches, missing fields, invalid enum variants, and more.

RON has no equivalent of JSON Schema. This project fills that gap.

Status: v0.7 — Schema parser, RON parser, validator, and CLI are all functional with test coverage. JSON output and default field values available.

Schema Format

Schemas use a custom .ronschema format that mirrors the shape of the data it validates. Types replace values:

// config.ronschema
(
  name: String,
  version: Integer,
  debug: Bool,
  description: Option(String),
  tags: [String],
  window: (
    width: Integer,
    height: Integer,
  ),
)

A matching .ron data file:

// config.ron
(
  name: "my-app",
  version: 3,
  debug: true,
  description: Some("A sample application"),
  tags: ["cli", "tools"],
  window: (
    width: 1920,
    height: 1080,
  ),
)

Supported Types

Enums

Define enums after the root struct. Variants can be unit (bare identifiers) or carry associated data:

(
  status: Status,
  effect: Effect,
)

enum Status { Active, Inactive, Pending }
enum Effect { Damage(Integer), Heal(Integer), Draw }

Type Aliases

Define reusable types with type Name = T:

(
  cost: Cost,
  backup_cost: Cost,
)

type Cost = (generic: Integer, sigil: Integer,)

Default Values

Fields with defaults are optional — they don't produce errors when absent from data:

(
  name: String,
  label: String = "unnamed",
  count: Integer = 0,
  tags: [String] = [],
  status: Status = Active,
)

enum Status { Active, Inactive }

Default values are type-checked against their field's declared type at schema parse time.

Maps

Map types use {KeyType: ValueType}. Keys must be String, Integer, or an enum type:

(
  attributes: {String: Integer},
)

CLI Usage

ron-schema validate --schema config.ronschema target.ron

Pass a directory as the target to validate all .ron files within it:

ron-schema validate --schema card.ronschema cards/

Use --format json for machine-readable output:

ron-schema validate --schema config.ronschema data/ --format json

{
  "success": true,
  "results": [
    {
      "file": "data/config.ron",
      "errors": [],
      "warnings": []
    }
  ]
}

Library Usage

The library crate (ron-schema) operates on &str — no file I/O, no formatting opinions.

use ron_schema::{parse_schema, parse_ron, validate, extract_source_line};

let schema = parse_schema(schema_source)?;
let value = parse_ron(ron_source)?;
let errors = validate(&schema, &value);

for error in &errors {
    let source_line = extract_source_line(ron_source, error.span);
    // Render however you like
}

Validation collects all errors rather than failing on the first — useful when batch-validating many files.

Project Structure

ron-schema-validator/
├── ron-schema/          ← library crate (zero external dependencies)
│   └── src/
│       ├── lib.rs       ← public API re-exports
│       ├── span.rs      ← Position, Span, Spanned<T>
│       ├── error.rs     ← error types (schema, RON, validation)
│       ├── diagnostic.rs
│       ├── schema/      ← schema AST + parser
│       └── ron/         ← RON value types + parser
└── ron-schema-cli/      ← binary crate (clap)
    └── src/
        └── main.rs

Building

cargo build
cargo test

Requires Rust 2021 edition.

Roadmap

MVP (v0.1)

• Workspace and crate scaffolding
• Source location types (Span, Position, Spanned<T>)
• Error types (schema parsing, RON parsing, validation)
• Schema AST types
• RON value types
• Source line extraction for diagnostics
• Schema parser (.ronschema → AST)
• RON data parser (.ron → Spanned<RonValue>)
• Validation engine
• CLI wiring (file I/O, error rendering, batch mode)
• Test coverage for all error kinds

v0.2 — Type Aliases

• type Name = T definitions
• Recursive alias detection
• Alias resolution during validation

v0.3 — Map Types

• {K: V} schema syntax
• { key: value, ... } RON parsing
• Map key/value validation
• Key type restriction (String, Integer, enum)

v0.4 — Tuple Types

• (T1, T2, ...) schema syntax
• Tuple parsing in RON data with struct/tuple disambiguation
• Tuple length and element type validation

v0.5 — Enum Variants with Data

• Variant(Type) schema syntax
• Variant(value) RON parsing
• Unit vs data variant validation

v0.6 — JSON Output

• --format json for machine-readable output
• Structured error objects with code, severity, path, message, span
• Schema parse errors surfaced in JSON with success: false

v0.7 — Default Values

• field: Type = <value> syntax for optional fields
• Fields with defaults not required in data
• Default values type-checked at schema parse time

Future

• Warnings and --deny-warnings
• Schema composition / imports
• Custom validation rules (value ranges, string patterns)
• init subcommand (schema inference)

Design Decisions

License

MIT