tree-type 0.4.5

Rust macros for creating type-safe filesystem tree structures
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

#![allow(deprecated)]
use tree_type::*;

#[test]
fn test_generic_file_file_name() {
    let file = GenericFile::new("/path/to/file.txt").unwrap();
    assert_eq!(file.file_name(), "file.txt");

    let file = GenericFile::new("simple.txt").unwrap();
    assert_eq!(file.file_name(), "simple.txt");

    // Root path should fail for files since files need a filename component
    assert!(GenericFile::new("/").is_err());
}

#[test]
fn test_generic_dir_file_name() {
    let dir = GenericDir::new("/path/to/directory").unwrap();
    assert_eq!(dir.file_name(), "directory");

    let dir = GenericDir::new("simple_dir").unwrap();
    assert_eq!(dir.file_name(), "simple_dir");

    let dir = GenericDir::new("/").unwrap();
    assert_eq!(dir.file_name(), "");
}

file_type!(TestFile);

#[test]
fn test_generated_file_display() {
    let file = TestFile::new("/tmp/test.txt").unwrap();
    let display_output = format!("{}", file);
    assert_eq!(display_output, "/tmp/test.txt");
}

#[test]
fn test_generated_file_debug() {
    let file = TestFile::new("/tmp/test.txt").unwrap();
    let debug_output = format!("{:?}", file);
    assert!(debug_output.contains("TestFile"));
    assert!(debug_output.contains("/tmp/test.txt"));
}

#[test]
fn test_file_type_file_name() {
    let file = TestFile::new("/path/to/test.txt").unwrap();
    assert_eq!(file.file_name(), "test.txt");

    let file = TestFile::new("config.toml").unwrap();
    assert_eq!(file.file_name(), "config.toml");
}

dir_type!(TestDir);

#[test]
fn test_generated_dir_display() {
    let dir = TestDir::new("/tmp/test_dir").unwrap();
    let display_output = format!("{}", dir);
    assert_eq!(display_output, "/tmp/test_dir");
}

#[test]
fn test_generated_dir_debug() {
    let dir = TestDir::new("/tmp/test_dir").unwrap();
    let debug_output = format!("{:?}", dir);
    assert!(debug_output.contains("TestDir"));
    assert!(debug_output.contains("/tmp/test_dir"));
}

#[test]
fn test_dir_type_file_name() {
    let dir = TestDir::new("/path/to/test_dir").unwrap();
    assert_eq!(dir.file_name(), "test_dir");

    let dir = TestDir::new("src").unwrap();
    assert_eq!(dir.file_name(), "src");
}

tree_type! {
    TestTree {
        config("config.toml"),
        src/
    }
}

#[test]
fn test_generated_tree_display() {
    let tree = TestTree::new("/tmp/test_tree").unwrap();
    let display_output = format!("{}", tree);
    assert_eq!(display_output, "/tmp/test_tree");
}

#[test]
fn test_generated_tree_debug() {
    let tree = TestTree::new("/tmp/test_tree").unwrap();
    let debug_output = format!("{:?}", tree);
    assert!(debug_output.contains("TestTree"));
    assert!(debug_output.contains("/tmp/test_tree"));
}

#[test]
fn test_tree_type_file_name() {
    let tree = TestTree::new("/project").unwrap();
    assert_eq!(tree.file_name(), "project");

    let config = tree.config();
    assert_eq!(config.file_name(), "config.toml");

    let src = tree.src();
    assert_eq!(src.file_name(), "src");
}