tree-type-proc-macro 0.2.0

Procedural macros for tree-type crate
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

use std::path::Path;
use tree_type_proc_macro::tree_type;

// Test basic navigation
tree_type! {
    TestRoot {
        config,
        src/ {
            lib,
            main
        }
    }
}

#[test]
fn test_basic_navigation() {
    let root = TestRoot::new("/tmp/test").unwrap();

    // Test root path
    assert_eq!(root.as_path(), Path::new("/tmp/test"));

    // Test file navigation
    let config = root.config();
    assert_eq!(config.as_path(), Path::new("/tmp/test/config"));

    // Test directory navigation
    let src = root.src();
    assert_eq!(src.as_path(), Path::new("/tmp/test/src"));

    // Test nested navigation
    let lib = src.lib();
    assert_eq!(lib.as_path(), Path::new("/tmp/test/src/lib"));

    let main = src.main();
    assert_eq!(main.as_path(), Path::new("/tmp/test/src/main"));
}

// Test custom filenames
tree_type! {
    CustomRoot {
        config(".config"),
        ssh/(".ssh") {
            key("id_rsa")
        }
    }
}

#[test]
fn test_custom_filenames() {
    let root = CustomRoot::new("/home/user").unwrap();

    let config = root.config();
    assert_eq!(config.as_path(), Path::new("/home/user/.config"));

    let ssh = root.ssh();
    assert_eq!(ssh.as_path(), Path::new("/home/user/.ssh"));

    let key = ssh.key();
    assert_eq!(key.as_path(), Path::new("/home/user/.ssh/id_rsa"));
}

// Test custom types
tree_type! {
    TypedRoot {
        config as ConfigFile,
        data/ as DataDir {
            settings as SettingsFile
        }
    }
}

#[test]
fn test_custom_types() {
    let root = TypedRoot::new("/app").unwrap();

    let config: ConfigFile = root.config();
    assert_eq!(config.as_path(), Path::new("/app/config"));

    let data: DataDir = root.data();
    assert_eq!(data.as_path(), Path::new("/app/data"));

    let settings: SettingsFile = data.settings();
    assert_eq!(settings.as_path(), Path::new("/app/data/settings"));
}

// Test nested directories (3+ levels)
tree_type! {
    DeepRoot {
        a/ {
            b/ {
                c/ {
                    d
                }
            }
        }
    }
}

#[test]
fn test_deep_nesting() {
    let root = DeepRoot::new("/deep").unwrap();

    let a = root.a();
    assert_eq!(a.as_path(), Path::new("/deep/a"));

    let b = a.b();
    assert_eq!(b.as_path(), Path::new("/deep/a/b"));

    let c = b.c();
    assert_eq!(c.as_path(), Path::new("/deep/a/b/c"));

    let d = c.d();
    assert_eq!(d.as_path(), Path::new("/deep/a/b/c/d"));
}