use std::collections::{HashMap, HashSet};
use std::ffi::OsStr;
use std::marker::PhantomData;
#[cfg(windows)]
use std::path::MAIN_SEPARATOR_STR;
use std::path::{Component, Path, PathBuf};
use std::time::SystemTime;
use chrono::{DateTime, TimeZone, Utc};
use glob::{MatchOptions, Pattern};
use multimap::MultiMap;
use path_clean::PathClean;
use crate::config::{Config, FileKind};
use crate::error::{MyError, MyResult};
use crate::file::File;
use crate::metadata::Metadata;
use crate::regex;
use crate::system::{Entry, Flags, System};
use crate::total::Total;
#[cfg(windows)]
use crate::version::inner::get_version;
#[allow(dead_code)]
pub struct Finder<'a, F, E, I, S> where
F: Flags + Copy,
E: Entry<F>,
I: Iterator<Item = MyResult<E>>,
S: System<F, E, I>,
{
config: &'a Config,
system: &'a S,
current: PathBuf,
options: MatchOptions,
start_time: Option<DateTime<Utc>>,
git_bash: bool,
phantom: PhantomData<(F, E, I)>,
}
impl<'a, F, E, I, S> Finder<'a, F, E, I, S> where
F: Flags + Copy,
E: Entry<F>,
I: Iterator<Item = MyResult<E>>,
S: System<F, E, I>,
{
pub fn new<Tz: TimeZone>(
config: &'a Config,
system: &'a S,
zone: &Tz,
current: PathBuf,
git_bash: bool,
) -> Finder<'a, F, E, I, S> {
let options = Self::match_options(config);
let start_time = config.start_time(zone);
return Self {
config,
system,
current,
options,
start_time,
git_bash,
phantom: PhantomData,
};
}
#[cfg(windows)]
fn match_options(config: &Config) -> MatchOptions {
let mut options = MatchOptions::new();
options.case_sensitive = config.case_sensitive.unwrap_or(false);
return options;
}
#[cfg(not(windows))]
fn match_options(config: &Config) -> MatchOptions {
let mut options = MatchOptions::new();
options.case_sensitive = config.case_sensitive.unwrap_or(true);
return options;
}
pub fn find_files(&self) -> MyResult<Vec<File>> {
let mut files = HashSet::new();
let tasks = self.group_tasks()?;
for ((abs_root, rel_root), patterns) in tasks.iter_all() {
self.find_entries(&mut files, abs_root, rel_root, patterns);
self.find_parents(&mut files, abs_root, rel_root)?;
}
let files = files.into_iter().collect();
return Ok(files);
}
pub fn create_total(&self, files: &Vec<File>) -> Total {
Total::from_files(self.start_time, self.config, files)
}
fn group_tasks(&self) -> MyResult<MultiMap<(PathBuf, PathBuf), Pattern>> {
let mut tasks = MultiMap::new();
for pattern in &self.config.patterns {
if let Some((abs_root, rel_root, filename)) = self.parse_pattern(pattern) {
let pattern = Pattern::new(&filename)?;
tasks.insert((abs_root, rel_root), pattern);
}
}
return Ok(tasks);
}
#[cfg(windows)]
fn parse_pattern(&self, pattern: &str) -> Option<(PathBuf, PathBuf, String)> {
return if self.git_bash {
let drive_regex = regex!(r#"^/([A-Za-z])/(.+)$"#);
if let Some(captures) = drive_regex.captures(pattern) {
let drive = captures.get(1).unwrap().as_str().to_uppercase();
let path = captures.get(2).unwrap().as_str().replace("/", MAIN_SEPARATOR_STR);
let pattern = format!("{}:{}{}", drive, MAIN_SEPARATOR_STR, path);
self.split_pattern(&pattern)
} else {
let pattern = pattern.replace("/", MAIN_SEPARATOR_STR);
self.split_pattern(&pattern)
}
} else {
self.split_pattern(pattern)
}
}
#[cfg(not(windows))]
fn parse_pattern(&self, pattern: &str) -> Option<(PathBuf, PathBuf, String)> {
self.split_pattern(pattern)
}
fn split_pattern(&self, pattern: &str) -> Option<(PathBuf, PathBuf, String)> {
let wildcard = requires_wildcard(pattern);
let rel_root = PathBuf::from(pattern);
let abs_root = self.current.join(&rel_root).clean();
if wildcard {
return Some((abs_root, rel_root, String::from("*")));
}
if let Some(mut name) = find_name(&abs_root) {
if let Some(abs_root) = find_parent(&abs_root) {
if let Some(rel_root) = find_parent(&rel_root) {
if name.starts_with(".") {
name = format!("*{name}");
}
return Some((abs_root, rel_root, name));
}
}
}
return None;
}
fn find_entries(
&self,
files: &mut HashSet<File>,
abs_root: &Path,
rel_root: &Path,
patterns: &Vec<Pattern>,
) {
let rel_depth = count_components(rel_root);
for entry in self.system.entries(abs_root, rel_root) {
match entry.and_then(|entry| self.create_file(&entry, abs_root, rel_root, rel_depth, patterns)) {
Ok(file) => {
if let Some(file) = file {
if !self.config.order_name || self.config.show_indent || (file.file_type != FileKind::Dir) {
files.insert(file);
}
}
}
Err(error) => {
error.eprint();
}
}
}
}
fn find_parents(
&self,
files: &mut HashSet<File>,
abs_root: &Path,
rel_root: &Path,
) -> MyResult<()> {
if self.config.show_indent {
let mut parents = HashMap::new();
for file in files.iter() {
let file_depth = file.file_depth + match file.file_type {
FileKind::File(_) => 0,
FileKind::Dir => 1,
FileKind::Link(_) => 0,
FileKind::Other => 0,
};
find_ancestors(&mut parents, &file.abs_dir, file_depth)?;
}
for (parent, depth) in parents.into_iter() {
match self.create_parent(abs_root, rel_root, parent, depth) {
Ok(file) => {
if let Some(file) = file {
files.insert(file);
}
}
Err(error) => {
error.eprint();
}
}
}
}
return Ok(());
}
fn create_file(
&self,
entry: &E,
abs_root: &Path,
rel_root: &Path,
rel_depth: usize,
patterns: &Vec<Pattern>,
) -> MyResult<Option<File>> {
if let Some(name) = entry.file_name().to_str() {
if patterns.iter().any(|p| p.matches_with(name, self.options)) {
if let Some(depth) = self.config.min_depth {
if entry.depth() < depth {
return Ok(None);
}
}
let mut file_data = entry.metadata()?;
let file_type = entry.file_type();
let file_type = FileKind::from_type(self.system, file_type, &file_data);
if let Some(filter_types) = &self.config.filter_types {
if !filter_types.contains(&file_type) {
return Ok(None);
}
}
let link_path = entry.read_link()?;
if let Some(link_path) = link_path {
if let Some((link_path, link_data)) = self.follow_link(entry.path(), &link_path) {
let link_type = FileKind::from_type(self.system, link_data.file_type, &link_data);
return self.create_inner(
entry,
abs_root,
rel_root,
rel_depth,
file_type,
link_data,
Some((link_path, link_type)),
);
} else {
file_data.file_size = 0;
file_data.file_time = SystemTime::UNIX_EPOCH;
return self.create_inner(
entry,
abs_root,
rel_root,
rel_depth,
FileKind::Link(false),
file_data,
Some((link_path, FileKind::Link(false))),
);
}
} else {
return self.create_inner(
entry,
abs_root,
rel_root,
rel_depth,
file_type,
file_data,
None,
);
}
}
}
return Ok(None);
}
fn follow_link(&self, file_path: &Path, link_path: &Path) -> Option<(PathBuf, Metadata<F>)> {
if let Some(file_parent) = file_path.parent() {
let link_path = file_parent.join(link_path);
if let Some(link_data) = self.system.metadata(&link_path).ok() {
return Some((link_path, link_data));
}
}
return None;
}
fn create_inner(
&self,
entry: &E,
abs_root: &Path,
rel_root: &Path,
rel_depth: usize,
file_type: FileKind,
file_data: Metadata<F>,
link_data: Option<(PathBuf, FileKind)>,
) -> MyResult<Option<File>> {
let file_time = DateTime::<Utc>::from(file_data.file_time);
if let Some(start_time) = self.start_time {
if file_time < start_time {
return Ok(None);
}
}
let abs_path = entry.path();
if let Some(rel_path) = create_relative(abs_root, rel_root, abs_path) {
if let Some(abs_dir) = select_parent(abs_path, file_type) {
if let Some(rel_dir) = select_parent_from_owned(rel_path, file_type) {
let file_depth = entry.depth() + rel_depth;
let file_name = select_name(abs_path, file_type).unwrap_or_default();
let file_ext = find_extension(abs_path, file_type);
let file_size = select_size(&file_data, &link_data, file_type);
let mut file = File::new(abs_dir, rel_dir, file_depth, file_name, file_ext, file_type)
.with_mode(file_data.file_mode)
.with_size(file_size)
.with_time(file_time);
#[cfg(unix)]
if self.config.show_owner {
let user = self.system.find_user(file_data.owner_uid);
let group = self.system.find_group(file_data.owner_gid);
file = file.with_owner(user, group);
}
#[cfg(windows)]
if self.config.win_ver {
if let Some(file_ver) = get_version(abs_path) {
file = file.with_version(file_ver);
}
}
if let Some((link_path, link_type)) = link_data {
file = file.with_link(link_path, link_type);
}
return Ok(Some(file));
}
}
}
return Ok(None);
}
fn create_parent(
&self,
abs_root: &Path,
rel_root: &Path,
abs_path: PathBuf,
file_depth: usize,
) -> MyResult<Option<File>> {
let file_data = self.system.metadata(&abs_path)?;
if let Some(rel_path) = create_relative(abs_root, rel_root, &abs_path) {
if let Some(abs_dir) = select_parent_from_owned(abs_path, FileKind::Dir) {
if let Some(rel_dir) = select_parent_from_owned(rel_path, FileKind::Dir) {
let file_time = DateTime::<Utc>::from(file_data.file_time);
let file = File::new(abs_dir, rel_dir, file_depth, String::from(""), String::from(""), FileKind::Dir)
.with_mode(file_data.file_mode)
.with_time(file_time);
return Ok(Some(file));
}
}
}
return Ok(None);
}
}
fn requires_wildcard(pattern: &str) -> bool {
let wildcard_regex = regex!(r"(^\.+$|[\\/]\.*$)");
return wildcard_regex.is_match(pattern);
}
fn count_components(path: &Path) -> usize {
let mut count = 0;
for component in path.components() {
if let Component::Normal(_) = component {
count += 1;
}
}
return count;
}
fn find_ancestors(
parents: &mut HashMap<PathBuf, usize>,
abs_path: &Path,
file_depth: usize,
) -> MyResult<()> {
if file_depth > 1 {
if let Some(old_depth) = parents.insert(PathBuf::from(abs_path), file_depth - 1) {
if old_depth != file_depth - 1 {
let error = format!("Inconsistent depth: {}", abs_path.display());
return Err(MyError::Text(error));
}
} else {
if let Some(abs_path) = abs_path.parent() {
find_ancestors(parents, abs_path, file_depth - 1)?;
}
}
}
return Ok(());
}
fn create_relative(
abs_root: &Path,
rel_root: &Path,
abs_path: &Path,
) -> Option<PathBuf> {
let mut abs_root = PathBuf::from(abs_root);
let mut rel_path = PathBuf::new();
loop {
if let Ok(path) = abs_path.strip_prefix(&abs_root) {
rel_path.push(path);
return Some(rel_root.join(rel_path).clean());
}
if !abs_root.pop() {
return None;
}
rel_path.push("..");
}
}
fn select_parent_from_owned(path: PathBuf, file_type: FileKind) -> Option<PathBuf> {
if file_type == FileKind::Dir {
Some(path)
} else {
find_parent(&path)
}
}
fn select_parent(path: &Path, file_type: FileKind) -> Option<PathBuf> {
if file_type == FileKind::Dir {
Some(PathBuf::from(path))
} else {
find_parent(path)
}
}
fn select_name(path: &Path, file_type: FileKind) -> Option<String> {
if file_type == FileKind::Dir {
Some(String::from(""))
} else {
find_name(path)
}
}
fn find_parent(path: &Path) -> Option<PathBuf> {
path.parent().map(PathBuf::from)
}
fn find_name(path: &Path) -> Option<String> {
path.file_name().and_then(OsStr::to_str).map(String::from)
}
fn find_extension(path: &Path, file_type: FileKind) -> String {
match file_type {
FileKind::File(_) | FileKind::Link(_) => path.extension()
.and_then(OsStr::to_str)
.map(|ext| format!(".{ext}"))
.unwrap_or_default(),
_ => String::default(),
}
}
fn select_size<F: Flags + Copy>(
file_data: &Metadata<F>,
link_data: &Option<(PathBuf, FileKind)>,
file_type: FileKind,
) -> u64 {
if file_type == FileKind::Dir {
return 0;
}
if let Some((_, link_type)) = link_data {
if *link_type == FileKind::Dir {
return 0;
}
}
return file_data.file_size;
}
#[cfg(test)]
#[allow(unexpected_cfgs)]
mod tests {
use chrono::TimeZone;
use pretty_assertions::assert_eq;
use crate::config::{ExecKind, RecentKind};
use crate::system::tests::{MockEntry, MockFlags, MockIterator, MockSystem};
use super::*;
#[test]
fn test_requires_wildcard() {
assert_eq!(true, requires_wildcard("."));
assert_eq!(true, requires_wildcard(".."));
assert_eq!(false, requires_wildcard("file"));
assert_eq!(true, requires_wildcard("/path/to/dir/"));
assert_eq!(true, requires_wildcard("/path/to/dir/."));
assert_eq!(true, requires_wildcard("/path/to/dir/.."));
assert_eq!(false, requires_wildcard("/path/to/dir/file"));
assert_eq!(true, requires_wildcard(r"\path\to\dir\"));
assert_eq!(true, requires_wildcard(r"\path\to\dir\."));
assert_eq!(true, requires_wildcard(r"\path\to\dir\.."));
assert_eq!(false, requires_wildcard(r"\path\to\dir\file"));
}
#[test]
#[cfg(all(windows, disabled))]
fn test_counts_components() {
assert_eq!(0, count_components(&PathBuf::from(r"")));
assert_eq!(0, count_components(&PathBuf::from(r"..")));
assert_eq!(1, count_components(&PathBuf::from(r"..\dir")));
assert_eq!(2, count_components(&PathBuf::from(r"..\dir\subdir")));
assert_eq!(0, count_components(&PathBuf::from(r".")));
assert_eq!(1, count_components(&PathBuf::from(r".\dir")));
assert_eq!(2, count_components(&PathBuf::from(r".\dir\subdir")));
assert_eq!(1, count_components(&PathBuf::from(r"dir")));
assert_eq!(2, count_components(&PathBuf::from(r"dir\subdir")));
assert_eq!(1, count_components(&PathBuf::from(r"\dir")));
assert_eq!(2, count_components(&PathBuf::from(r"\dir\subdir")));
assert_eq!(1, count_components(&PathBuf::from(r"D:\dir")));
assert_eq!(2, count_components(&PathBuf::from(r"D:\dir\subdir")));
assert_eq!(1, count_components(&PathBuf::from(r"\\unc\dir")));
assert_eq!(2, count_components(&PathBuf::from(r"\\unc\dir\subdir")));
}
#[test]
#[cfg(not(windows))]
fn test_counts_components() {
assert_eq!(0, count_components(&PathBuf::from("")));
assert_eq!(0, count_components(&PathBuf::from("..")));
assert_eq!(1, count_components(&PathBuf::from("../dir")));
assert_eq!(2, count_components(&PathBuf::from("../dir/subdir")));
assert_eq!(0, count_components(&PathBuf::from(".")));
assert_eq!(1, count_components(&PathBuf::from("./dir")));
assert_eq!(2, count_components(&PathBuf::from("./dir/subdir")));
assert_eq!(1, count_components(&PathBuf::from("dir")));
assert_eq!(2, count_components(&PathBuf::from("dir/subdir")));
assert_eq!(1, count_components(&PathBuf::from("/dir")));
assert_eq!(2, count_components(&PathBuf::from("/dir/subdir")));
}
#[test]
fn test_creates_relative_paths() {
assert_eq!(Some(PathBuf::from("..")), test_relative("/root"));
assert_eq!(Some(PathBuf::from("../dir")), test_relative("/root/dir"));
assert_eq!(Some(PathBuf::from("../dir/subdir")), test_relative("/root/dir/subdir"));
assert_eq!(Some(PathBuf::from("../dir2")), test_relative("/root/dir2"));
assert_eq!(Some(PathBuf::from("../dir2/subdir")), test_relative("/root/dir2/subdir"));
assert_eq!(Some(PathBuf::from("../..")), test_relative("/"));
assert_eq!(Some(PathBuf::from("../../root2/dir")), test_relative("/root2/dir"));
assert_eq!(Some(PathBuf::from("../../root2/dir/subdir")), test_relative("/root2/dir/subdir"));
}
fn test_relative(abs_path: &str) -> Option<PathBuf> {
let abs_root = PathBuf::from("/root/dir");
let rel_root = PathBuf::from("../dir");
let abs_path = PathBuf::from(abs_path);
return create_relative(&abs_root, &rel_root, &abs_path);
}
#[test]
fn test_parses_file_attributes_no_indent_in_root_directory() {
let config = Config::default()
.with_patterns(vec!["*"]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
assert_eq!(10, files.len());
assert_data(files.get(0), 1, FileKind::File(ExecKind::User), 0o744, 100, 2023, 1, 1);
assert_data(files.get(1), 1, FileKind::Dir, 0o755, 0, 2023, 2, 2);
assert_data(files.get(2), 2, FileKind::Link(true), 0o755, 0, 2023, 3, 3);
assert_data(files.get(3), 2, FileKind::Link(true), 0o644, 500, 2023, 5, 5);
assert_data(files.get(4), 2, FileKind::Link(false), 0o644, 0, 1970, 1, 1);
assert_data(files.get(5), 2, FileKind::Dir, 0o755, 0, 2023, 3, 3);
assert_data(files.get(6), 3, FileKind::File(ExecKind::None), 0o644, 400, 2023, 4, 4);
assert_data(files.get(7), 3, FileKind::File(ExecKind::None), 0o644, 500, 2023, 5, 5);
assert_data(files.get(8), 3, FileKind::File(ExecKind::None), 0o644, 600, 2023, 6, 6);
assert_data(files.get(9), 3, FileKind::File(ExecKind::None), 0o644, 700, 2023, 7, 7);
assert_path(files.get(0), "/root", "", "archive.sh", ".sh");
assert_path(files.get(1), "/root/dir", "dir", "", "");
assert_path(files.get(2), "/root/dir", "dir", "link1", "");
assert_path(files.get(3), "/root/dir", "dir", "link2", "");
assert_path(files.get(4), "/root/dir", "dir", "link3", "");
assert_path(files.get(5), "/root/dir/subdir", "dir/subdir", "", "");
assert_path(files.get(6), "/root/dir/subdir", "dir/subdir", "alpha.csv", ".csv");
assert_path(files.get(7), "/root/dir/subdir", "dir/subdir", "alpha.txt", ".txt");
assert_path(files.get(8), "/root/dir/subdir", "dir/subdir", "beta.csv", ".csv");
assert_path(files.get(9), "/root/dir/subdir", "dir/subdir", "beta.txt", ".txt");
assert_link(files.get(0), None);
assert_link(files.get(1), None);
assert_link(files.get(2), Some((FileKind::Dir, "/root/dir/subdir")));
assert_link(files.get(3), Some((FileKind::File(ExecKind::None), "/root/dir/subdir/alpha.txt")));
assert_link(files.get(4), Some((FileKind::Link(false), "/etc/missing.txt")));
assert_link(files.get(5), None);
assert_link(files.get(6), None);
assert_link(files.get(7), None);
assert_link(files.get(8), None);
assert_link(files.get(9), None);
}
#[test]
fn test_parses_file_attributes_no_indent_in_branch_directory() {
let config = Config::default()
.with_patterns(vec!["dir/*"]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
assert_eq!(9, files.len());
assert_data(files.get(0), 1, FileKind::Dir, 0o755, 0, 2023, 2, 2);
assert_data(files.get(1), 2, FileKind::Link(true), 0o755, 0, 2023, 3, 3);
assert_data(files.get(2), 2, FileKind::Link(true), 0o644, 500, 2023, 5, 5);
assert_data(files.get(3), 2, FileKind::Link(false), 0o644, 0, 1970, 1, 1);
assert_data(files.get(4), 2, FileKind::Dir, 0o755, 0, 2023, 3, 3);
assert_data(files.get(5), 3, FileKind::File(ExecKind::None), 0o644, 400, 2023, 4, 4);
assert_data(files.get(6), 3, FileKind::File(ExecKind::None), 0o644, 500, 2023, 5, 5);
assert_data(files.get(7), 3, FileKind::File(ExecKind::None), 0o644, 600, 2023, 6, 6);
assert_data(files.get(8), 3, FileKind::File(ExecKind::None), 0o644, 700, 2023, 7, 7);
assert_path(files.get(0), "/root/dir", "dir", "", "");
assert_path(files.get(1), "/root/dir", "dir", "link1", "");
assert_path(files.get(2), "/root/dir", "dir", "link2", "");
assert_path(files.get(3), "/root/dir", "dir", "link3", "");
assert_path(files.get(4), "/root/dir/subdir", "dir/subdir", "", "");
assert_path(files.get(5), "/root/dir/subdir", "dir/subdir", "alpha.csv", ".csv");
assert_path(files.get(6), "/root/dir/subdir", "dir/subdir", "alpha.txt", ".txt");
assert_path(files.get(7), "/root/dir/subdir", "dir/subdir", "beta.csv", ".csv");
assert_path(files.get(8), "/root/dir/subdir", "dir/subdir", "beta.txt", ".txt");
assert_link(files.get(0), None);
assert_link(files.get(1), Some((FileKind::Dir, "/root/dir/subdir")));
assert_link(files.get(2), Some((FileKind::File(ExecKind::None), "/root/dir/subdir/alpha.txt")));
assert_link(files.get(3), Some((FileKind::Link(false), "/etc/missing.txt")));
assert_link(files.get(4), None);
assert_link(files.get(5), None);
assert_link(files.get(6), None);
assert_link(files.get(7), None);
assert_link(files.get(8), None);
}
#[test]
fn test_parses_file_attributes_with_indent_in_root_directory() {
let config = Config::default()
.with_patterns(vec!["*"])
.with_show_indent(true)
.with_filter_types(vec![
FileKind::File(ExecKind::None),
FileKind::File(ExecKind::User),
FileKind::File(ExecKind::Other),
FileKind::Link(false),
FileKind::Link(true),
]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
assert_eq!(10, files.len());
assert_data(files.get(0), 1, FileKind::File(ExecKind::User), 0o744, 100, 2023, 1, 1);
assert_data(files.get(1), 1, FileKind::Dir, 0o755, 0, 2023, 2, 2);
assert_data(files.get(2), 2, FileKind::Link(true), 0o755, 0, 2023, 3, 3);
assert_data(files.get(3), 2, FileKind::Link(true), 0o644, 500, 2023, 5, 5);
assert_data(files.get(4), 2, FileKind::Link(false), 0o644, 0, 1970, 1, 1);
assert_data(files.get(5), 2, FileKind::Dir, 0o755, 0, 2023, 3, 3);
assert_data(files.get(6), 3, FileKind::File(ExecKind::None), 0o644, 400, 2023, 4, 4);
assert_data(files.get(7), 3, FileKind::File(ExecKind::None), 0o644, 500, 2023, 5, 5);
assert_data(files.get(8), 3, FileKind::File(ExecKind::None), 0o644, 600, 2023, 6, 6);
assert_data(files.get(9), 3, FileKind::File(ExecKind::None), 0o644, 700, 2023, 7, 7);
assert_path(files.get(0), "/root", "", "archive.sh", ".sh");
assert_path(files.get(1), "/root/dir", "dir", "", "");
assert_path(files.get(2), "/root/dir", "dir", "link1", "");
assert_path(files.get(3), "/root/dir", "dir", "link2", "");
assert_path(files.get(4), "/root/dir", "dir", "link3", "");
assert_path(files.get(5), "/root/dir/subdir", "dir/subdir", "", "");
assert_path(files.get(6), "/root/dir/subdir", "dir/subdir", "alpha.csv", ".csv");
assert_path(files.get(7), "/root/dir/subdir", "dir/subdir", "alpha.txt", ".txt");
assert_path(files.get(8), "/root/dir/subdir", "dir/subdir", "beta.csv", ".csv");
assert_path(files.get(9), "/root/dir/subdir", "dir/subdir", "beta.txt", ".txt");
assert_link(files.get(0), None);
assert_link(files.get(1), None);
assert_link(files.get(2), Some((FileKind::Dir, "/root/dir/subdir")));
assert_link(files.get(3), Some((FileKind::File(ExecKind::None), "/root/dir/subdir/alpha.txt")));
assert_link(files.get(4), Some((FileKind::Link(false), "/etc/missing.txt")));
assert_link(files.get(5), None);
assert_link(files.get(6), None);
assert_link(files.get(7), None);
assert_link(files.get(8), None);
assert_link(files.get(9), None);
}
#[test]
fn test_finds_multiple_patterns_in_same_directory() {
let expected = vec![
"/root/dir/subdir/alpha.csv",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["dir/subdir/alpha.*", "dir/subdir/*.txt"]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_finds_multiple_patterns_in_diff_directories() {
let expected = vec![
"/root/dir/subdir/alpha.csv",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["dir/alpha.*", "dir/subdir/*.txt"]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_finds_files_if_recurse_no_indent_in_root_directory() {
let expected = vec![
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["*.txt"]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_finds_parents_if_recurse_with_indent_in_root_directory() {
let expected = vec![
"/root/dir/",
"/root/dir/subdir/",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["*.txt"])
.with_show_indent(true);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_finds_parents_if_recurse_with_indent_in_branch_directory() {
let expected = vec![
"/root/dir/",
"/root/dir/subdir/",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["dir/*.txt"])
.with_show_indent(true);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_finds_parents_if_recurse_with_indent_in_leaf_directory() {
let expected = vec![
"/root/dir/",
"/root/dir/subdir/",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["dir/subdir/*.txt"])
.with_show_indent(true);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_hides_directories_if_order_by_name() {
let expected = vec![
"/root/archive.sh",
"/root/dir/link1",
"/root/dir/link2",
"/root/dir/link3",
"/root/dir/subdir/alpha.csv",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.csv",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["*"])
.with_order_name(true);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_finds_files_with_bare_filename() {
let expected = vec![
"/root/dir/subdir/beta.csv",
];
let config = Config::default()
.with_patterns(vec!["beta.csv"]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_finds_files_with_bare_extension() {
let expected = vec![
"/root/dir/subdir/alpha.csv",
"/root/dir/subdir/beta.csv",
];
let config = Config::default()
.with_patterns(vec![".csv"]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_filters_files_by_minimum_depth() {
let expected = vec![
"/root/dir/link1",
"/root/dir/link2",
"/root/dir/link3",
"/root/dir/subdir/",
"/root/dir/subdir/alpha.csv",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.csv",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["*"])
.with_min_depth(2);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_filters_files_by_maximum_depth() {
let expected = vec![
"/root/archive.sh",
"/root/dir/",
"/root/dir/link1",
"/root/dir/link2",
"/root/dir/link3",
"/root/dir/subdir/",
];
let config = Config::default()
.with_patterns(vec!["*"])
.with_max_depth(2);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_filters_files_by_file_type() {
let expected = vec![
"/root/archive.sh",
"/root/dir/subdir/alpha.csv",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.csv",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["*"])
.with_filter_types(vec![
FileKind::File(ExecKind::None),
FileKind::File(ExecKind::User),
FileKind::File(ExecKind::Other),
]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_filters_files_by_recent_time() {
let expected = vec![
"/root/dir/link2",
"/root/dir/subdir/alpha.txt",
"/root/dir/subdir/beta.csv",
"/root/dir/subdir/beta.txt",
];
let config = Config::default()
.with_patterns(vec!["*"])
.with_curr_time(2024, 1, 1, 0, 0, 0)
.with_filter_recent(RecentKind::Month(8));
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_calculates_total_from_files() {
let config = Config::default()
.with_patterns(vec!["*"]);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let total = finder.create_total(&files);
assert_eq!(700, total.max_size);
assert_eq!(2800, total.total_size);
#[cfg(unix)]
assert_eq!(0, total.user_width);
#[cfg(unix)]
assert_eq!(0, total.group_width);
assert_eq!(0, total.ver_width);
assert_eq!(4, total.ext_width);
assert_eq!(8, total.num_files);
assert_eq!(2, total.num_dirs);
}
#[test]
#[cfg(unix)]
fn test_calculates_total_from_files_with_no_owners() {
let config = Config::default()
.with_show_owner(true);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let total = finder.create_total(&files);
assert_eq!(1, total.user_width);
assert_eq!(1, total.group_width);
}
#[test]
#[cfg(unix)]
fn test_calculates_total_from_files_with_some_owners() {
let config = Config::default()
.with_patterns(vec!["*"])
.with_show_owner(true);
let system = create_system(&config, create_entries());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let total = finder.create_total(&files);
assert_eq!(5, total.user_width);
assert_eq!(6, total.group_width);
}
fn create_entries() -> Vec<MockEntry> {
let link1 = MockEntry::new(2, 'd', 0o755, 1000, 500, 4096, 2023, 3, 3, "subdir", None);
let link2 = MockEntry::new(3, 'f', 0o644, 1000, 500, 500, 2023, 5, 5, "subdir/alpha.txt", None);
let link3 = MockEntry::new(0, 'f', 0o644, 1000, 500, 1000, 2023, 10, 10, "/etc/missing.txt", None);
return vec![
MockEntry::new(1, 'f', 0o744, 0, 0, 100, 2023, 1, 1, "archive.sh", None),
MockEntry::new(1, 'd', 0o755, 1000, 500, 4096, 2023, 2, 2, "dir", None),
MockEntry::new(2, 'l', 0o644, 1000, 500, 99, 2023, 12, 31, "dir/link1", Some(link1)),
MockEntry::new(2, 'l', 0o644, 1000, 500, 99, 2023, 12, 31, "dir/link2", Some(link2)),
MockEntry::new(2, 'l', 0o644, 1000, 500, 99, 2023, 12, 31, "dir/link3", Some(link3)),
MockEntry::new(2, 'd', 0o755, 1500, 500, 4096, 2023, 3, 3, "dir/subdir", None),
MockEntry::new(3, 'f', 0o644, 1500, 500, 400, 2023, 4, 4, "dir/subdir/alpha.csv", None),
MockEntry::new(3, 'f', 0o644, 1500, 500, 500, 2023, 5, 5, "dir/subdir/alpha.txt", None),
MockEntry::new(3, 'f', 0o644, 1500, 500, 600, 2023, 6, 6, "dir/subdir/beta.csv", None),
MockEntry::new(3, 'f', 0o644, 1500, 500, 700, 2023, 7, 7, "dir/subdir/beta.txt", None),
];
}
#[test]
fn test_performs_case_sensitive_search() {
let expected = vec![
"/root/A1.txt",
"/root/A2.txt",
];
let config = Config::default()
.with_patterns(vec!["A*"])
.with_case_sensitive(true);
let system = create_system(&config, create_cases());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
#[test]
fn test_performs_case_insensitive_search() {
let expected = vec![
"/root/A1.txt",
"/root/A2.txt",
"/root/a1.txt",
"/root/a2.txt",
];
let config = Config::default()
.with_patterns(vec!["A*"])
.with_case_sensitive(false);
let system = create_system(&config, create_cases());
let finder = create_finder(&config, &system);
let files = find_files(&finder);
let paths = convert_paths(files);
assert_eq!(expected, paths);
}
fn create_cases() -> Vec<MockEntry> {
return vec![
MockEntry::new(1, 'f', 0o000, 0, 0, 0, 1970, 1, 1, "A1.txt", None),
MockEntry::new(1, 'f', 0o000, 0, 0, 0, 1970, 1, 1, "A2.txt", None),
MockEntry::new(1, 'f', 0o000, 0, 0, 0, 1970, 1, 1, "B3.txt", None),
MockEntry::new(1, 'f', 0o000, 0, 0, 0, 1970, 1, 1, "B4.txt", None),
MockEntry::new(1, 'f', 0o000, 0, 0, 0, 1970, 1, 1, "a1.txt", None),
MockEntry::new(1, 'f', 0o000, 0, 0, 0, 1970, 1, 1, "a2.txt", None),
MockEntry::new(1, 'f', 0o000, 0, 0, 0, 1970, 1, 1, "b3.txt", None),
MockEntry::new(1, 'f', 0o000, 0, 0, 0, 1970, 1, 1, "b4.txt", None),
];
}
#[cfg(unix)]
fn create_system(config: &Config, entries: Vec<MockEntry>) -> MockSystem {
let current = PathBuf::from("/root");
let user_names = HashMap::from([
(0, String::from("root")),
(1000, String::from("alice")),
(1500, String::from("bob")),
]);
let group_names = HashMap::from([
(0, String::from("root")),
(500, String::from("public")),
]);
return MockSystem::new(config, ¤t, entries, user_names, group_names);
}
#[cfg(not(unix))]
fn create_system(config: &Config, entries: Vec<MockEntry>) -> MockSystem {
let current = PathBuf::from("/root");
return MockSystem::new(config, ¤t, entries);
}
fn create_finder<'a>(
config: &'a Config,
system: &'a MockSystem,
) -> Finder<'a, MockFlags, MockEntry, MockIterator, MockSystem<'a>> {
let current = PathBuf::from("/root");
return Finder::new(config, system, &Utc, current, false);
}
fn find_files(finder: &Finder<MockFlags, MockEntry, MockIterator, MockSystem>) -> Vec<File> {
let mut files = finder.find_files().unwrap();
files.sort_by_key(File::get_path);
return files;
}
fn assert_data(
file: Option<&File>,
file_depth: usize,
file_type: FileKind,
file_mode: u32,
file_size: u64,
time_year: i32,
time_month: u32,
time_day: u32,
) {
let file = file.unwrap();
let file_time = create_time(time_year, time_month, time_day);
assert_eq!(file_depth, file.file_depth);
assert_eq!(file_type, file.file_type);
assert_eq!(file_mode, file.file_mode);
assert_eq!(file_size, file.file_size);
assert_eq!(file_time, file.file_time);
}
fn assert_path(
file: Option<&File>,
abs_dir: &str,
rel_dir: &str,
file_name: &str,
file_ext: &str,
) {
let file = file.unwrap();
assert_eq!(PathBuf::from(abs_dir), file.abs_dir);
assert_eq!(PathBuf::from(rel_dir), file.rel_dir);
assert_eq!(file_name, file.file_name);
assert_eq!(file_ext, file.file_ext);
}
fn assert_link(
file: Option<&File>,
link_data: Option<(FileKind, &str)>,
) {
let file = file.unwrap();
let link_data = link_data.map(|(f, p)| (PathBuf::from(p), f));
assert_eq!(link_data, file.link_data);
}
fn create_time(year: i32, month: u32, day: u32) -> DateTime<Utc> {
Utc.with_ymd_and_hms(year, month, day, 0, 0, 0).unwrap()
}
fn convert_paths(files: Vec<File>) -> Vec<String> {
files.into_iter().flat_map(convert_path).collect()
}
#[cfg(windows)]
fn convert_path(file: File) -> Option<String> {
let path = file.abs_dir.join(file.file_name);
return path.to_str().map(|path| path.replace(MAIN_SEPARATOR_STR, "/"));
}
#[cfg(not(windows))]
fn convert_path(file: File) -> Option<String> {
let path = file.abs_dir.join(file.file_name);
return path.to_str().map(str::to_string);
}
}