Santa Data

Data models, schemas, and CCL configuration parser for the Santa package manager.

This library provides the core data structures and configuration parsing functionality used by Santa. It's designed to be reusable for other tools that need to work with Santa's configuration format or data models.

Features

CCL Configuration Parser - Parse Santa's CCL-based configuration files
Data Models - Strongly-typed models for packages, sources, and configuration
Serde Integration - Full serialization/deserialization support
Validation - Built-in validation for configuration data
Builder Patterns - Ergonomic builders for constructing data models

Installation

Add to your Cargo.toml:

[dependencies]
santa-data = "0.1"

Usage

Parse CCL Configuration

use santa_data::parser::parse_ccl_config;

let ccl = r#"
sources =
  = brew
  = cargo
  = apt

packages =
  = ripgrep
  = bat
  = fd
"#;

let config = parse_ccl_config(ccl)?;
println!("Sources: {:?}", config.sources);
println!("Packages: {:?}", config.packages);

Work with Data Models

use santa_data::models::{PackageSource, Package};

// Define package sources
let sources = vec![
    PackageSource::Brew,
    PackageSource::Cargo,
    PackageSource::Apt,
];

// Create a package reference
let package = Package::new("ripgrep");

Use Configuration Builder

use santa_data::config::ConfigBuilder;

let config = ConfigBuilder::default()
    .sources(vec!["brew", "cargo"])
    .packages(vec!["ripgrep", "bat"])
    .cache_ttl_seconds(3600)
    .build()?;

Validation

use santa_data::config::Config;
use validator::Validate;

let config = Config::from_ccl(ccl_string)?;
config.validate()?; // Validates sources, packages, cache settings

Data Models

Core Types

Config - Main configuration structure with sources, packages, and settings
PackageSource - Enumeration of supported package managers (Brew, Cargo, APT, etc.)
Package - Package reference with optional metadata
CacheConfig - Cache settings (TTL, size limits)

Configuration Schema

The library provides JSON Schema support for validation and documentation:

use santa_data::schemas::generate_config_schema;

let schema = generate_config_schema();
println!("{}", serde_json::to_string_pretty(&schema)?);

CCL Format

Santa Data uses CCL (Categorical Configuration Language) for configuration files. CCL is a simple, indentation-based format:

/= This is a comment

/= List items use empty keys with indentation
sources =
  = brew
  = cargo
  = apt

packages =
  = ripgrep
  = bat
  = fd

/= Nested configuration
cache =
  ttl_seconds = 3600
  max_size = 1000

Integration with Sickle

Santa Data uses the sickle crate for CCL parsing, which provides:

Pure Rust CCL parser
Serde integration
Memory-efficient parsing
Comprehensive error reporting

API Documentation

For complete API documentation, see docs.rs/santa-data.

Key Modules

models - Core data structures (Config, Package, PackageSource)
parser - CCL parsing utilities
config - Configuration builders and loaders
schemas - JSON Schema generation

Examples

See the examples directory for complete usage examples:

parse_config.rs - Parse CCL configuration files
build_config.rs - Build configuration programmatically
validate_config.rs - Validate configuration data

Run examples with:

cargo run --example parse_config

Development

Testing

# Run all tests
cargo test

# Run with output
cargo test -- --nocapture

# Run specific test
cargo test test_parse_ccl_config

Documentation

# Generate and open docs
cargo doc --open

# Check docs for warnings
cargo doc --no-deps

Contributing

Contributions are welcome! This library is part of the Santa workspace.

Please ensure:

Tests pass: cargo test
Code is formatted: cargo fmt
Lints pass: cargo clippy

License

Licensed under the MIT License.

Related Crates

santa-cli - Command-line interface for Santa
sickle - CCL parser used by Santa Data

Part of the Santa package manager project.

santa-data 0.3.2