interprex_github/
issues.rs1use async_trait::async_trait;
9use interprex::{
10 Issue, IssueNumber, IssuesProvider, Label, OpenClosed, ProviderError, Repository, Result,
11};
12use octocrab::Page;
13use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
14use serde::Deserialize;
15
16use crate::{GithubProvider, client::external};
17
18#[derive(Deserialize)]
19struct GithubIssue {
20 number: u64,
21 title: String,
22 body: Option<String>,
23 state: String,
24 #[serde(default)]
25 labels: Vec<GithubLabel>,
26 updated_at: chrono::DateTime<chrono::Utc>,
27 pull_request: Option<serde_json::Value>,
28}
29
30#[derive(Deserialize)]
31struct GithubLabel {
32 name: String,
33 color: String,
34 description: Option<String>,
35}
36
37impl From<GithubLabel> for Label {
38 fn from(value: GithubLabel) -> Self {
39 Self {
40 name: value.name,
41 color: value.color,
42 description: value.description,
43 }
44 }
45}
46
47fn normalize_issue(value: GithubIssue) -> Result<Issue> {
48 if value.pull_request.is_some() {
49 return Err(ProviderError::Unrepresentable {
50 provider: "github",
51 fact: "an issue-domain read addressed a pull request".to_owned(),
52 });
53 }
54 Ok(Issue {
55 number: IssueNumber::new(value.number).map_err(|error| ProviderError::Unrepresentable {
56 provider: "github",
57 fact: error.to_string(),
58 })?,
59 title: value.title,
60 body: value.body,
61 state: match value.state.as_str() {
62 "open" => OpenClosed::Open,
63 "closed" => OpenClosed::Closed,
64 other => {
65 return Err(ProviderError::Unrepresentable {
66 provider: "github",
67 fact: format!("unknown issue state {other}"),
68 });
69 }
70 },
71 labels: value.labels.into_iter().map(Into::into).collect(),
72 updated_at: value.updated_at,
73 })
74}
75
76#[async_trait]
77impl IssuesProvider for GithubProvider {
78 #[tracing::instrument(
79 name = "interprex.provider.issues.issue",
80 skip_all,
81 fields(interprex.provider.name = "github")
82 )]
83 async fn issue(&self, repository: &Repository, number: IssueNumber) -> Result<Issue> {
84 let response: GithubIssue = self
85 .user()?
86 .get(
87 format!("/repos/{repository}/issues/{}", number.get()),
88 None::<&()>,
89 )
90 .await
91 .map_err(|error| {
92 crate::client::read_error(
93 "read issue",
94 format!("issue {} in {repository}", number.get()),
95 error,
96 )
97 })?;
98 normalize_issue(response)
99 }
100
101 #[tracing::instrument(
102 name = "interprex.provider.issues.labels",
103 skip_all,
104 fields(interprex.provider.name = "github")
105 )]
106 async fn labels(&self, repository: &Repository) -> Result<Vec<Label>> {
107 let page: Page<GithubLabel> = self
108 .user()?
109 .get(
110 format!("/repos/{repository}/labels"),
111 Some(&[("per_page", 100)]),
112 )
113 .await
114 .map_err(|error| external("list labels", error))?;
115 let response = self
116 .user()?
117 .all_pages(page)
118 .await
119 .map_err(|error| external("list labels", error))?;
120 Ok(response.into_iter().map(Into::into).collect())
121 }
122
123 #[tracing::instrument(
124 name = "interprex.provider.issues.upsert_label",
125 skip_all,
126 fields(interprex.provider.name = "github")
127 )]
128 async fn upsert_label(&self, repository: &Repository, label: &Label) -> Result<Label> {
129 let existing = self.labels(repository).await?;
130 let response: GithubLabel = if existing.iter().any(|existing| existing.name == label.name) {
131 self.user()?
132 .patch(
133 format!(
134 "/repos/{repository}/labels/{}",
135 utf8_percent_encode(&label.name, NON_ALPHANUMERIC)
136 ),
137 Some(label),
138 )
139 .await
140 .map_err(|error| external("update label", error))?
141 } else {
142 self.user()?
143 .post(format!("/repos/{repository}/labels"), Some(label))
144 .await
145 .map_err(|error| external("create label", error))?
146 };
147 Ok(response.into())
148 }
149}
150
151#[cfg(test)]
152mod tests {
153 use super::{GithubIssue, normalize_issue};
154
155 #[test]
156 fn issue_fixture_normalizes_labels_and_state() {
157 let response: GithubIssue =
158 serde_json::from_str(include_str!("../tests/fixtures/issue.json")).expect("fixture");
159 let issue = normalize_issue(response).expect("normalizes");
160 assert_eq!(issue.number.get(), 11);
161 assert_eq!(issue.labels[0].name, "feature");
162 }
163
164 #[test]
165 fn unknown_issue_states_are_unrepresentable() {
166 let mut response: GithubIssue =
167 serde_json::from_str(include_str!("../tests/fixtures/issue.json")).expect("fixture");
168 response.state = "reopening".to_owned();
169 let error = normalize_issue(response).expect_err("unknown state must be unrepresentable");
170 assert!(matches!(
171 error,
172 interprex::ProviderError::Unrepresentable { fact, .. }
173 if fact.contains("unknown issue state")
174 ));
175 }
176}