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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
use std::{
path::PathBuf,
fs::{ self, File }
};
use sqlx::prelude::*;
use atom_syndication::*;
use anyhow::{ Result, Context };
use futures::{ Stream, StreamExt };
use chrono::{ Utc, TimeZone };
use url::Url;
use tracing::info;
use crate::{ Conn, query::{ self, repo_id } };
#[allow(dead_code)]
#[derive(sqlx::FromRow)]
struct Issue {
number: i64,
state: i64,
title: String,
body: String,
user_login: String,
html_url: String,
updated_at: i64
}
// Naive implementation of https://www.w3.org/TR/REC-xml/#syntax
fn entity_escape(from: &str) -> String {
let mut escaped = String::with_capacity(from.len());
for c in from.chars() {
match c {
'&' => escaped.push_str("&"),
'<' => escaped.push_str("<"),
'>' => escaped.push_str(">"),
'\'' => escaped.push_str("'"),
'"' => escaped.push_str("""),
any => escaped.push(any)
}
}
escaped
}
async fn query_issues_for_label<'conn>(conn: &'conn mut Conn,
repo_id: i64, label: &str, only_open: bool) -> impl Stream<Item=sqlx::Result<Issue>> + 'conn {
sqlx::query_as::<_, Issue>(r#"
SELECT issues.number, state, title, body, user_login, html_url, updated_at FROM issues
INNER JOIN is_labeled ON is_labeled.issue=issues.number
WHERE is_labeled.label=(SELECT id FROM labels WHERE repo=? AND name=?)
AND (?=0 OR issues.state=?)
ORDER BY issues.number DESC
"#).bind(repo_id).bind(label)
.bind(only_open).bind(query::issues::IssueState::OPEN.to_integer())
.fetch(conn)
}
async fn issue_to_entry(conn: &mut Conn, repo_id: i64, issue: Issue) -> Result<Entry> {
let state_label = query::issues::IssueState::from_integer(issue.state)
.expect("Inconsistent database, invalid issue state").to_string();
let labels_of_issue = sqlx::query_as::<_, (String,)>(
"SELECT labels.name FROM is_labeled
JOIN labels ON is_labeled.label=labels.id
JOIN issues ON (is_labeled.issue=issues.number AND is_labeled.repo=issues.repo)
WHERE is_labeled.repo=? AND is_labeled.issue=?"
).bind(repo_id).bind(issue.number)
.fetch(&mut *conn);
let all_labels = futures::stream::iter(state_label)
.chain(labels_of_issue
.filter_map(|row| async { row.ok() })
.map(|(name,)| name))
.map(|name| Category {
term: name,
scheme: None,
label: None
})
.collect::<Vec<_>>()
.await;
Ok(EntryBuilder::default()
.title(entity_escape(&issue.title))
.id(entity_escape(&issue.html_url))
.updated(Utc.timestamp(issue.updated_at, 0))
.authors(vec![
Person {
uri: Some(format!("https://github.com/{}", issue.user_login)),
name: issue.user_login,
email: None
}
])
.categories(all_labels)
.links(vec![LinkBuilder::default()
.href(issue.html_url)
.build()
.expect("Failed to build link")])
.content(ContentBuilder::default()
.content_type(Some(String::from("html")))
.value(entity_escape(&issue.body))
.build()
.expect("Failed to build content"))
.build()
.map_err(|err_str| anyhow::anyhow!(err_str))
.context("Failed to build atom entry")?)
}
pub async fn generate(mut conn: &mut Conn, (ref owner, ref name): (String, String),
out_path: PathBuf, labels: Vec<String>,
only_open: bool) -> Result<()> {
let labels = if labels.is_empty() {
sqlx::query_as::<_, (String,)>(
"SELECT name FROM labels WHERE repo=(SELECT id FROM repositories WHERE owner=? AND name=?)"
).bind(owner).bind(name)
.fetch(&mut *conn)
.filter_map(|row| async { match row {
Ok((label,)) => Some(label),
_ => None
} })
.collect()
.await
} else { labels };
let repo_id = repo_id(&mut conn, owner, name).await?;
for label in labels {
info!("atom for {:?}", label);
let label_url = {
let mut url = Url::parse("https://github.com")?;
url.path_segments_mut()
.unwrap()
.push(owner).push(name)
.push("labels").push(&label);
url.into_string()
};
let mut feed = FeedBuilder::default();
feed.title(entity_escape(&label));
feed.id(&label_url);
feed.updated(Utc::now());
feed.links(vec![
LinkBuilder::default()
.href(&label_url)
.rel("alternate")
.build()
.map_err(anyhow::Error::msg)?
]);
let issues: Vec<Issue> = query_issues_for_label(&mut conn, repo_id, &label, only_open).await
.filter_map(|res| async { res.ok() })
.collect().await;
let entries: Vec<Entry> = {
let mut acc = Vec::new();
for issue in issues.into_iter() {
acc.push(issue_to_entry(&mut conn, repo_id, issue).await?);
}
acc
};
feed.entries(entries);
let feed = feed.build().expect("Failed to build feed");
let feed_directory = out_path.join(label);
fs::create_dir_all(&feed_directory)?;
let feed_path = feed_directory.join("atom.xml");
let mut out_file = File::create(feed_path)?;
feed.write_to(&mut out_file)?;
}
Ok(())
}
|