//! Opening projects, listing order and ignore rules. #![allow( clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::indexing_slicing )] mod common; use std::fs; use std::path::{Path, PathBuf}; use common::{open, tree}; use lutra_vfs::{Entry, EntryKind, EntryRole, GlobalExcludes, Project, ProjectOptions, VfsError}; fn names(entries: &[Entry]) -> Vec<&str> { entries.iter().map(|e| e.name.as_str()).collect() } fn entry<'a>(entries: &'a [Entry], name: &str) -> &'a Entry { entries.iter().find(|e| e.name == name).unwrap() } #[test] fn open_canonicalises_the_root() { let dir = tree(&[("src/", "")]); let project = open(&dir.path().join("src").join("..")); assert!(project.root().is_absolute()); assert_eq!(project.root(), open(dir.path()).root()); assert!(!project.root().to_string_lossy().starts_with(r"\\?\")); } #[test] fn open_rejects_missing_and_non_directory_paths() { let dir = tree(&[("file.txt", "x")]); let missing = Project::open(dir.path().join("nope")); assert!(matches!(missing, Err(VfsError::NotFound { .. }))); let file = Project::open(dir.path().join("file.txt")); assert!(matches!(file, Err(VfsError::NotADirectory { .. }))); } #[test] fn children_sorts_directories_first_then_case_insensitive() { let dir = tree(&[ ("b.php", ""), ("A.php", ""), ("c.php", ""), ("zeta/", ""), ("Alpha/", ""), ("beta/", ""), ]); let listing = open(dir.path()).children("").unwrap(); assert_eq!( names(&listing.entries), ["Alpha", "beta", "zeta", "A.php", "b.php", "c.php"] ); assert!(!listing.truncated); let alpha = entry(&listing.entries, "Alpha"); assert_eq!(alpha.kind, EntryKind::Directory); assert_eq!(alpha.path, PathBuf::from("Alpha")); assert_eq!(entry(&listing.entries, "b.php").kind, EntryKind::File); } #[test] fn children_of_a_subdirectory_have_relative_paths() { let dir = tree(&[("src/Controller/Home.php", "")]); let listing = open(dir.path()).children("src").unwrap(); assert_eq!(names(&listing.entries), ["Controller"]); assert_eq!(listing.entries[0].path, Path::new("src").join("Controller")); let inner = open(dir.path()).children("src/Controller").unwrap(); assert_eq!( inner.entries[0].path, Path::new("src").join("Controller").join("Home.php") ); } #[test] fn children_rejects_bad_paths() { let dir = tree(&[("a.php", "")]); let project = open(dir.path()); assert!(matches!( project.children("../"), Err(VfsError::OutsideProject { .. }) )); assert!(matches!( project.children("missing"), Err(VfsError::NotFound { .. }) )); assert!(matches!( project.children("a.php"), Err(VfsError::NotADirectory { .. }) )); } #[test] fn gitignore_marks_entries_and_their_descendants() { let dir = tree(&[ (".gitignore", "*.log\n/build/\n!keep.log\n"), ("app.log", ""), ("keep.log", ""), ("index.php", ""), ("build/out/a.txt", ""), ("src/build/b.txt", ""), ]); let project = open(dir.path()); let root = project.children("").unwrap().entries; assert!(entry(&root, "app.log").ignored); assert!(!entry(&root, "keep.log").ignored); assert!(!entry(&root, "index.php").ignored); assert!(entry(&root, "build").ignored); assert!(!entry(&root, ".gitignore").ignored); let build = project.children("build").unwrap().entries; assert!(entry(&build, "out").ignored); let deep = project.children("build/out").unwrap().entries; assert!(entry(&deep, "a.txt").ignored); let src = project.children("src").unwrap().entries; assert!( !entry(&src, "build").ignored, "anchored pattern only at root" ); } #[test] fn nested_gitignore_and_dot_ignore_take_precedence() { let dir = tree(&[ (".gitignore", "*.cache\n"), ("sub/.gitignore", "!local.cache\n"), ("sub/local.cache", ""), ("sub/other.cache", ""), (".ignore", "notes.md\n"), ("notes.md", ""), ("tool/.gitignore", "gen.php\n"), ("tool/.ignore", "!gen.php\n"), ("tool/gen.php", ""), ]); let project = open(dir.path()); let sub = project.children("sub").unwrap().entries; assert!(!entry(&sub, "local.cache").ignored); assert!(entry(&sub, "other.cache").ignored); let root = project.children("").unwrap().entries; assert!(entry(&root, "notes.md").ignored); let tool = project.children("tool").unwrap().entries; assert!(!entry(&tool, "gen.php").ignored, ".ignore beats .gitignore"); } #[test] fn ignore_rule_edits_apply_to_the_next_listing() { let dir = tree(&[("a.tmp", "")]); let project = open(dir.path()); assert!(!project.children("").unwrap().entries[0].ignored); fs::write(dir.path().join(".gitignore"), "*.tmp\n").unwrap(); let root = project.children("").unwrap().entries; assert!(entry(&root, "a.tmp").ignored); } #[test] fn info_exclude_and_global_excludes_apply() { let dir = tree(&[ (".git/info/exclude", "secret.txt\n"), ("secret.txt", ""), ("global.bak", ""), ("plain.txt", ""), ]); let global = tempfile::NamedTempFile::new().unwrap(); fs::write(global.path(), "*.bak\n").unwrap(); let project = Project::open_with( dir.path(), ProjectOptions { global_excludes: GlobalExcludes::File(global.path().to_path_buf()), }, ) .unwrap(); let root = project.children("").unwrap().entries; assert!(entry(&root, "secret.txt").ignored); assert!(entry(&root, "global.bak").ignored); assert!(!entry(&root, "plain.txt").ignored); } #[test] fn lutra_defaults_hide_git_and_mark_vendor_and_node_modules() { let dir = tree(&[ (".git/HEAD", "ref"), ("vendor/acme/lib/A.php", ""), ("vendor/acme/node_modules/x.js", ""), ("node_modules/pkg/index.js", ""), ("web/node_modules/y.js", ""), ("src/vendor/", ""), ("src/sub/.git", "gitdir: elsewhere"), ]); let project = open(dir.path()); let root = project.children("").unwrap().entries; assert_eq!(names(&root), ["node_modules", "src", "vendor", "web"]); assert_eq!(entry(&root, "vendor").role, EntryRole::Library); assert!(!entry(&root, "vendor").ignored); assert_eq!(entry(&root, "node_modules").role, EntryRole::Excluded); assert_eq!(entry(&root, "src").role, EntryRole::Normal); let acme = project.children("vendor/acme").unwrap().entries; assert_eq!(entry(&acme, "lib").role, EntryRole::Library); assert_eq!(entry(&acme, "node_modules").role, EntryRole::Excluded); let pkg = project.children("node_modules/pkg").unwrap().entries; assert_eq!(entry(&pkg, "index.js").role, EntryRole::Excluded); let web = project.children("web").unwrap().entries; assert_eq!(entry(&web, "node_modules").role, EntryRole::Excluded); let src = project.children("src").unwrap().entries; assert_eq!(entry(&src, "vendor").role, EntryRole::Normal); assert!(project.children("src/sub").unwrap().entries.is_empty()); assert!(project.status(".git/HEAD").unwrap().hidden); } #[test] fn resolve_and_relative_round_trip() { let dir = tree(&[("src/a.php", "")]); let project = open(dir.path()); let abs = project.resolve("src/a.php").unwrap(); assert!(abs.is_file()); assert_eq!( project.relative(&abs).unwrap(), Path::new("src").join("a.php") ); assert!( project .relative(std::env::temp_dir().join("elsewhere")) .is_none() ); assert!(project.resolve("../x").is_err()); }