Format and lint the code

[rbdr/page] / src / file_finder.rs

use crate::file_handler::{File, FileHandler};
use std::fs::read_dir;
use std::path::PathBuf;

pub fn find_files(directory_path: &PathBuf) -> Vec<File> {
    find_files_recursively(directory_path, directory_path)
}

fn find_files_recursively(root_path: &PathBuf, directory_path: &PathBuf) -> Vec<File> {
    let mut result: Vec<File> = vec![];
    let file_handler = FileHandler::default();
    let entries = read_dir(directory_path).unwrap();
    for entry in entries {
        let path = entry.unwrap().path();
        let relative_path = path.strip_prefix(root_path).unwrap();
        if relative_path.starts_with(".git") || relative_path.starts_with(".gitignore") {
            continue;
        }
        if path.is_dir() {
            result.append(&mut find_files_recursively(root_path, &path))
        } else {
            let file_type = file_handler.identify(&path);
            result.push(File { path, file_type });
        }
    }
    result
}

#[cfg(test)]
mod tests {
    use std::collections::HashSet;
    use std::fs::create_dir_all;
    use std::path::PathBuf;

    use super::*;

    use crate::file_handler::File;
    use crate::file_handler::FileType;
    use test_utilities::*;

    fn get_paths(root_directory: &PathBuf, files: &Vec<File>) -> HashSet<String> {
        files
            .iter()
            .map(|file| {
                file.path
                    .strip_prefix(root_directory)
                    .unwrap()
                    .to_string_lossy()
                    .to_string()
            })
            .collect()
    }

    #[test]
    fn finds_all_files() {
        let test_dir = setup_test_dir();
        create_dir_all(&test_dir.join("nested")).expect("Could not create nested test directory");
        create_dir_all(&test_dir.join("assets")).expect("Could not create assets test directory");
        create_test_file(&test_dir.join("test1.gmi"), "");
        create_test_file(&test_dir.join("_layout.html"), "");
        create_test_file(&test_dir.join("nested/nested.gmi"), "");
        create_test_file(&test_dir.join("assets/style.css"), "");
        create_test_file(&test_dir.join("image.png"), "");

        let files = find_files(&test_dir);
        let paths = get_paths(&test_dir, &files);

        assert!(paths.contains("test1.gmi"));
        assert!(paths.contains("_layout.html"));
        assert!(paths.contains("nested/nested.gmi"));
        assert!(paths.contains("assets/style.css"));
        assert!(paths.contains("image.png"));
    }

    #[test]
    fn identifies_correct_file_types() {
        let test_dir = setup_test_dir();
        create_dir_all(&test_dir.join("nested")).expect("Could not create nested test directory");
        create_dir_all(&test_dir.join("assets")).expect("Could not create assets test directory");
        create_test_file(&test_dir.join("_layout.html"), "");
        create_test_file(&test_dir.join("nested/nested.gmi"), "");
        create_test_file(&test_dir.join("assets/style.css"), "");
        create_test_file(&test_dir.join("image.png"), "");
        let files = find_files(&test_dir);

        for file in files {
            let extension = file.path.extension().and_then(|e| e.to_str());
            match extension {
                Some("gmi") => assert_eq!(file.file_type, FileType::Gemini),
                Some("html") => {
                    if file.path.ends_with("_layout.html") {
                        assert_eq!(file.file_type, FileType::Layout)
                    } else {
                        assert_eq!(file.file_type, FileType::File)
                    }
                }
                _ => assert_eq!(file.file_type, FileType::File),
            }
        }
    }

    #[test]
    fn ignores_git_directory() {
        let test_dir = setup_test_dir();
        create_dir_all(&test_dir.join("nested")).expect("Could not create nested test directory");
        create_dir_all(&test_dir.join("assets")).expect("Could not create assets test directory");
        create_dir_all(&test_dir.join(".git")).expect("Could not create git test directory");
        create_test_file(&test_dir.join("_layout.html"), "");
        create_test_file(&test_dir.join("nested/nested.gmi"), "");
        create_test_file(&test_dir.join("assets/style.css"), "");
        create_test_file(&test_dir.join("image.png"), "");
        create_test_file(&test_dir.join(".git/config"), "");
        let files = find_files(&test_dir);

        let paths = get_paths(&test_dir, &files);

        assert!(!paths.iter().any(|p| p.starts_with(".git/")));
        assert!(!paths.contains(".gitignore"));
    }

    #[test]
    fn returns_empty_for_empty_directory() {
        let test_dir = setup_test_dir();
        let files = find_files(&test_dir);
        assert!(files.is_empty());
    }
}