use ignore::gitignore::{Gitignore, GitignoreBuilder};
use std::path::Path;
use crate::error::Result;
pub const TRACKED_OAK_FILES: &[&str] = &[".oak/attributes", ".oak/PERMISSIONS"];
pub const ROOT_STATE_FILE: &str = ".oakroot";
pub const ROOT_DIRS_FILE: &str = "root-dirs";
pub fn root_dirs(repo_root: &Path) -> Vec<String> {
let Ok(text) = std::fs::read_to_string(repo_root.join(".oak").join(ROOT_DIRS_FILE)) else {
return Vec::new();
};
text.lines()
.map(|line| line.trim().trim_matches('/').to_string())
.filter(|line| !line.is_empty() && !line.starts_with('#'))
.collect()
}
const SYSTEM_METADATA_NAMES: &[&str] = &[
".DS_Store",
".AppleDouble",
".LSOverride",
".DocumentRevisions-V100",
".fseventsd",
".Spotlight-V100",
".TemporaryItems",
".Trashes",
".VolumeIcon.icns",
".com.apple.timemachine.donotpresent",
".AppleDB",
".AppleDesktop",
".apdisk",
"Thumbs.db",
"ehthumbs.db",
"Desktop.ini",
"$RECYCLE.BIN",
".directory",
];
pub fn is_system_metadata_path(path: &str) -> bool {
path.split('/').filter(|c| !c.is_empty()).any(|comp| {
comp.starts_with("._")
|| SYSTEM_METADATA_NAMES
.iter()
.any(|n| n.eq_ignore_ascii_case(comp))
})
}
pub struct IgnorePatterns {
gitignore: Option<Gitignore>,
}
impl IgnorePatterns {
pub fn new(repo_root: &Path) -> Result<Self> {
let oakignore_path = repo_root.join(".oakignore");
let gitignore_path = repo_root.join(".gitignore");
let mut builder = GitignoreBuilder::new(repo_root);
builder.add_line(None, ".oak/").ok();
builder.add_line(None, ".oak-branch").ok();
builder.add_line(None, ".git/").ok();
if oakignore_path.exists() {
builder.add(&oakignore_path);
}
if !oakignore_path.exists() && gitignore_path.exists() {
builder.add(&gitignore_path);
}
for dir in root_dirs(repo_root) {
builder.add_line(None, &format!("/{dir}/")).ok();
}
let gitignore = builder.build().ok();
Ok(IgnorePatterns { gitignore })
}
pub fn from_patterns(patterns: &str) -> Self {
let synthetic_root = Path::new("/");
let mut builder = GitignoreBuilder::new(synthetic_root);
builder.add_line(None, ".oak/").ok();
builder.add_line(None, ".oak-branch").ok();
builder.add_line(None, ".git/").ok();
for line in patterns.lines() {
let trimmed = line.trim();
if !trimmed.is_empty() && !trimmed.starts_with('#') {
builder.add_line(None, trimmed).ok();
}
}
let gitignore = builder.build().ok();
IgnorePatterns { gitignore }
}
pub fn empty(repo_root: &Path) -> Self {
let mut builder = GitignoreBuilder::new(repo_root);
builder.add_line(None, ".oak/").ok();
builder.add_line(None, ".oak-branch").ok();
builder.add_line(None, ".git/").ok();
let gitignore = builder.build().ok();
IgnorePatterns { gitignore }
}
pub fn is_path_or_ancestors_ignored(&self, path_str: &str) -> bool {
let path = Path::new(path_str);
if self.is_ignored(path, false) {
return true;
}
let mut current = path.parent();
while let Some(ancestor) = current {
if ancestor.as_os_str().is_empty() {
break;
}
if self.is_ignored(ancestor, true) {
return true;
}
current = ancestor.parent();
}
false
}
pub fn is_ignored(&self, path: &Path, is_dir: bool) -> bool {
let path_str = path.to_string_lossy();
if TRACKED_OAK_FILES.contains(&path_str.as_ref()) {
return false;
}
if path_str == ".oak/workflows"
|| path_str == ".oak/workflows/"
|| path_str.starts_with(".oak/workflows/")
{
return false;
}
if is_dir && (path_str == ".oak" || path_str.ends_with("/.oak")) {
return false;
}
if path.starts_with(".oak") || path_str.contains("/.oak/") {
return true;
}
if path.starts_with(".git") || path.to_string_lossy().contains("/.git/") {
return true;
}
if path
.file_name()
.map(|f| f == ".oak-branch" || f == ROOT_STATE_FILE)
.unwrap_or(false)
{
return true;
}
if is_system_metadata_path(&path_str) {
return true;
}
if let Some(ref gitignore) = self.gitignore {
gitignore.matched(path, is_dir).is_ignore()
} else {
false
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile::TempDir;
#[test]
fn root_dirs_and_state_files_are_ignored() {
let temp = TempDir::new().unwrap();
fs::create_dir_all(temp.path().join(".oak")).unwrap();
fs::write(temp.path().join(".oakignore"), "!me/\n").unwrap();
fs::write(
temp.path().join(".oak").join(ROOT_DIRS_FILE),
"me\nroots/ops/\n",
)
.unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new("me"), true));
assert!(patterns.is_path_or_ancestors_ignored("me/notes.md"));
assert!(patterns.is_path_or_ancestors_ignored("roots/ops/a/b.txt"));
assert!(!patterns.is_path_or_ancestors_ignored("src/me/notes.md"));
assert!(!patterns.is_path_or_ancestors_ignored("roots/other.txt"));
assert!(patterns.is_ignored(Path::new("docs/.oakroot"), false));
assert!(patterns.is_ignored(Path::new(".oakroot"), false));
}
#[test]
fn test_ignores_oak_directory() {
let temp = TempDir::new().unwrap();
let patterns = IgnorePatterns::empty(temp.path());
assert!(!patterns.is_ignored(Path::new(".oak"), true));
assert!(patterns.is_ignored(Path::new(".oak/oak.db"), false));
assert!(patterns.is_ignored(Path::new(".oak/internal"), true));
}
#[test]
fn test_tracks_oak_workflows() {
let temp = TempDir::new().unwrap();
let patterns = IgnorePatterns::empty(temp.path());
assert!(!patterns.is_ignored(Path::new(".oak/workflows"), true));
assert!(!patterns.is_ignored(Path::new(".oak/workflows/ci.yml"), false));
assert!(!patterns.is_ignored(Path::new("apps/web/.oak"), true));
assert!(patterns.is_ignored(Path::new("apps/web/.oak/workflows/ci.yml"), false));
assert!(patterns.is_ignored(Path::new("apps/web/.oak/oak.db"), false));
assert!(!patterns.is_ignored(Path::new(".oak/workflows/deploy.yaml"), false));
assert!(patterns.is_ignored(Path::new(".oak/oak.db"), false));
}
#[test]
fn test_oakignore_patterns() {
let temp = TempDir::new().unwrap();
fs::write(temp.path().join(".oakignore"), "*.log\ntarget/\n").unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new("debug.log"), false));
assert!(patterns.is_ignored(Path::new("target"), true));
assert!(!patterns.is_ignored(Path::new("src/main.rs"), false));
}
#[test]
fn test_gitignore_fallback() {
let temp = TempDir::new().unwrap();
fs::write(temp.path().join(".gitignore"), "node_modules/\n").unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new("node_modules"), true));
}
#[test]
fn test_ignores_git_directory() {
let temp = TempDir::new().unwrap();
let patterns = IgnorePatterns::empty(temp.path());
assert!(patterns.is_ignored(Path::new(".git"), true));
assert!(patterns.is_ignored(Path::new(".git/config"), false));
}
#[test]
fn test_always_ignores_oak_and_git_with_no_ignore_file() {
let temp = TempDir::new().unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(!patterns.is_ignored(Path::new(".oak"), true));
assert!(patterns.is_ignored(Path::new(".oak/oak.db"), false));
assert!(patterns.is_ignored(Path::new(".git"), true));
assert!(patterns.is_ignored(Path::new(".oak-branch"), false));
assert!(!patterns.is_ignored(Path::new("src/main.rs"), false));
}
#[test]
fn test_oakignore_takes_precedence() {
let temp = TempDir::new().unwrap();
fs::write(temp.path().join(".gitignore"), "*.log\n").unwrap();
fs::write(temp.path().join(".oakignore"), "*.txt\n").unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new("file.txt"), false));
assert!(!patterns.is_ignored(Path::new("file.log"), false));
}
#[test]
fn test_oak_attributes_not_ignored() {
let temp = TempDir::new().unwrap();
let patterns = IgnorePatterns::empty(temp.path());
assert!(!patterns.is_ignored(Path::new(".oak/attributes"), false));
assert!(patterns.is_ignored(Path::new(".oak/oak.db"), false));
}
#[test]
fn test_oak_permissions_not_ignored() {
let temp = TempDir::new().unwrap();
let patterns = IgnorePatterns::empty(temp.path());
assert!(!patterns.is_ignored(Path::new(".oak/PERMISSIONS"), false));
assert!(patterns.is_ignored(Path::new(".oak/oak.db"), false));
assert!(patterns.is_ignored(Path::new(".oak/permissions"), false));
assert!(patterns.is_ignored(Path::new(".oak/PERMISSIONS.bak"), false));
}
#[test]
fn test_nested_gitignore_patterns() {
let temp = TempDir::new().unwrap();
fs::write(
temp.path().join(".gitignore"),
"*.o\n*.so\nbuild/\n!build/keep.txt\n",
)
.unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new("main.o"), false));
assert!(patterns.is_ignored(Path::new("lib.so"), false));
assert!(patterns.is_ignored(Path::new("build"), true));
assert!(!patterns.is_ignored(Path::new("src/lib.rs"), false));
}
#[test]
fn test_negation_pattern() {
let temp = TempDir::new().unwrap();
fs::write(temp.path().join(".oakignore"), "*.log\n!important.log\n").unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new("debug.log"), false));
assert!(!patterns.is_ignored(Path::new("important.log"), false));
}
#[test]
fn test_directory_specific_pattern() {
let temp = TempDir::new().unwrap();
fs::write(temp.path().join(".oakignore"), "logs/\n").unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new("logs"), true));
assert!(!patterns.is_ignored(Path::new("logs"), false));
}
#[test]
fn test_oak_branch_marker_always_ignored() {
let temp = TempDir::new().unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new(".oak-branch"), false));
assert!(patterns.is_ignored(Path::new("subdir/.oak-branch"), false));
}
#[test]
fn test_empty_ignore_file() {
let temp = TempDir::new().unwrap();
fs::write(temp.path().join(".oakignore"), "").unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new(".oak/oak.db"), false));
assert!(patterns.is_ignored(Path::new(".git"), true));
assert!(!patterns.is_ignored(Path::new("file.txt"), false));
}
#[test]
fn test_comment_lines_in_ignore() {
let temp = TempDir::new().unwrap();
fs::write(
temp.path().join(".oakignore"),
"# This is a comment\n*.log\n# Another comment\n",
)
.unwrap();
let patterns = IgnorePatterns::new(temp.path()).unwrap();
assert!(patterns.is_ignored(Path::new("debug.log"), false));
assert!(!patterns.is_ignored(Path::new("# This is a comment"), false));
}
#[test]
fn test_from_patterns_godot() {
let patterns = IgnorePatterns::from_patterns("# Godot\n.godot/\n*.import\n");
assert!(patterns.is_ignored(Path::new(".godot"), true));
assert!(patterns.is_ignored(Path::new("icon.svg.import"), false));
assert!(!patterns.is_ignored(Path::new("project.godot"), false));
assert!(!patterns.is_ignored(Path::new("scenes/main.tscn"), false));
assert!(patterns.is_ignored(Path::new(".oak/oak.db"), false));
assert!(patterns.is_ignored(Path::new(".git"), true));
}
#[test]
fn test_from_patterns_unity() {
let patterns = IgnorePatterns::from_patterns(
"Library/\nTemp/\nLogs/\nUserSettings/\nobj/\nBuilds/\nBuild/\n*.csproj\n*.sln\n",
);
assert!(patterns.is_ignored(Path::new("Library"), true));
assert!(patterns.is_ignored(Path::new("Temp"), true));
assert!(patterns.is_ignored(Path::new("Assembly-CSharp.csproj"), false));
assert!(patterns.is_ignored(Path::new("MyGame.sln"), false));
assert!(!patterns.is_ignored(Path::new("Assets/Scripts/Player.cs"), false));
assert!(!patterns.is_ignored(Path::new("ProjectSettings/ProjectSettings.asset"), false));
}
#[test]
fn test_from_patterns_empty() {
let patterns = IgnorePatterns::from_patterns("");
assert!(!patterns.is_ignored(Path::new("src/main.rs"), false));
assert!(patterns.is_ignored(Path::new(".oak/oak.db"), false));
assert!(patterns.is_ignored(Path::new(".git"), true));
}
#[test]
fn test_system_metadata_path() {
assert!(is_system_metadata_path(".fseventsd"));
assert!(is_system_metadata_path(".fseventsd/fseventsd-uuid"));
assert!(is_system_metadata_path(".Spotlight-V100/Store-V2/x"));
assert!(is_system_metadata_path(".Trashes/501"));
assert!(is_system_metadata_path(".DS_Store"));
assert!(is_system_metadata_path("src/.DS_Store"));
assert!(is_system_metadata_path("._foo"));
assert!(is_system_metadata_path("dir/._image.png"));
assert!(is_system_metadata_path("Thumbs.db"));
assert!(is_system_metadata_path("a/b/desktop.ini")); assert!(!is_system_metadata_path("src/main.rs"));
assert!(!is_system_metadata_path("README.md"));
assert!(!is_system_metadata_path("Documents/notes.txt"));
}
#[test]
fn test_is_ignored_covers_system_metadata() {
let temp = TempDir::new().unwrap();
let patterns = IgnorePatterns::empty(temp.path());
assert!(patterns.is_ignored(Path::new(".fseventsd"), true));
assert!(patterns.is_ignored(Path::new(".fseventsd/fseventsd-uuid"), false));
assert!(patterns.is_ignored(Path::new("src/.DS_Store"), false));
assert!(!patterns.is_ignored(Path::new("src/main.rs"), false));
}
#[test]
fn test_from_patterns_is_file_in_ignored_dir() {
let patterns = IgnorePatterns::from_patterns("Library/\n");
assert!(patterns.is_ignored(Path::new("Library"), true));
assert!(patterns.is_path_or_ancestors_ignored("Library/foo.dll"));
assert!(!patterns.is_path_or_ancestors_ignored("Assets/main.cs"));
}
}