stax 0.50.2

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

use crate::config::Config;
use crate::engine::Stack;
use crate::git::GitRepo;
use crate::remote::RemoteInfo;
use anyhow::Result;
use arboard::Clipboard;
use colored::Colorize;

/// What to copy to clipboard
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CopyTarget {
    /// Copy branch name (default)
    #[default]
    Branch,
    /// Copy PR URL
    Pr,
}

/// Copy branch name or PR URL to clipboard
pub fn run(target: CopyTarget) -> Result<()> {
    let repo = GitRepo::open()?;
    let current = repo.current_branch()?;

    let text = match target {
        CopyTarget::Branch => current.clone(),
        CopyTarget::Pr => {
            let stack = Stack::load(&repo)?;
            let config = Config::load()?;

            // Check if branch is tracked
            let branch_info = stack.branches.get(&current);
            if branch_info.is_none() {
                anyhow::bail!(
                    "Branch '{}' is not tracked. Use {} to track it first.",
                    current,
                    "stax branch track".cyan()
                );
            }

            // Resolve PR number (local metadata or forge fallback)
            let pr_number = super::resolve_pr::resolve_pr_number(&repo, &stack, &current, &config)?;
            if pr_number.is_none() {
                anyhow::bail!(
                    "No PR found for branch '{}'. Use {} to create one.",
                    current,
                    "stax submit".cyan()
                );
            }

            let pr_number = pr_number.unwrap();
            let remote_info = RemoteInfo::from_repo(&repo, &config)?;
            remote_info.pr_url(pr_number)
        }
    };

    // Copy to clipboard
    let mut clipboard =
        Clipboard::new().map_err(|e| anyhow::anyhow!("Failed to access clipboard: {}", e))?;
    clipboard
        .set_text(&text)
        .map_err(|e| anyhow::anyhow!("Failed to copy to clipboard: {}", e))?;

    let label = match target {
        CopyTarget::Branch => "Branch name",
        CopyTarget::Pr => "PR URL",
    };

    println!("{} copied to clipboard: {}", label, text.cyan());

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_copy_target_default() {
        let target = CopyTarget::default();
        assert_eq!(target, CopyTarget::Branch);
    }

    #[test]
    fn test_copy_target_variants() {
        assert_ne!(CopyTarget::Branch, CopyTarget::Pr);
    }

    #[test]
    fn test_copy_target_clone() {
        let target = CopyTarget::Pr;
        let cloned = target.clone();
        assert_eq!(target, cloned);
    }

    #[test]
    fn test_copy_target_debug() {
        let target = CopyTarget::Branch;
        let debug_str = format!("{:?}", target);
        assert_eq!(debug_str, "Branch");

        let target_pr = CopyTarget::Pr;
        let debug_str_pr = format!("{:?}", target_pr);
        assert_eq!(debug_str_pr, "Pr");
    }

    #[test]
    fn test_copy_target_copy_trait() {
        let target = CopyTarget::Branch;
        let copied = target; // Copy, not move
        assert_eq!(target, copied); // Original still accessible
    }
}