Commit a resolution by paths, and amend only some paths 69953b507188

    /// Fold only `paths` of the working copy into the head it sits on

    /// (oxygen#118): they are committed as a change of their own, on the

    /// head, which is then squashed into it; the rest stays uncommitted

    /// work. A new `message` replaces the head's.

    pub fn amend_paths(&self, message: Option<&str>, paths: &[String]) -> Result<ChangeHash> {

        let snap = self.snapshot("oxy amend")?;

        let base_heads = snap.base.maximal(&snap.wc.deps);

        let [head] = base_heads.as_slice() else {

            return fail(format!(

                "the working copy sits on {} heads; check out the single change to amend",

                base_heads.len()

            ));

        };

        let head = *head;

        self.rewritable_head(&head)?;

        drop(snap);

        let (part, _) = self.commit_selection_partial(

            "oxy amend: the paths to fold in",

            &[head],

            &Selection::Paths(paths.to_vec()),

        )?;

        let folded = self.squash(&part, &head)?;

        match message {

            Some(m) => self.describe(&folded, m),

            None => Ok(folded),

        }

    }

        // A resolution may leave other work uncommitted (oxygen#118), but

        // takes every file it resolves, whole.

            let resolved = snap

                .statuses

                .iter()

                .filter(|s| s.status == ChangeStatus::Resolved)

                .map(|s| s.path.as_str());

            let missing: Vec<&str> = match selection {

                Selection::Paths(paths) => resolved

                    .filter(|p| {

                        !paths.iter().any(|x| {

                            p == x || p.starts_with(&format!("{}/", x.trim_end_matches('/')))

                        })

                    })

                    .collect(),

                _ => resolved.collect(),

            };

            if !missing.is_empty() {

                return fail(format!(

                    "a conflict resolution takes every file it resolves, whole: commit by paths, including {}",

                    missing.join(", ")

                ));

            }

/// oxygen#118 (Metal Gear): a resolution commits by paths, leaving other

/// work uncommitted, so long as it takes every file it resolves; and

/// `amend PATHS` folds only those paths into the head.

fn resolutions_and_amends_take_paths() {

    hermetic();

    let (dir, repo, _h1, _h2, _h3) = conflicted_repo();

    let root = dir.path();

    repo.checkout(&repo.bookmark_heads().unwrap(), false, "checkout main")

        .unwrap();

    // The conflict resolved, and other work beside it.

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

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

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

    assert!(s.resolves);

    let err = repo

        .commit_selection_partial("resolve", &[], &Selection::Paths(vec!["notes.txt".into()]))

        .unwrap_err()

        .to_string();

    assert!(

        err.contains("takes every file it resolves") && err.contains("f.txt"),

        "{err}"

    );

    let (h4, partial) = repo

        .commit_selection_partial("resolve", &[], &Selection::Paths(vec!["f.txt".into()]))

        .unwrap();

    assert!(partial);

    assert_eq!(

        repo.store().get_change(&h4).unwrap().kind,

        ChangeKind::Resolution

    );

    assert!(!repo

        .load_state(&[h4])

        .unwrap()

        .materialize()

        .is_conflicted());

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

    assert_eq!(

        statuses(&s),

        vec![("notes.txt".into(), ChangeStatus::Added)],

        "the other work waits"

    );

    // amend PATHS: only those paths join the head; it keeps its ChangeId.

    // On the resolution, so the bookmark has one head to amend.

    let h5 = repo.commit("notes", &[h4]).unwrap();

    let id5 = repo.store().get_change(&h5).unwrap().change_id;

    write(root, "notes.txt", b"pending\nmore\n");

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

    let h6 = repo

        .amend_paths(Some("notes, amended"), &["notes.txt".into()])

        .unwrap();

    let c6 = repo.store().get_change(&h6).unwrap();

    assert_eq!((c6.change_id, c6.message.as_str()), (id5, "notes, amended"));

    assert_eq!(repo.bookmark_heads().unwrap(), vec![h6]);

    let snap6 = repo.load_state(&[h6]).unwrap().materialize();

    assert!(

        matches!(&snap6.files["notes.txt"].content, FileContent::Text { bytes, .. } if bytes == b"pending\nmore\n")

    );

    assert!(

        !snap6.files.contains_key("other.txt"),

        "other.txt stays out"

    );

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

    assert_eq!(

        statuses(&s),

        vec![("other.txt".into(), ChangeStatus::Added)]

    );

}

#[test]

- A **resolution** (a working copy that resolves its base's conflicts, §9.6) may be committed by paths too, so other work need not be put aside (oxygen#118): the named paths must include every file it resolves, whole, or the commit is refused naming them; what is left stays uncommitted on top of the resolved state. `oxy amend PATH..` folds only those paths into the head (committed as a change on it, then squashed into it, §8.5), leaving the rest uncommitted; `-m` replaces the head's message as usual.

oxy describe [CHANGE] [-m MSG]      oxy amend [-m MSG] [--into CHANGE | PATH..]

        #[arg(long, conflicts_with = "paths")]

        /// Fold in only these paths; the rest stays as uncommitted work

        paths: Vec<String>,

        Cmd::Amend {

            message,

            into,

            paths,

        } => workspace::amend(message.as_deref(), into.as_deref(), &paths),

pub fn amend(message: Option<&str>, into: Option<&str>, paths: &[String]) -> Result<i32> {

        None if !paths.is_empty() => repo.amend_paths(message, paths)?,