derive_defs/

validation.rs

//! Validation utilities for derive-defs configuration.
//!
//! This module provides validation functions to ensure that configuration
//! values are valid and will produce correct generated code.

use crate::{Error, Result};
use std::path::Path;

/// Check if a string is a valid Rust identifier.
///
/// A valid identifier:
/// - Starts with a letter (a-z, A-Z) or underscore (_)
/// - Contains only letters, digits (0-9), and underscores
/// - Is not a Rust keyword
#[must_use]
pub fn is_valid_identifier(name: &str) -> bool {
    if name.is_empty() {
        return false;
    }

    let mut chars = name.chars();

    // First character must be letter or underscore
    match chars.next() {
        Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
        _ => return false,
    }

    // Rest must be alphanumeric or underscore
    if !chars.all(|c| c.is_ascii_alphanumeric() || c == '_') {
        return false;
    }

    // Check for Rust keywords
    !is_rust_keyword(name)
}

/// Check if a string is a Rust keyword.
fn is_rust_keyword(name: &str) -> bool {
    const KEYWORDS: &[&str] = &[
        "as", "break", "const", "continue", "crate", "else", "enum", "extern", "false", "fn",
        "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref",
        "return", "self", "Self", "static", "struct", "super", "trait", "true", "type", "unsafe",
        "use", "where", "while", "async", "await", "dyn", // Reserved keywords
        "abstract", "become", "box", "do", "final", "macro", "override", "priv", "typeof",
        "unsized", "virtual", "yield", "try",
    ];

    KEYWORDS.contains(&name)
}

/// Validate a trait name.
///
/// Returns an error if the trait name is not a valid Rust identifier.
///
/// # Errors
///
/// Returns `Error::Validation` if the trait name is invalid.
pub fn validate_trait_name(name: &str) -> Result<()> {
    if !is_valid_identifier(name) {
        return Err(Error::Validation(format!(
            "Invalid trait name: '{name}' is not a valid Rust identifier"
        )));
    }
    Ok(())
}

/// Validate all trait names in a configuration.
///
/// Returns an error if any trait name is invalid.
///
/// # Errors
///
/// Returns `Error::Validation` if any trait name is invalid.
pub fn validate_trait_names(traits: &[String]) -> Result<()> {
    for name in traits {
        validate_trait_name(name)?;
    }
    Ok(())
}

/// Detect the crate type from Cargo.toml.
///
/// This helps provide better error messages and guidance for users.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CrateType {
    /// A binary crate (`[[bin]]` in Cargo.toml)
    Binary,
    /// A library crate (`[lib]` in Cargo.toml)
    Library,
    /// A proc-macro crate (`[lib] proc-macro = true` in Cargo.toml)
    ProcMacro,
    /// Unknown or workspace-only crate
    Unknown,
}

/// Detect the crate type by reading the Cargo.toml file.
///
/// # Errors
///
/// Returns an error if the Cargo.toml cannot be read or parsed.
pub fn detect_crate_type(manifest_dir: &Path) -> Result<CrateType> {
    let cargo_toml = manifest_dir.join("Cargo.toml");

    let content = std::fs::read_to_string(&cargo_toml).map_err(|e| {
        Error::ConfigRead(std::io::Error::new(
            std::io::ErrorKind::NotFound,
            format!("Could not read {}: {e}", cargo_toml.display()),
        ))
    })?;

    // Check for proc-macro
    if content.contains("proc-macro = true") {
        return Ok(CrateType::ProcMacro);
    }

    // Check for binary
    if content.contains("[[bin]]") || content.contains("[bin]") {
        return Ok(CrateType::Binary);
    }

    // Check for library
    if content.contains("[lib]") {
        return Ok(CrateType::Library);
    }

    Ok(CrateType::Unknown)
}

/// Check if any workspace member is a proc-macro crate.
fn has_proc_macro_member(workspace_root: &Path, workspace_content: &str) -> bool {
    // Parse workspace members from the Cargo.toml
    let members = workspace_content
        .lines()
        .find(|line| line.trim().starts_with("members"))
        .and_then(|line| line.split('=').nth(1))
        .map_or_else(Vec::new, |members_str| {
            // Parse the members array
            let members_str = members_str.trim();
            if members_str.starts_with('[') {
                members_str
                    .trim_start_matches('[')
                    .trim_end_matches(']')
                    .split(',')
                    .map(|s| s.trim().trim_matches('"').trim_matches('\'').to_string())
                    .collect::<Vec<_>>()
            } else {
                vec![]
            }
        });

    // Check each member
    for member in members {
        let member_path = if member == "." {
            workspace_root.to_path_buf()
        } else {
            workspace_root.join(&member)
        };

        let cargo_toml = member_path.join("Cargo.toml");
        if let Ok(content) = std::fs::read_to_string(&cargo_toml)
            && content.contains("proc-macro = true")
        {
            return true;
        }
    }

    false
}

/// Check if the current crate type is compatible with proc-macro generation.
///
/// Binary crates cannot define and use proc-macros in the same crate.
/// This function provides helpful guidance when this is detected.
///
/// # Errors
///
/// Returns `Error::Validation` with guidance if binary crate does not have
/// a separate macros crate in the workspace.
pub fn validate_crate_type_for_macros(manifest_dir: &Path) -> Result<()> {
    let crate_type = detect_crate_type(manifest_dir)?;

    match crate_type {
        CrateType::Binary => {
            // Binary crate - check if there's a separate macros crate in workspace
            let workspace_root = manifest_dir.parent().unwrap_or(manifest_dir);
            let workspace_cargo = workspace_root.join("Cargo.toml");

            if workspace_cargo.exists()
                && let Ok(workspace_content) = std::fs::read_to_string(&workspace_cargo)
                && workspace_content.contains("[workspace]")
                && has_proc_macro_member(workspace_root, &workspace_content)
            {
                // User has a separate proc-macro crate in workspace
                return Ok(());
            }

            // Binary crate without separate macros crate - provide guidance
            Err(Error::Validation(
                "Binary crates cannot define proc-macros that they also use. \
                Create a separate proc-macro crate in your workspace. \
                \n\n\
                Recommended structure:\n\
                - Create a `macros/` package with `[lib] proc-macro = true`\n\
                - Move derive_defs.toml and build.rs to the macros package\n\
                - Add `my-app-macros = { path = \"../macros\" }` to your binary's dependencies\n\
                \n\n\
                See https://doc.rust-lang.org/stable/reference/procedural-macros.html for more information.".to_string()
            ))
        }
        CrateType::Library | CrateType::ProcMacro | CrateType::Unknown => Ok(()),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_valid_identifiers() {
        assert!(is_valid_identifier("Debug"));
        assert!(is_valid_identifier("Clone"));
        assert!(is_valid_identifier("Serialize"));
        assert!(is_valid_identifier("my_trait"));
        assert!(is_valid_identifier("_private"));
        assert!(is_valid_identifier("Trait123"));
    }

    #[test]
    fn test_invalid_identifiers() {
        assert!(!is_valid_identifier(""));
        assert!(!is_valid_identifier("123Trait"));
        assert!(!is_valid_identifier("my-trait"));
        assert!(!is_valid_identifier("my::trait"));
        assert!(!is_valid_identifier("my trait"));
        assert!(!is_valid_identifier("trait")); // keyword
        assert!(!is_valid_identifier("impl")); // keyword
    }

    #[test]
    fn test_validate_trait_name_valid() {
        assert!(validate_trait_name("Debug").is_ok());
        assert!(validate_trait_name("Clone").is_ok());
    }

    #[test]
    fn test_validate_trait_name_invalid() {
        assert!(validate_trait_name("").is_err());
        assert!(validate_trait_name("123Trait").is_err());
        assert!(validate_trait_name("trait").is_err());
    }

    #[test]
    fn test_validate_trait_names() {
        let valid = vec!["Debug".to_string(), "Clone".to_string()];
        assert!(validate_trait_names(&valid).is_ok());

        let invalid = vec!["Debug".to_string(), "123Invalid".to_string()];
        assert!(validate_trait_names(&invalid).is_err());
    }

    #[test]
    fn test_detect_crate_type_proc_macro() {
        let content = r#"
[package]
name = "test-macros"
version = "0.1.0"

[lib]
proc-macro = true
"#;

        let temp_dir = tempfile::tempdir().unwrap();
        let cargo_toml = temp_dir.path().join("Cargo.toml");
        std::fs::write(&cargo_toml, content).unwrap();

        let crate_type = detect_crate_type(temp_dir.path()).unwrap();
        assert_eq!(crate_type, CrateType::ProcMacro);
    }

    #[test]
    fn test_detect_crate_type_binary() {
        let content = r#"
[package]
name = "test-bin"
version = "0.1.0"

[[bin]]
name = "test"
path = "src/main.rs"
"#;

        let temp_dir = tempfile::tempdir().unwrap();
        let cargo_toml = temp_dir.path().join("Cargo.toml");
        std::fs::write(&cargo_toml, content).unwrap();

        let crate_type = detect_crate_type(temp_dir.path()).unwrap();
        assert_eq!(crate_type, CrateType::Binary);
    }

    #[test]
    fn test_detect_crate_type_library() {
        let content = r#"
[package]
name = "test-lib"
version = "0.1.0"

[lib]
path = "src/lib.rs"
"#;

        let temp_dir = tempfile::tempdir().unwrap();
        let cargo_toml = temp_dir.path().join("Cargo.toml");
        std::fs::write(&cargo_toml, content).unwrap();

        let crate_type = detect_crate_type(temp_dir.path()).unwrap();
        assert_eq!(crate_type, CrateType::Library);
    }

    #[test]
    fn test_validate_binary_without_macros_crate() {
        let content = r#"
[package]
name = "test-bin"
version = "0.1.0"

[[bin]]
name = "test"
"#;

        let temp_dir = tempfile::tempdir().unwrap();
        let cargo_toml = temp_dir.path().join("Cargo.toml");
        std::fs::write(&cargo_toml, content).unwrap();

        let result = validate_crate_type_for_macros(temp_dir.path());
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Binary crates cannot define")
        );
    }

    #[test]
    fn test_validate_binary_without_macros_crate_in_workspace() {
        let workspace_content = r#"
[workspace]
members = ["."]
"#;

        let bin_content = r#"
[package]
name = "test-bin"
version = "0.1.0"

[[bin]]
name = "test"
"#;

        let temp_dir = tempfile::tempdir().unwrap();
        let workspace_toml = temp_dir.path().join("Cargo.toml");
        std::fs::write(&workspace_toml, workspace_content).unwrap();
        std::fs::write(temp_dir.path().join("Cargo.toml"), bin_content).unwrap();

        let result = validate_crate_type_for_macros(temp_dir.path());
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Binary crates cannot define")
        );
    }

    #[test]
    fn test_validate_binary_with_macros_crate() {
        // Create workspace with macros member
        let workspace_content = r#"
[workspace]
members = ["macros", "app"]
"#;

        let macros_content = r#"
[package]
name = "test-macros"
version = "0.1.0"

[lib]
proc-macro = true
"#;

        let bin_content = r#"
[package]
name = "test-bin"
version = "0.1.0"

[[bin]]
name = "test"
"#;

        let temp_dir = tempfile::tempdir().unwrap();
        let workspace_toml = temp_dir.path().join("Cargo.toml");
        std::fs::write(&workspace_toml, workspace_content).unwrap();

        // Create macros directory with proc-macro crate
        let macros_dir = temp_dir.path().join("macros");
        std::fs::create_dir(&macros_dir).unwrap();
        std::fs::write(macros_dir.join("Cargo.toml"), macros_content).unwrap();

        // Create app directory (simulating binary crate location)
        let app_dir = temp_dir.path().join("app");
        std::fs::create_dir(&app_dir).unwrap();
        std::fs::write(app_dir.join("Cargo.toml"), bin_content).unwrap();

        let result = validate_crate_type_for_macros(&app_dir);
        // Should be ok because we have a macros member with proc-macro = true
        assert!(result.is_ok());
    }
}