stax 0.29.4

Fast stacked Git branches and PRs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use crate::engine::{BranchMetadata, Stack};
use crate::git::GitRepo;
use crate::ops::receipt::OpKind;
use crate::ops::tx::Transaction;
use anyhow::Result;
use colored::Colorize;

pub fn run(branch: Option<String>, yes: bool) -> Result<()> {
    let repo = GitRepo::open()?;
    let stack = Stack::load(&repo)?;
    let current = repo.current_branch()?;
    let trunk = stack.trunk.clone();
    let target = branch.unwrap_or_else(|| current.clone());

    if target == trunk {
        anyhow::bail!("Cannot detach the trunk branch.");
    }

    let branch_info = stack
        .branches
        .get(&target)
        .ok_or_else(|| anyhow::anyhow!("Branch '{}' is not tracked by stax.", target))?;

    let parent = branch_info
        .parent
        .clone()
        .ok_or_else(|| anyhow::anyhow!("Branch '{}' has no parent.", target))?;

    let children: Vec<String> = branch_info.children.clone();

    if !yes && !children.is_empty() {
        println!(
            "Detaching '{}' will reparent {} child branch(es) onto '{}':",
            target.cyan(),
            children.len(),
            parent.blue()
        );
        for child in &children {
            println!("  {} → {}", child.cyan(), parent.blue());
        }
        println!();
        let confirm = dialoguer::Confirm::new()
            .with_prompt("Continue?")
            .default(true)
            .interact()?;
        if !confirm {
            println!("Aborted.");
            return Ok(());
        }
    }

    // Begin transaction
    let mut tx = Transaction::begin(OpKind::Detach, &repo, false)?;
    tx.plan_branch(&repo, &target)?;
    for child in &children {
        tx.plan_branch(&repo, child)?;
    }
    tx.snapshot()?;

    // Reparent children to detached branch's parent
    for child in &children {
        let child_meta = BranchMetadata::read(repo.inner(), child)?;
        if let Some(meta) = child_meta {
            let parent_rev = repo.branch_commit(&parent)?;
            let merge_base = repo
                .merge_base(&parent, child)
                .unwrap_or_else(|_| parent_rev.clone());
            let updated = BranchMetadata {
                parent_branch_name: parent.clone(),
                parent_branch_revision: merge_base,
                ..meta
            };
            updated.write(repo.inner(), child)?;
        }
        tx.record_after(&repo, child)?;
    }

    // Set detached branch's parent to trunk
    let trunk_rev = repo.branch_commit(&trunk)?;
    let merge_base = repo
        .merge_base(&trunk, &target)
        .unwrap_or_else(|_| trunk_rev.clone());
    let existing = BranchMetadata::read(repo.inner(), &target)?;
    let updated = if let Some(meta) = existing {
        BranchMetadata {
            parent_branch_name: trunk.clone(),
            parent_branch_revision: merge_base,
            ..meta
        }
    } else {
        BranchMetadata::new(&trunk, &merge_base)
    };
    updated.write(repo.inner(), &target)?;
    tx.record_after(&repo, &target)?;

    tx.finish_ok()?;

    println!(
        "Detached '{}' from its stack. It now branches off '{}'.",
        target.green(),
        trunk.blue()
    );

    if !children.is_empty() {
        println!("Reparented:");
        for child in &children {
            println!("  {} → {}", child.cyan(), parent.blue());
        }
    }

    println!(
        "{}",
        "Run `stax restack` to rebase affected branches.".yellow()
    );

    Ok(())
}