Crate fsvalidator

FSValidator

A library for validating filesystem structures against a declarative schema.

This crate allows you to define expected file and directory structures and validate that real filesystem paths match those expectations. It’s useful for ensuring project layouts, validating data directories, or enforcing configuration structures.

Features

• Validate files and directories using literal names or regex patterns
• Support for complex nested directory structures
• Template system for reusing common structures
• Control validation strictness with required flags and restricted directories
• Load definitions from TOML or JSON files
• Comprehensive validation with categorized errors for programmatic usage
• Colorful, symbolic display for human-readable output
• Fluent builder API for programmatically constructing validation models

Examples

Using TOML Config File

use anyhow::Result;
use fsvalidator::from_toml;
use fsvalidator::display::format_validation_result;

    // Load structure definition from TOML
    let root = from_toml("path/to/fsvalidator.toml")?;
     
    // Validate a directory against the defined structure
    // Note: The path should be the direct path to the item being validated
    let path = "./path/to/validate";
     
    // Validate and get comprehensive results (with categorized errors)
    let validation_result = root.validate(path);
     
    // Display results with colorful, symbolic output
    println!("{}", format_validation_result(&validation_result, path));
     
    // Check success/failure and handle accordingly
    if validation_result.is_err() {
        eprintln!("Validation failed!");
    }
     
    Ok(())

Using Builder API

use anyhow::Result;
use fsvalidator::ModelBuilder;
use fsvalidator::display::format_validation_result;

fn main() -> Result<()> {
    // Create a project structure using the builder API
    let project = ModelBuilder::new_dir("project")
        .required(true)
        .allow_defined_only(true)
        .add_file("README.md", true)
        .add_dir("src", true)
            .add_file_pattern(".*\\.rs", true)
            .up()
        .add_dir("tests", false)
            .add_file_pattern("test_.*\\.rs", false)
            .build();
     
    // Validate a directory against the defined structure
    let path = "./path/to/validate";
    let validation_result = project.validate(path);
     
    // Display results with colorful, symbolic output
    println!("{}", format_validation_result(&validation_result, path));
     
    Ok(())
}

Schema Definition

The schema can be defined in TOML or JSON, with a structure like this:

[root]
type = "dir"
name = "project"
required = true

[[root.children]]
type = "file"
name = "README.md"
required = true

[[root.children]]
type = "dir"
name = "src"
required = true

[[root.children.children]]
type = "file"
pattern = ".*\.rs"
required = true

Re-exports

pub use validate::ValidationError;

pub use validate::ValidationResult;

pub use validate::ErrorCategory;

pub use model::ModelBuilder;

Modules

display

Display Formatting

loader

Schema Loader

model

Model

raw

Raw Schema Types

validate

Validation

Functions

from_toml

Load a filesystem structure definition from a TOML file and convert it to a validation model.