git-bra 0.4.0

A Git worktree manager with project-aware configuration.
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
118
119
120

use std::path::{Path, PathBuf};

use anyhow::{Context, Result, anyhow, bail};

use crate::git;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProjectSelector {
    Alias(String),
    RepoPath(PathBuf),
    InferredFromCwd,
}

#[derive(Debug, Clone)]
pub struct ProjectContext {
    pub alias: String,
    pub repo_root: Option<PathBuf>,
}

pub fn selector_from_arg(project: Option<&str>) -> ProjectSelector {
    match project {
        Some(value) => {
            let path = Path::new(value);
            if path.exists() {
                ProjectSelector::RepoPath(path.to_path_buf())
            } else {
                ProjectSelector::Alias(value.to_owned())
            }
        }
        None => ProjectSelector::InferredFromCwd,
    }
}

pub fn resolve_project(project: Option<&str>, cwd: &Path) -> Result<ProjectContext> {
    match selector_from_arg(project) {
        ProjectSelector::RepoPath(path) => {
            let root = git::repo_root(&path)?;
            let origin = git::origin_url(&root).with_context(|| {
                format!("failed to resolve project alias from {}", root.display())
            })?;
            let alias = alias_from_origin_url(&origin)?;
            Ok(ProjectContext {
                alias,
                repo_root: Some(root),
            })
        }
        ProjectSelector::Alias(alias) => Ok(ProjectContext {
            alias,
            repo_root: None,
        }),
        ProjectSelector::InferredFromCwd => {
            let root = git::repo_root(cwd).map_err(|_| {
                anyhow!("not inside a git repository and --project was not provided")
            })?;
            let origin = git::origin_url(&root).with_context(|| {
                format!("failed to resolve project alias from {}", root.display())
            })?;
            let alias = alias_from_origin_url(&origin)?;
            Ok(ProjectContext {
                alias,
                repo_root: Some(root),
            })
        }
    }
}

pub fn require_repo_root(context: &ProjectContext) -> Result<&Path> {
    context.repo_root.as_deref().ok_or_else(|| {
        anyhow!(
            "this command needs a local git repository; pass --project with a repository path or run inside the repo"
        )
    })
}

pub fn alias_from_origin_url(origin: &str) -> Result<String> {
    let trimmed = origin.trim_end_matches('/');
    let last = trimmed
        .rsplit(['/', ':'])
        .next()
        .ok_or_else(|| anyhow!("failed to extract project alias from origin URL '{origin}'"))?;
    let alias = last.trim_end_matches(".git");
    if alias.is_empty() {
        bail!("failed to extract project alias from origin URL '{origin}'")
    }
    Ok(alias.to_owned())
}

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

    #[test]
    fn extracts_alias_from_ssh_url() {
        assert_eq!(
            alias_from_origin_url("git@github.com:some-org/my-project.git").unwrap(),
            "my-project"
        );
    }

    #[test]
    fn extracts_alias_from_https_url() {
        assert_eq!(
            alias_from_origin_url("https://github.com/some-org/my-project.git").unwrap(),
            "my-project"
        );
    }

    #[test]
    fn treats_missing_project_as_inferred() {
        assert_eq!(selector_from_arg(None), ProjectSelector::InferredFromCwd);
    }

    #[test]
    fn treats_nonexistent_argument_as_alias() {
        assert_eq!(
            selector_from_arg(Some("my-project")),
            ProjectSelector::Alias("my-project".to_owned())
        );
    }
}