bounty 0.2.0

A CLI tool for managing GitHub bounties
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use eyre::Result;
use regex::Regex;
use url::Url;

#[derive(Debug, PartialEq, Eq)]
pub struct RepoIssue {
    pub owner: String,
    pub repo: String,
    pub issue_number: u64,
}

impl RepoIssue {
    /// Parse a repository issue reference from various formats:
    /// - Full URL: <https://github.com/owner/repo/issues/123>
    /// - Domain URL: github.com/owner/repo/issues/123
    /// - Path only: owner/repo/issues/123
    /// - Short form: owner/repo/123
    /// - Issue reference: owner/repo#123
    pub fn parse(input: &str) -> Result<Self> {
        // Try parsing as URL first
        if let Ok(url) = Url::parse(input) {
            return Self::from_url(&url);
        }

        // Try parsing as domain URL (add https:// prefix)
        if input.starts_with("github.com/") {
            if let Ok(url) = Url::parse(&format!("https://{input}")) {
                return Self::from_url(&url);
            }
        }

        // Try parsing as path or issue reference
        Self::from_path(input)
    }

    fn from_url(url: &Url) -> Result<Self> {
        let path = url.path().trim_start_matches('/');
        Self::from_path(path)
    }

    fn from_path(path: &str) -> Result<Self> {
        // Match patterns like:
        // - owner/repo/issues/123
        // - owner/repo/123
        // - owner/repo#123
        let re = Regex::new(r"^([^/]+)/([^/#]+)(?:/(?:issues/)?|#)(\d+)$").unwrap();

        if let Some(caps) = re.captures(path) {
            let owner = caps[1].to_string();
            let repo = caps[2].to_string();
            let issue_number = caps[3].parse()?;

            Ok(Self {
                owner,
                repo,
                issue_number,
            })
        } else {
            Err(eyre::eyre!("Invalid repository issue reference format"))
        }
    }
}

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

    #[test]
    fn test_parse_full_url() {
        let input = "https://github.com/ghbountybot/cli/issues/2";
        let result = RepoIssue::parse(input).unwrap();
        assert_eq!(
            result,
            RepoIssue {
                owner: "ghbountybot".to_string(),
                repo: "cli".to_string(),
                issue_number: 2
            }
        );
    }

    #[test]
    fn test_parse_domain_url() {
        let input = "github.com/ghbountybot/cli/issues/2";
        let result = RepoIssue::parse(input).unwrap();
        assert_eq!(
            result,
            RepoIssue {
                owner: "ghbountybot".to_string(),
                repo: "cli".to_string(),
                issue_number: 2
            }
        );
    }

    #[test]
    fn test_parse_path_only() {
        let input = "ghbountybot/cli/issues/2";
        let result = RepoIssue::parse(input).unwrap();
        assert_eq!(
            result,
            RepoIssue {
                owner: "ghbountybot".to_string(),
                repo: "cli".to_string(),
                issue_number: 2
            }
        );
    }

    #[test]
    fn test_parse_short_form() {
        let input = "ghbountybot/cli/2";
        let result = RepoIssue::parse(input).unwrap();
        assert_eq!(
            result,
            RepoIssue {
                owner: "ghbountybot".to_string(),
                repo: "cli".to_string(),
                issue_number: 2
            }
        );
    }

    #[test]
    fn test_parse_issue_reference() {
        let input = "ghbountybot/cli#2";
        let result = RepoIssue::parse(input).unwrap();
        assert_eq!(
            result,
            RepoIssue {
                owner: "ghbountybot".to_string(),
                repo: "cli".to_string(),
                issue_number: 2
            }
        );
    }

    #[test]
    fn test_parse_invalid_input() {
        let inputs = [
            "not-a-url",
            "ghbountybot",
            "ghbountybot/",
            "ghbountybot/cli",
            "ghbountybot/cli/",
            "ghbountybot/cli/issues",
            "ghbountybot/cli/issues/",
            "ghbountybot/cli/issues/abc",
        ];

        for input in inputs {
            assert!(
                RepoIssue::parse(input).is_err(),
                "Expected error for input: {input}"
            );
        }
    }
}