ferrous-forge 1.9.4

System-wide Rust development standards enforcer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Ferrous Forge standards checking

use crate::Result;
use std::path::Path;
use std::time::Instant;

use super::SafetyCheck;
use crate::safety::{CheckType, report::CheckResult};

/// Standards check implementation
pub struct StandardsCheck;

impl SafetyCheck for StandardsCheck {
    async fn run(project_path: &Path) -> Result<CheckResult> {
        run(project_path).await
    }

    fn name() -> &'static str {
        "standards"
    }

    fn description() -> &'static str {
        "Validates Ferrous Forge coding standards"
    }
}

/// Run Ferrous Forge standards validation
///
/// # Errors
///
/// Returns an error if the `RustValidator` cannot be created.
pub async fn run(project_path: &Path) -> Result<CheckResult> {
    let start = Instant::now();
    let mut result = CheckResult::new(CheckType::Standards);

    // Use the existing validation module
    let validator = crate::validation::RustValidator::new(project_path.to_path_buf())?;
    match validator.validate_project().await {
        Ok(violations) => {
            result.set_duration(start.elapsed());

            if violations.is_empty() {
                result.add_context("All Ferrous Forge standards met");
            } else {
                result.add_error(format!("Found {} standards violations", violations.len()));

                // Add specific violations (limit to first 5)
                for violation in violations.iter().take(5) {
                    result.add_error(format!(
                        "{:?}: {}",
                        violation.violation_type, violation.message
                    ));
                }

                if violations.len() > 5 {
                    result.add_error(format!("... and {} more violations", violations.len() - 5));
                }

                result.add_suggestion("Run 'ferrous-forge validate' for detailed report");
                result.add_suggestion("Fix standards violations before proceeding");
            }
        }
        Err(e) => {
            result.set_duration(start.elapsed());
            result.add_error(format!("Standards check failed: {}", e));
            result.add_suggestion("Ensure project has valid Cargo.toml and Rust files");
        }
    }

    Ok(result)
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod tests {
    use super::*;

    #[test]
    fn test_standards_check_struct() {
        assert_eq!(StandardsCheck::name(), "standards");
        assert!(!StandardsCheck::description().is_empty());
    }
}