Skip to main content

koji_diff/
parse.rs

1// SPDX-License-Identifier: MPL-2.0
2
3//! Parse Koji build/task references from URLs or prefixed IDs.
4
5use std::fmt;
6
7/// A reference to a Koji build or task.
8#[derive(Debug)]
9pub struct KojiRef {
10    pub instance: String,
11    pub ref_type: RefType,
12    pub id: i64,
13}
14
15#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16pub enum RefType {
17    Build,
18    Task,
19}
20
21impl fmt::Display for RefType {
22    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
23        match self {
24            RefType::Build => write!(f, "build"),
25            RefType::Task => write!(f, "task"),
26        }
27    }
28}
29
30#[derive(Debug)]
31pub struct ParseError(pub String);
32
33impl fmt::Display for ParseError {
34    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
35        write!(f, "{}", self.0)
36    }
37}
38
39impl std::error::Error for ParseError {}
40
41/// Parse a reference string into a [`KojiRef`].
42///
43/// Accepted formats:
44/// - Full URL: `https://koji.fedoraproject.org/koji/buildinfo?buildID=2970379`
45/// - Full URL: `https://koji.fedoraproject.org/koji/taskinfo?taskID=143927217`
46/// - Prefixed: `build:2970379` (requires `default_instance`)
47/// - Prefixed: `task:143927217` (requires `default_instance`)
48pub fn parse_ref(input: &str, default_instance: Option<&str>) -> Result<KojiRef, ParseError> {
49    if input.starts_with("http://") || input.starts_with("https://") {
50        return parse_url(input);
51    }
52
53    if let Some(id_str) = input.strip_prefix("build:") {
54        let instance = default_instance
55            .ok_or_else(|| ParseError("--instance required for bare IDs".into()))?;
56        let id = id_str
57            .parse::<i64>()
58            .map_err(|_| ParseError(format!("invalid build ID: {id_str}")))?;
59        return Ok(KojiRef {
60            instance: instance.to_string(),
61            ref_type: RefType::Build,
62            id,
63        });
64    }
65
66    if let Some(id_str) = input.strip_prefix("task:") {
67        let instance = default_instance
68            .ok_or_else(|| ParseError("--instance required for bare IDs".into()))?;
69        let id = id_str
70            .parse::<i64>()
71            .map_err(|_| ParseError(format!("invalid task ID: {id_str}")))?;
72        return Ok(KojiRef {
73            instance: instance.to_string(),
74            ref_type: RefType::Task,
75            id,
76        });
77    }
78
79    Err(ParseError(format!(
80        "cannot parse reference: {input}\n\
81         Expected: Koji URL, build:<ID>, or task:<ID>"
82    )))
83}
84
85fn parse_url(url: &str) -> Result<KojiRef, ParseError> {
86    let without_scheme = url
87        .strip_prefix("https://")
88        .or_else(|| url.strip_prefix("http://"))
89        .unwrap_or(url);
90
91    let (host, path_and_query) = without_scheme
92        .split_once('/')
93        .ok_or_else(|| ParseError(format!("cannot parse URL: {url}")))?;
94
95    let instance = host.to_string();
96
97    if path_and_query.contains("buildinfo") || path_and_query.contains("buildID") {
98        if let Some(id) = extract_param(url, "buildID") {
99            return Ok(KojiRef {
100                instance,
101                ref_type: RefType::Build,
102                id,
103            });
104        }
105    }
106
107    if path_and_query.contains("taskinfo") || path_and_query.contains("taskID") {
108        if let Some(id) = extract_param(url, "taskID") {
109            return Ok(KojiRef {
110                instance,
111                ref_type: RefType::Task,
112                id,
113            });
114        }
115    }
116
117    Err(ParseError(format!(
118        "cannot extract build/task ID from URL: {url}"
119    )))
120}
121
122fn extract_param(url: &str, param: &str) -> Option<i64> {
123    let query = url.split('?').nth(1)?;
124    for part in query.split('&') {
125        if let Some(value) = part.strip_prefix(&format!("{param}=")) {
126            return value.parse().ok();
127        }
128    }
129    None
130}
131
132#[cfg(test)]
133mod tests {
134    use super::*;
135
136    #[test]
137    fn test_parse_build_url() {
138        let r = parse_ref(
139            "https://koji.fedoraproject.org/koji/buildinfo?buildID=2970379",
140            None,
141        )
142        .unwrap();
143        assert_eq!(r.instance, "koji.fedoraproject.org");
144        assert_eq!(r.ref_type, RefType::Build);
145        assert_eq!(r.id, 2970379);
146    }
147
148    #[test]
149    fn test_parse_task_url() {
150        let r = parse_ref(
151            "https://koji.fedoraproject.org/koji/taskinfo?taskID=143927217",
152            None,
153        )
154        .unwrap();
155        assert_eq!(r.instance, "koji.fedoraproject.org");
156        assert_eq!(r.ref_type, RefType::Task);
157        assert_eq!(r.id, 143927217);
158    }
159
160    #[test]
161    fn test_parse_cbs_url() {
162        let r = parse_ref("https://cbs.centos.org/koji/buildinfo?buildID=12345", None).unwrap();
163        assert_eq!(r.instance, "cbs.centos.org");
164        assert_eq!(r.ref_type, RefType::Build);
165        assert_eq!(r.id, 12345);
166    }
167
168    #[test]
169    fn test_parse_build_prefix() {
170        let r = parse_ref("build:2970379", Some("koji.fedoraproject.org")).unwrap();
171        assert_eq!(r.instance, "koji.fedoraproject.org");
172        assert_eq!(r.ref_type, RefType::Build);
173        assert_eq!(r.id, 2970379);
174    }
175
176    #[test]
177    fn test_parse_task_prefix() {
178        let r = parse_ref("task:143927217", Some("koji.fedoraproject.org")).unwrap();
179        assert_eq!(r.instance, "koji.fedoraproject.org");
180        assert_eq!(r.ref_type, RefType::Task);
181        assert_eq!(r.id, 143927217);
182    }
183
184    #[test]
185    fn test_parse_prefix_without_instance_fails() {
186        let err = parse_ref("build:123", None).unwrap_err();
187        assert!(err.0.contains("--instance"));
188    }
189
190    #[test]
191    fn test_parse_invalid_ref() {
192        let err = parse_ref("foobar", None).unwrap_err();
193        assert!(err.0.contains("cannot parse"));
194    }
195
196    #[test]
197    fn test_parse_url_with_multiple_params() {
198        let r = parse_ref(
199            "https://koji.fedoraproject.org/koji/taskinfo?foo=bar&taskID=999&baz=1",
200            None,
201        )
202        .unwrap();
203        assert_eq!(r.ref_type, RefType::Task);
204        assert_eq!(r.id, 999);
205    }
206
207    #[test]
208    fn test_parse_http_url() {
209        let r = parse_ref(
210            "http://koji.fedoraproject.org/koji/buildinfo?buildID=100",
211            None,
212        )
213        .unwrap();
214        assert_eq!(r.instance, "koji.fedoraproject.org");
215        assert_eq!(r.id, 100);
216    }
217}