dynami 0.1.0

Automatic Axum router generation from directory structure with file-system based routing
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

use anyhow::Result;
use std::fs;
use std::path::Path;
use syn::{Item, parse_file};

pub fn detect_appstate(root_mod_path: &Path) -> Result<Option<String>> {
    if !root_mod_path.exists() {
        return Ok(None);
    }

    let content = fs::read_to_string(root_mod_path)?;
    let parsed = parse_file(&content)?;

    // Look for structs with "State" in the name or that have Clone derive
    for item in parsed.items {
        if let Item::Struct(item_struct) = item {
            let name = item_struct.ident.to_string();

            // Check if name contains "State"
            if name.contains("State") {
                return Ok(Some(name));
            }

            // Check for Clone derive as a hint (common for state structs)
            for attr in &item_struct.attrs {
                if attr.path().is_ident("derive") {
                    if let Ok(meta) = attr.parse_args::<syn::Meta>() {
                        let meta_str = quote::quote!(#meta).to_string();
                        if meta_str.contains("Clone") && is_likely_state_name(&name) {
                            return Ok(Some(name));
                        }
                    }
                }
            }
        }
        // Also check for type aliases
        else if let Item::Type(item_type) = item {
            let name = item_type.ident.to_string();
            if name.contains("State") {
                return Ok(Some(name));
            }
        }
    }

    Ok(None)
}

fn is_likely_state_name(name: &str) -> bool {
    // Check if name seems like it could be a state struct
    // Common patterns: AppContext, Context, App, SharedState, etc.
    let lowercase = name.to_lowercase();
    lowercase.contains("context")|| lowercase.contains("app") || lowercase.contains("shared")
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::TempDir;

    #[test]
    fn test_detect_appstate() -> Result<()> {
        let temp = TempDir::new()?;
        let mod_path = temp.path().join("mod.rs");

        let content = r#"
            #[derive(Clone)]
            pub struct AppState {
                pub db: Database,
            }
        "#;

        fs::write(&mod_path, content)?;

        let result = detect_appstate(&mod_path)?;
        assert_eq!(result, Some("AppState".to_string()));

        Ok(())
    }

    #[test]
    fn test_detect_no_state() -> Result<()> {
        let temp = TempDir::new()?;
        let mod_path = temp.path().join("mod.rs");

        let content = r#"
            pub struct User {
                pub name: String,
            }
        "#;

        fs::write(&mod_path, content)?;

        let result = detect_appstate(&mod_path)?;
        assert_eq!(result, None);

        Ok(())
    }

    #[test]
    fn test_detect_custom_state_name() -> Result<()> {
        let temp = TempDir::new()?;
        let mod_path = temp.path().join("mod.rs");

        let content = r#"
            #[derive(Clone)]
            pub struct MyAppState {
                pub config: Config,
            }
        "#;

        fs::write(&mod_path, content)?;

        let result = detect_appstate(&mod_path)?;
        assert_eq!(result, Some("MyAppState".to_string()));

        Ok(())
    }
}