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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Implementation of coding standards methods

use super::types::*;
use crate::Result;

impl CodingStandards {
    /// Load standards from configuration
    ///
    /// # Errors
    ///
    /// Currently infallible, but returns `Result` for future configuration loading.
    pub fn load() -> Result<Self> {
        // For now, return defaults
        // TODO: Load from configuration file or remote source
        Ok(Self::default())
    }

    /// Save standards to configuration
    ///
    /// # Errors
    ///
    /// Currently infallible, but returns `Result` for future configuration saving.
    pub fn save(&self) -> Result<()> {
        // TODO: Save to configuration file
        Ok(())
    }

    /// Get all clippy rules based on these standards
    pub fn get_clippy_rules(&self) -> Vec<String> {
        let mut rules = vec!["-D warnings".to_string()];

        if self.banned_patterns.ban_unwrap {
            rules.push("-D clippy::unwrap_used".to_string());
        }

        if self.banned_patterns.ban_expect {
            rules.push("-D clippy::expect_used".to_string());
        }

        if self.banned_patterns.ban_panic {
            rules.push("-D clippy::panic".to_string());
        }

        if self.banned_patterns.ban_todo {
            rules.push("-D clippy::todo".to_string());
        }

        if self.banned_patterns.ban_unimplemented {
            rules.push("-D clippy::unimplemented".to_string());
        }

        if self.documentation.require_public_docs {
            rules.push("-D missing_docs".to_string());
        }

        if self.security.ban_unsafe {
            rules.push("-F unsafe_code".to_string());
        }

        // Add performance and style lints
        rules.extend([
            "-W clippy::pedantic".to_string(),
            "-W clippy::nursery".to_string(),
            "-W clippy::cargo".to_string(),
            "-D clippy::dbg_macro".to_string(),
            "-D clippy::print_stdout".to_string(),
            "-D clippy::print_stderr".to_string(),
        ]);

        rules
    }

    /// Generate clippy.toml configuration
    pub fn generate_clippy_config(&self) -> String {
        format!(
            r#"# Ferrous Forge - Rust Standards Enforcement
# Generated automatically - do not edit manually

msrv = "{}"
max-fn-params-bools = 2
max-struct-bools = 2
max-trait-bounds = 2
max-include-file-size = {}
min-ident-chars-threshold = 2
literal-representation-threshold = 1000
check-private-items = {}
missing-docs-allow-unused = false
allow-comparison-to-zero = false
allow-mixed-uninlined-format-args = false
allow-one-hash-in-raw-strings = false
allow-useless-vec-in-tests = false
allow-indexing-slicing-in-tests = false
allowed-idents-below-min-chars = ["i", "j", "x", "y", "z"]
allowed-wildcard-imports = []
allow-exact-repetitions = false
allow-private-module-inception = false
too-large-for-stack = 100
upper-case-acronyms-aggressive = true
allowed-scripts = ["Latin"]
disallowed-names = ["foo", "bar", "baz", "qux", "quux", "test", "tmp", "temp"]
unreadable-literal-lint-fractions = true
semicolon-inside-block-ignore-singleline = false
semicolon-outside-block-ignore-multiline = false
arithmetic-side-effects-allowed = []
"#,
            self.edition.min_rust_version,
            self.file_limits.max_lines * 1000, // Convert to bytes approximation
            self.documentation.require_private_docs,
        )
    }

    /// Check if a project complies with these standards
    ///
    /// # Errors
    ///
    /// Returns an error if reading `Cargo.toml` fails.
    pub async fn check_compliance(&self, project_path: &std::path::Path) -> Result<Vec<String>> {
        let mut violations = Vec::new();

        // Check Cargo.toml for edition
        let cargo_toml = project_path.join("Cargo.toml");
        if cargo_toml.exists() {
            let content = tokio::fs::read_to_string(&cargo_toml).await?;
            if !content.contains(&format!(r#"edition = "{}""#, self.edition.required_edition)) {
                violations.push(format!(
                    "Project must use Rust Edition {}",
                    self.edition.required_edition
                ));
            }
        }

        // Additional compliance checks would go here

        Ok(violations)
    }
}