Projects coming from Git: .gitignore honoured, nested Git repositories named (closes #43, closes #44) d4dbab97e948

    /// The nested repositories the last walk left out, being neither

    /// registered nor tracked subrepos (oxygen#43).

    pub(crate) untracked_nested: std::cell::RefCell<Vec<String>>,

            untracked_nested: Default::default(),

            untracked_nested: Default::default(),

                    untracked_nested: Default::default(),

                    untracked_nested: Default::default(),

    /// Folders holding a repository of their own that the last look at the

    /// working copy left out, not being subrepos (oxygen#43).

    pub fn untracked_nested(&self) -> Vec<String> {

        self.untracked_nested.borrow().clone()

    }

            // Ignore rules apply to untracked paths only, so the base's

            // files are not matched against them (an added file is: a rule

            // written after it was snapshotted leaves it out again).

            None => walk::list_knowing(&self.root, &in_scope, &|p: &str| tracked.contains_key(p))?,

        let mut untracked_nested = Vec::new();

                untracked_nested.push(rel);

        untracked_nested.sort();

        *self.untracked_nested.borrow_mut() = untracked_nested;

        // Known files are not matched against the ignore rules: with no

        // uncommitted work (the clean check), the manifest's files are the

        // base's, and a prompt's answer is the same either way.

        let known = |p: &str| manifest.entries.contains_key(p);

        let Ok(listing) = super::walk::list_knowing(&self.root, &in_scope, &known) else {

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

            // rules hide (Linux tracks some its own .gitignore names). Found

            // by merging the two sorted lists; they count as present when

            // still on disk and unchanged, checked on every core.

            let mut listed: Vec<&str> = listing

                .files

                .iter()

                .map(|(r, _, _)| r.as_str())

                .chain(listing.symlinks.iter().map(|(r, _)| r.as_str()))

                .collect();

            listed.sort_unstable();

            let mut at = listed.iter().peekable();

            let skipped: Vec<(&String, &ManifestEntry)> = manifest

                .entries

                .iter()

                .filter(|(rel, _)| {

                    while at.next_if(|l| **l < rel.as_str()).is_some() {}

                    at.peek().is_none_or(|l| **l != rel.as_str())

                })

                .collect();

            let root = &self.root;

            Ok(skipped.par_iter().any(|(rel, me)| {

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

                    return true;

                !m.file_type().is_symlink()

                    && (m.len() != me.size

                        || super::is_executable(&m) != me.exec

                        || (mtime_ns(&m) != me.mtime_ns

                            && !fs::read(&path)

                                .is_ok_and(|b| *blake3::hash(&b).as_bytes() == me.hash)))

            }))

        if !dirty {

            // Nested repositories the manifest has no entry for are not

            // subrepos: nothing in them is tracked (oxygen#43).

            *self.untracked_nested.borrow_mut() = listing

                .nested

                .iter()

                .map(|d| self.rel_path(d))

                .filter(|rel| !manifest.entries.contains_key(rel))

                .collect();

        }

    /// Folders holding a repository of their own (`.git` or `.oxy`) that

    /// are not subrepos, so nothing in them is tracked (oxygen#43).

    pub untracked_nested: Vec<String>,

            untracked_nested: self.untracked_nested.borrow().clone(),

            "{{\"bookmark\":{},\"working_copy\":{},\"heads\":{},\"clean\":{},\"conflicted\":{},\"paths\":{paths},\"conflicts\":{},\"untracked_nested\":{}}}",

            json_array(conflicts),

            json_array(snap.untracked_nested.iter().map(|p| json_str(p)))

#[test]

fn an_ignore_rule_drops_an_added_file_but_not_a_tracked_one() {

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

    write(root, "a.txt", b"a\n");

    write(root, "kept.log", b"tracked\n");

    repo.commit("first", &[]).unwrap();

    write(root, "build.log", b"made\n");

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

    assert!(snap.statuses.iter().any(|s| s.path == "build.log"));

    // A rule written afterwards leaves the added file out again, while the

    // committed one stays tracked.

    write(root, ".gitignore", b"*.log\n");

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

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

    assert_eq!(paths, vec![".gitignore"], "{paths:?}");

    write(root, "kept.log", b"tracked, edited\n");

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

    assert!(snap.statuses.iter().any(|s| s.path == "kept.log"));

}

//! instead. `.oxyignore` files exclude paths with gitignore syntax, the

//! nearest file deciding; `.gitignore` and `.ignore` files count too, below

//! `.oxyignore` in the same directory (oxygen#44), so a project coming from

//! Git does not commit what Git ignored, and `.oxyignore` can still say

//! otherwise with `!`.

        // Later files win: .oxyignore over .ignore over .gitignore.

        let files: Vec<&str> = [".gitignore", ".ignore", ".oxyignore"]

    known: &'a (dyn Fn(&str) -> bool + Sync),

    list_knowing(root, in_scope, &|_| false)

}

/// [`list`], taking files `known` says are tracked without asking the

/// ignore rules, which apply to untracked paths only: on the Linux tree,

/// matching every file against its 400 `.gitignore` files cost more than

/// a manifest lookup.

pub(crate) fn list_knowing(

    root: &Path,

    in_scope: &(dyn Fn(&str) -> bool + Sync),

    known: &(dyn Fn(&str) -> bool + Sync),

) -> Result<Listing> {

        known,

        if (ft.is_dir() || !(ctx.known)(&child)) && rules.ignored(&path, ft.is_dir()) {

            continue;

        }

        // .gitignore counts, below .oxyignore in the same directory.

        write(root, "gitproj/.gitignore", "build/\n*.tmp\nkeep.tmp\n");

        write(root, "gitproj/.oxyignore", "!keep.tmp\n");

        write(root, "gitproj/build/out.bin", "");

        write(root, "gitproj/x.tmp", "");

        write(root, "gitproj/keep.tmp", "");

        write(root, "gitproj/src.c", "");

            "gitproj/.gitignore",

            "gitproj/.oxyignore",

            "gitproj/keep.tmp",

            "gitproj/src.c",

delete it. A project's `.gitignore` files are honoured too, so moving a Git

project to Oxygen does not commit its build output; `.oxyignore` comes

first, and a `!` rule there brings back what `.gitignore` leaves out.

| `.oxyignore` | Ignore rules. Gitignore syntax and semantics, per directory, plus `.oxy/info/ignore` and the global ignore file. A directory's `.gitignore` and `.ignore` files are read too, with lower precedence than its `.oxyignore` (a `!` rule there re-includes what they exclude), so a project coming from Git leaves out what Git did. 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. |

/// Folders holding a repository of their own, which oxy leaves out (oxygen#43):

/// named, with how to track them.

fn print_untracked_nested(repo: &Repo, nested: &[String]) {

    if nested.is_empty() {

        return;

    }

    println!();

    println!(

        "{} {}",

        ui::section(ui::warn("Not tracked")),

        ui::dim("folders holding a repository of their own")

    );

    for p in nested {

        let kind = if repo.root().join(p).join(".git").exists() {

            "Git"

        } else {

            "Oxygen"

        };

        println!(

            "  {} {}  {}",

            ui::caution(),

            ui::path(format!("{p}/")),

            ui::dim(format!("a nested {kind} repository"))

        );

    }

    println!(

        "  {} {}",

        ui::note(),

        ui::dim(

            "to track one's files, remove its .git (or .oxy); to keep it a repository of its own, \

             oxy submodule add URL PATH"

        )

    );

}

        print_untracked_nested(&repo, &repo.untracked_nested());

    print_untracked_nested(&repo, &snap.untracked_nested);

    print_untracked_nested(&repo, &repo.untracked_nested());

#[test]

fn a_nested_git_repository_is_named_not_silently_skipped() {

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

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let r = tmp.path().join("repo");

    std::fs::create_dir_all(&r).unwrap();

    assert_eq!(oxy(&r, &home, &["init", "."]).0, 0);

    write(&r, "a.txt", "a\n");

    write(&r, "rust-core/src/lib.rs", "pub fn f() {}\n");

    write(&r, "rust-core/.git/HEAD", "ref: refs/heads/main\n");

    let st = json(&r, &home, &["status", "--json"]);

    assert_eq!(st["untracked_nested"], serde_json::json!(["rust-core"]));

    let (code, out, err) = oxy(&r, &home, &["commit", "-m", "first"]);

    assert_eq!(code, 0, "{err}");

    let out = String::from_utf8_lossy(&out);

    assert!(

        out.contains("rust-core/") && out.contains("nested Git repository"),

        "{out}"

    );

    // The clean status says so too.

    let (_, out, _) = oxy(&r, &home, &["status"]);

    let out = String::from_utf8_lossy(&out);

    assert!(

        out.contains("working copy clean") && out.contains("rust-core/"),

        "{out}"

    );

}