Rebase: --into-working-copy resolves a conflicted rebase in the working copy (closes #42) e266b7d4065c

        let (_, op) = self.head_op()?;

        if name == self.config.bookmark {

        self.merge_heads(other, &format!("oxy merge {name}"))

    }

    /// Bring CHANGE up to date with `onto` where a rebase would be

    /// conflicted (oxygen#42): the state of `onto` is merged into the

    /// current bookmark, which must hold the change, and a working copy

    /// without changes follows, so the conflict is resolved there and

    /// committed on top, as after `oxy merge`.

    pub fn rebase_into_working_copy(

        &self,

        c: &ChangeHash,

        onto: &[ChangeHash],

    ) -> Result<MergeReport> {

        let _wc = self.lock_working_copy()?;

        let (_, op) = self.head_op()?;

        let current = self.config.bookmark.clone();

        let local = self.heads_of(&op.view, &current)?;

        if !self.load_state_indexed(&local)?.contains(c) {

            return fail(format!(

                "#{} is not on the current bookmark {current}; switch to the bookmark \

                 holding it first",

                c.short(12)

            ));

        }

        let named: Vec<String> = onto.iter().map(|h| h.short(12)).collect();

        let label = format!(

            "oxy rebase {} --onto {} --into-working-copy",

            c.short(12),

            named.join(" ")

        );

        self.merge_heads(onto.to_vec(), &label)

    }

    /// Union `other` into the current bookmark's heads, recorded as

    /// `label`; a working copy without changes follows.

    fn merge_heads(&self, other: Vec<ChangeHash>, label: &str) -> Result<MergeReport> {

        let (op_ref, op) = self.head_op()?;

        let current = self.config.bookmark.clone();

        self.record_op(&[op_ref], label, view)?;

        let snap = self.snapshot(label)?;

            self.checkout(&heads, false, &format!("{label} (checkout)"))?;

                return Err(RepoError::Conflicted(format!(

                     To resolve it in the working copy instead, on the bookmark holding #{} \

                     pass --into-working-copy (the target is merged in), fix the marked files \

                     and oxy commit",

                )));

    /// The operation would leave a conflict where none may be (a rebased

    /// change cannot hold one); the caller may offer another way.

    #[error("{0}")]

    Conflicted(String),

#[test]

fn a_conflicted_rebase_can_be_resolved_in_the_working_copy() {

    hermetic();

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

    let root = dir.path();

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

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

    let a = repo.commit("A", &[]).unwrap();

    repo.bookmark_create("develop", Some(&[a])).unwrap();

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

    let c = repo.commit("C: 2 to X", &[]).unwrap();

    repo.bookmark_switch("develop", false).unwrap();

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

    let d = repo.commit("D: 2 to Y", &[]).unwrap();

    repo.bookmark_switch("main", false).unwrap();

    let err = repo.rebase(&c, &[d]).unwrap_err();

    assert!(matches!(err, RepoError::Conflicted(_)), "{err}");

    let r = repo.rebase_into_working_copy(&c, &[d]).unwrap();

    assert!(r.changed && r.checked_out);

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

    assert!(

        snap.base_snapshot.is_conflicted(),

        "the conflict is in the working copy"

    );

    let text = fs::read_to_string(root.join("a.txt")).unwrap();

    assert!(text.contains('X') && text.contains('Y'), "{text}");

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

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

    let st = repo.load_state(&repo.bookmark_heads().unwrap()).unwrap();

    assert!(st.contains(&c) && st.contains(&d));

    let files = st.materialize().files;

    assert!(!files["a.txt"].is_conflicted());

    assert!(

        matches!(&files["a.txt"].content, FileContent::Text { bytes, .. } if bytes == b"1\nXY\n")

    );

    // A change the current bookmark does not hold is refused.

    repo.bookmark_switch("develop", false).unwrap();

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

    let e = repo.commit("E", &[]).unwrap();

    repo.bookmark_switch("main", false).unwrap();

    let err = repo.rebase_into_working_copy(&e, &[a]).unwrap_err();

    assert!(

        err.to_string().contains("not on the current bookmark"),

        "{err}"

    );

}

- [x] R1 **Rebase into the working copy** (oxygen#42, Andy's choice for the

oxy rebase 658990aa --onto develop --into-working-copy   # conflicted? resolve it here, then commit

**Rebase.** `oxy rebase C --onto HEADS` re-expresses `C` against a different base: the state `HEADS` names is materialized with and without `C` added to it (commutation makes the union meaningful, and `HEADS` must contain `C`'s dependencies), the difference is re-derived as edits against the `HEADS` state, and the new change keeps `C`'s ChangeId with dependencies computed from what it now references (plus `HEADS` as explicit dependencies). This is the move a Git user makes with `rebase --onto`: it changes what a change is said to build on. It is refused when `HEADS` conflicts in any file `C` touches, since the re-derivation would have no single text to diff against, and when the result would be empty. With `--into-working-copy`, a rebase that would be conflicted instead merges the `HEADS` state into the current bookmark, which must hold `C`: a working copy without changes follows, so the conflict is fixed there and committed as a resolution on top, as after `oxy merge` (§10.1). Dependents of `C` are rewritten per §8.4. Because commuting changes already coexist, the common reason to rebase is to drop an accidental dependency, for instance on a change that is to be abandoned.

oxy commit [PATH].. [--interactive]         oxy squash CHANGE --into DEST   oxy rebase CHANGE --onto HEADS.. [--into-working-copy]

        /// Where the rebase would be conflicted, merge the target into the

        /// current bookmark instead, leaving the conflict in the working

        /// copy to fix and commit

        #[arg(long)]

        into_working_copy: bool,

        Cmd::Rebase {

            change,

            onto,

            into_working_copy,

        } => workspace::rebase(&change, &onto, into_working_copy),

pub fn rebase(change: &str, onto: &[String], into_working_copy: bool) -> Result<i32> {

    let h = match repo.rebase(&c, &heads) {

        Err(oxy_core::repo::RepoError::Conflicted(_)) if into_working_copy => {

            let r = repo.rebase_into_working_copy(&c, &heads)?;

            sp.done(&format!(

                "{} {} into {}: now {}",

                ui::done("Merged"),

                onto.join(" "),

                ui::bookmark(&repo.config.bookmark),

                plural(r.heads.len(), "head"),

            ));

            if r.checked_out {

                println!(

                    "  {} {}",

                    ui::caution(),

                    ui::warn("the conflict is in the working copy: fix the marked files (see oxy status), then oxy commit")

                );

            } else {

                println!(

                    "  {} {}",

                    ui::caution(),

                    ui::warn("the working copy has changes of its own: commit or discard them, then oxy checkout to take the conflict in")

                );

            }

            return Ok(0);

        }

        other => other?,

    };