topcat 0.1.0

A tool for concatenating files in topological order
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

use std::collections::HashSet;
use std::path::{Path, PathBuf};
use std::{fs, io};

use glob::glob;
use log::error;

pub fn walk_dir(dir: &Path) -> io::Result<HashSet<PathBuf>> {
    let mut _files = HashSet::new();
    if dir.is_dir() {
        match fs::read_dir(dir) {
            Ok(entries) => {
                for entry in entries {
                    match entry {
                        Ok(entry) => {
                            let path = entry.path();
                            if path.is_file() {
                                _files.insert(path);
                            } else if path.is_dir() {
                                for path in walk_dir(&path)? {
                                    _files.insert(path);
                                }
                            }
                        }
                        Err(e) => error!("Unable to read entry in dir: {}", e),
                    }
                }
            }
            Err(e) => error!("Read dir failed: {}", e),
        }
    }
    Ok(_files)
}

pub fn glob_files(glob_patterns: &[String]) -> Result<HashSet<PathBuf>, glob::PatternError> {
    let mut paths = HashSet::new();

    for pattern in glob_patterns {
        let entries = glob(pattern)?;
        for entry in entries {
            if let Ok(path) = entry {
                paths.insert(path);
            } else if let Err(e) = entry {
                error!("Failed to read entry: {:?}", e);
            }
        }
    }

    Ok(paths)
}
#[cfg(test)]
mod tests {
    use tempfile::tempdir;

    use super::*;

    #[test]
    fn test_walk_dir() -> io::Result<()> {
        // Create a temporary directory for testing
        let temp_dir = tempdir()?;
        let temp_path = temp_dir.path();

        // Create a file and a subdirectory within the temporary directory
        let file_path = temp_path.join("file.txt");
        fs::write(&file_path, "Test file")?;

        let subdir_path = temp_path.join("subdir");
        fs::create_dir(&subdir_path)?;

        let subfile_path = subdir_path.join("subfile.txt");
        fs::write(&subfile_path, "Test subfile")?;

        // Call the walk_dir function with the temporary directory
        let result = walk_dir(temp_path)?;

        // Assert the expected files are returned
        assert!(result.contains(&file_path));
        assert!(result.contains(&subfile_path));

        Ok(())
    }

    #[test]
    fn test_glob_files() {
        // Create a temporary directory for testing
        let temp_dir = tempdir().unwrap();
        let temp_path = temp_dir.path();

        // Create files matching the glob pattern within the temporary directory
        let file1_path = temp_path.join("file1.txt");
        fs::write(&file1_path, "Test file 1").unwrap();

        let file2_path = temp_path.join("file2.txt");
        fs::write(&file2_path, "Test file 2").unwrap();

        // Create a glob pattern that matches the files
        let glob_pattern = format!("{}/*.txt", temp_path.display());

        // Call the glob_files function with the glob pattern
        let result = glob_files(&vec![glob_pattern]);

        // Assert the expected files are returned
        match result {
            Ok(files) => {
                assert!(files.contains(&file1_path));
                assert!(files.contains(&file2_path));
            }
            Err(e) => panic!("Error occurred: {:?}", e),
        }
    }
}