gh-jeanluciano-quaestor-src-quaestor/skills/implementing-features/languages/RUST.md

Rust Quality Standards

Load this file when: Implementing features in Rust projects

Validation Commands

# Linting
cargo clippy -- -D warnings

# Formatting
cargo fmt

# Tests
cargo test

# Type Checking (implicit)
cargo check

# Documentation
cargo doc --no-deps --open

# Full Validation Pipeline
cargo clippy -- -D warnings && cargo fmt --check && cargo test

Required Standards

Code Style:
  - Follow: Rust API guidelines
  - Formatting: rustfmt (automatic)
  - Naming: snake_case for functions, PascalCase for types
  - Modules: Clear separation of concerns

Testing:
  - Framework: Built-in test framework
  - Coverage: >= 75%
  - Unit tests: In same file with #[cfg(test)]
  - Integration tests: In tests/ directory
  - Doc tests: In documentation examples

Documentation:
  - All public items: /// documentation
  - Modules: //! module-level docs
  - Examples: Working examples in docs
  - Safety: Document unsafe blocks thoroughly

Error Handling:
  - Use Result<T, E> for fallible operations
  - Use Option<T> for optional values
  - No .unwrap() in production code
  - Custom error types with thiserror or anyhow
  - Proper error context with context/wrap_err

Quality Checklist

Before Declaring Complete:

• No clippy warnings (cargo clippy -- -D warnings)
• Code formatted (cargo fmt --check)
• All tests pass (cargo test)
• No unwrap() calls in production code
• Result<T, E> used for all fallible operations
• All public items documented
• Examples in documentation tested
• Unsafe blocks documented with safety comments
• Proper error types defined
• Resource cleanup handled (Drop trait if needed)

Example Quality Pattern

use thiserror::Error;
use std::path::Path;

#[derive(Error, Debug)]
pub enum ConfigError {
    #[error("Config file not found: {0}")]
    NotFound(String),
    #[error("Invalid YAML: {0}")]
    InvalidYaml(#[from] serde_yaml::Error),
}

/// Load configuration from YAML file.
///
/// # Arguments
///
/// * `path` - Path to configuration file
///
/// # Returns
///
/// Returns the parsed configuration or an error.
///
/// # Errors
///
/// Returns `ConfigError::NotFound` if file doesn't exist.
/// Returns `ConfigError::InvalidYaml` if parsing fails.
///
/// # Examples
///
/// ```
/// let config = load_config(Path::new("config.yaml"))?;
/// ```
pub fn load_config(path: &Path) -> Result<Config, ConfigError> {
    if !path.exists() {
        return Err(ConfigError::NotFound(path.display().to_string()));
    }

    let contents = std::fs::read_to_string(path)
        .map_err(|e| ConfigError::InvalidYaml(e.into()))?;

    let config: Config = serde_yaml::from_str(&contents)?;
    Ok(config)
}

---

Rust-specific quality standards for production-ready code