dx-driven 0.1.0

Professional AI-assisted development orchestrator with binary-first architecture
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

//! Convention extractor

use super::{NamingConventions, NamingStyle, scanner::ScanResult};
use crate::Result;

/// Extracts coding conventions from a project
#[derive(Debug, Default)]
pub struct ConventionExtractor;

impl ConventionExtractor {
    /// Create a new convention extractor
    pub fn new() -> Self {
        Self
    }

    /// Extract naming conventions from scan results
    pub fn extract(&self, scan_result: &ScanResult) -> Result<NamingConventions> {
        let mut conventions = NamingConventions::default();

        // Detect conventions based on languages
        if scan_result.languages.contains(&"Rust".to_string()) {
            conventions.functions = Some(NamingStyle::SnakeCase);
            conventions.types = Some(NamingStyle::PascalCase);
            conventions.variables = Some(NamingStyle::SnakeCase);
            conventions.files = Some(NamingStyle::SnakeCase);
        } else if scan_result.languages.contains(&"TypeScript".to_string())
            || scan_result.languages.contains(&"JavaScript".to_string())
        {
            conventions.functions = Some(NamingStyle::CamelCase);
            conventions.types = Some(NamingStyle::PascalCase);
            conventions.variables = Some(NamingStyle::CamelCase);
            conventions.files = Some(NamingStyle::KebabCase);
        } else if scan_result.languages.contains(&"Python".to_string()) {
            conventions.functions = Some(NamingStyle::SnakeCase);
            conventions.types = Some(NamingStyle::PascalCase);
            conventions.variables = Some(NamingStyle::SnakeCase);
            conventions.files = Some(NamingStyle::SnakeCase);
        } else if scan_result.languages.contains(&"Go".to_string()) {
            conventions.functions = Some(NamingStyle::CamelCase);
            conventions.types = Some(NamingStyle::PascalCase);
            conventions.variables = Some(NamingStyle::CamelCase);
            conventions.files = Some(NamingStyle::SnakeCase);
        }

        Ok(conventions)
    }
}

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

    #[test]
    fn test_extract_rust_conventions() {
        let extractor = ConventionExtractor::new();
        let scan_result = ScanResult {
            languages: vec!["Rust".to_string()],
            ..Default::default()
        };

        let conventions = extractor.extract(&scan_result).unwrap();
        assert_eq!(conventions.functions, Some(NamingStyle::SnakeCase));
        assert_eq!(conventions.types, Some(NamingStyle::PascalCase));
    }

    #[test]
    fn test_extract_typescript_conventions() {
        let extractor = ConventionExtractor::new();
        let scan_result = ScanResult {
            languages: vec!["TypeScript".to_string()],
            ..Default::default()
        };

        let conventions = extractor.extract(&scan_result).unwrap();
        assert_eq!(conventions.functions, Some(NamingStyle::CamelCase));
        assert_eq!(conventions.types, Some(NamingStyle::PascalCase));
    }
}