swt 5.0.0-rc.1

🍬 Sweet: A blazing-fast code health and architecture analyzer.
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

//! Hierarchical configuration and global state management.

#![deny(
    clippy::panic,
    clippy::unwrap_used,
    clippy::expect_used,
    clippy::pedantic,
    clippy::absolute_paths
)]

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

pub mod analyzer;
pub mod config;
pub mod errors;
pub mod languages;
pub mod report;
pub mod uncomment;
pub mod update;

// Re-export core configuration types for easier access.
pub use config::Config;
pub use config::thresholds::{
    PartialThresholds, RuleSeverities, Severity, Thresholds, ThresholdsConfig,
};

/// A single rule violation with its importance level.
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Issue {
    /// Description of the problem.
    pub message: String,
    /// Importance level.
    pub severity: Severity,
}

/// Analysis results for a single source file.
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct FileReport {
    /// Absolute or relative path to the file.
    pub path: PathBuf,
    /// Measured source lines.
    pub lines: usize,
    /// Measured import count.
    pub imports: usize,
    /// Measured nesting depth.
    pub max_depth: usize,
    /// Measured repetition percentage.
    pub repetition: f64,
    /// True if no Error-level thresholds were exceeded.
    pub is_sweet: bool,
    /// List of descriptive issue messages.
    pub issues: Vec<Issue>,
    /// Effective configuration used for this file.
    pub config: Option<Config>,
    /// Details about duplicated code chunks.
    pub duplicates: Vec<RepetitionDetail>,
    /// Lines where the nesting depth exceeds the threshold.
    pub deep_lines: Vec<(usize, usize)>,
}

/// Details about a specific duplicated code chunk.
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct RepetitionDetail {
    /// The actual code content that is repeated.
    pub content: String,
    /// Starting line number in the file.
    pub line: usize,
    /// Other files where this same chunk appears.
    pub occurrences: Vec<(PathBuf, usize)>,
}

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

    #[test]
    fn test_language_specific_defaults() {
        let config = Config::default();
        let t_rs = config.get_thresholds("rs");
        assert_eq!(t_rs.max_lines, 300);
        assert_eq!(t_rs.max_imports, 30);

        let t_java = config.get_thresholds("java");
        assert_eq!(t_java.max_lines, 500);
    }

    #[test]
    fn test_config_overrides() {
        let mut config = Config::default();
        config.thresholds.overrides.java = Some(PartialThresholds {
            max_imports: Some(100),
            ..Default::default()
        });

        let t = config.get_thresholds("java");
        assert_eq!(t.max_imports, 100);
        assert_eq!(t.max_lines, 500);
    }

    #[test]
    fn test_is_supported_file() {
        assert!(Config::is_supported_file(Path::new("test.rs")));
        assert!(!Config::is_supported_file(Path::new("test.txt")));
    }

    #[cfg(feature = "schema")]
    #[test]
    fn generate_schema() -> miette::Result<()> {
        use schemars::schema_for;
        use std::fs;
        let schema = schema_for!(Config);
        let schema_json = serde_json::to_string_pretty(&schema)
            .map_err(|e| miette::miette!("Failed to serialize schema: {}", e))?;
        fs::write("schema.json", schema_json)
            .map_err(|e| miette::miette!("Failed to write schema.json: {}", e))?;
        Ok(())
    }
}