Ignore rules apply to untracked paths only: tracked files hidden by .oxyignore stay tracked in snapshots, amend, checkout manifests and the prompt 9ac1fbe211b4

        let entries = self.walk_working_copy_with(None, &Self::tracked_paths(&target))?;

        self.walk_working_copy_with(None, &BTreeSet::new())

    ///

    /// `.oxyignore` applies to untracked paths only: every path in `tracked`

    /// (the base state's files) that exists on disk is included even when

    /// an ignore rule matches it, as in Git.

    fn walk_working_copy_with(&self, cache: Option<&prompt::Manifest>, tracked: &BTreeSet<String>) -> Result<BTreeMap<String, FsEntry>> {

                let e = self.file_entry(&rel, path, &meta, cache)?;

                out.insert(rel, e);

        // Tracked paths the ignore rules hid.

        for rel in tracked {

            if out.contains_key(rel) || !self.in_scope(rel) {

                continue;

            }

            let path = self.root.join(rel);

            let Ok(meta) = fs::symlink_metadata(&path) else { continue };

            let ft = meta.file_type();

            if ft.is_symlink() {

                let target = fs::read_link(&path)?;

                out.insert(rel.clone(), FsEntry::new(NodeKind::Symlink, false, target.to_string_lossy().as_bytes().to_vec()));

            } else if ft.is_file() {

                let e = self.file_entry(rel, &path, &meta, cache)?;

                out.insert(rel.clone(), e);

            }

        }

    /// The entry for one regular file, read or served from the stat cache.

    fn file_entry(&self, rel: &str, path: &Path, meta: &fs::Metadata, cache: Option<&prompt::Manifest>) -> Result<FsEntry> {

        let exec = is_executable(meta);

        let cached = cache.and_then(|m| {

            let e = m.entries.get(rel)?;

            let mtime_ns = prompt::mtime_ns(meta);

            let racy = mtime_ns + 2_000_000_000 >= m.written_ns;

            (e.size == meta.len() && e.mtime_ns == mtime_ns && !racy).then_some(e)

        });

        Ok(match cached {

            Some(e) if e.blob.is_some_and(|b| self.store.has(&b)) => FsEntry { kind: NodeKind::File, exec, content: vec![], blob: e.blob, content_hash: Some(e.hash.clone()) },

            Some(e) => FsEntry { kind: NodeKind::File, exec, content: fs::read(path)?, blob: None, content_hash: Some(e.hash.clone()) },

            None => FsEntry::new(NodeKind::File, exec, fs::read(path)?),

        })

    }

    /// The non-directory paths of a snapshot, for the walker's `tracked` set.

    pub(crate) fn tracked_paths(snapshot: &Snapshot) -> BTreeSet<String> {

        snapshot.files.iter().filter(|(_, f)| f.kind != NodeKind::Dir).map(|(p, _)| p.clone()).collect()

    }

        if seen == manifest.entries.len() {

            return Ok(Some(false));

        }

        // Manifest entries the walk skipped: tracked files that ignore rules

        // hide. They count as present when still on disk and unchanged.

        for (rel, me) in &manifest.entries {

            let path = self.root.join(rel);

            let Ok(m) = fs::symlink_metadata(&path) else { return Ok(Some(true)) };

            if m.file_type().is_symlink() {

                continue;

            }

            if m.len() != me.size || (mtime_ns(&m) != me.mtime_ns && blake3::hash(&fs::read(&path)?).to_hex().as_str() != me.hash) {

                return Ok(Some(true));

            }

        }

        Ok(Some(false))

        let fs_entries = self.walk_working_copy_with(None, &Self::tracked_paths(base_snapshot))?;

        let fs_entries = self.walk_working_copy_with(manifest.as_ref(), &Self::tracked_paths(&base_snapshot))?;

#[test]

fn ignore_rules_do_not_untrack_files() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let repo = Repo::init(root).unwrap().with_home(root.join("home"));

    write(root, "src.c", b"int x;\n");

    write(root, "build/out.o", b"\0obj");

    write(root, "sub/keep.log", b"keep\n");

    write(root, "sub/junk.log", b"junk\n");

    write(root, ".oxyignore", b"/build\n*.log\n!sub/keep.log\n");

    let snap = repo.snapshot("status").unwrap();

    let added: Vec<&str> = snap.statuses.iter().map(|s| s.path.as_str()).collect();

    assert_eq!(added, vec![".oxyignore", "src.c", "sub/keep.log"], "anchored, glob, and negated rules");

    let h1 = repo.commit("base", &[]).unwrap();

    // Ignoring a tracked file changes nothing about it.

    write(root, ".oxyignore", b"/build\n*.log\n!sub/keep.log\nsrc.c\n");

    let snap = repo.snapshot("status").unwrap();

    assert_eq!(snap.statuses.iter().map(|s| s.path.as_str()).collect::<Vec<_>>(), vec![".oxyignore"]);

    let h2 = repo.commit("ignore src.c", &[]).unwrap();

    assert!(repo.load_state(&[h2]).unwrap().materialize().files.contains_key("src.c"));

    // Its edits are still seen, by status and by the prompt.

    assert_eq!(repo.quick_dirty().unwrap(), Some(false));

    write(root, "src.c", b"int x, y;\n");

    assert_eq!(repo.quick_dirty().unwrap(), Some(true));

    let snap = repo.snapshot("status").unwrap();

    assert_eq!(snap.statuses.iter().map(|s| (s.path.as_str(), s.status)).collect::<Vec<_>>(), vec![("src.c", ChangeStatus::Modified)]);

    let h3 = repo.commit("edit src.c", &[]).unwrap();

    assert!(matches!(&repo.load_state(&[h3]).unwrap().materialize().files["src.c"].content, FileContent::Text { bytes, .. } if bytes == b"int x, y;\n"));

    // Deleting it on disk removes it, ignored or not; a checkout brings it back.

    fs::remove_file(root.join("src.c")).unwrap();

    let snap = repo.snapshot("status").unwrap();

    assert_eq!(snap.statuses.iter().map(|s| (s.path.as_str(), s.status)).collect::<Vec<_>>(), vec![("src.c", ChangeStatus::Removed)]);

    repo.checkout(&[h3], true, "checkout").unwrap();

    assert_eq!(fs::read(root.join("src.c")).unwrap(), b"int x, y;\n");

    assert!(!repo.snapshot("status").unwrap().changed);

    let _ = h1;

}

`oxy init` creates `.oxy/`. Add `.oxyignore` (gitignore syntax, per

directory, negations with `!`) for files that should never be tracked;

`/target` and `*.tmp` are typical entries. As in Git, ignore rules only

affect untracked files: a file already in history stays tracked until you

delete it.

| `.oxyignore` | Ignore rules. Gitignore syntax and semantics, per directory, plus `.oxy/info/ignore` and the global ignore file. Rules apply to untracked paths only: a tracked path stays tracked, and its edits are seen, until it is deleted or removed from the state. |