1use std::io::Cursor;
2
3use anyhow::{Context, Result};
4use quick_xml::events::{BytesDecl, BytesEnd, BytesStart, BytesText, Event};
5use quick_xml::{Reader, Writer};
6use time::OffsetDateTime;
7use time::format_description::well_known::Rfc2822;
8
9#[derive(Clone, Debug)]
11pub struct Feed {
12 pub title: String,
14 pub link: String,
16 pub description: String,
18 pub language: String,
20}
21
22#[derive(Clone, Debug)]
24pub struct Item {
25 pub title: String,
27 pub release_notes_url: String,
29 pub build_number: String,
31 pub display_version: String,
33 pub channel: String,
35 pub minimum_system_version: String,
37 pub enclosure_url: String,
39 pub enclosure_length: String,
41 pub ed_signature: String,
43 pub publication_date: String,
45}
46
47impl Item {
48 pub fn with_current_publication_date(mut self) -> Result<Self> {
50 self.publication_date = OffsetDateTime::now_utc()
51 .format(&Rfc2822)
52 .context("format Sparkle pubDate")?;
53 Ok(self)
54 }
55}
56
57pub fn new_appcast(feed: &Feed, item: &Item) -> Result<String> {
59 let mut writer = xml_writer();
60 writer.write_event(Event::Decl(BytesDecl::new("1.0", Some("utf-8"), None)))?;
61
62 let mut rss = BytesStart::new("rss");
63 rss.push_attribute(("version", "2.0"));
64 rss.push_attribute((
65 "xmlns:sparkle",
66 "http://www.andymatuschak.org/xml-namespaces/sparkle",
67 ));
68 writer.write_event(Event::Start(rss))?;
69
70 writer.write_event(Event::Start(BytesStart::new("channel")))?;
71 write_text_element(&mut writer, "title", &feed.title)?;
72 write_text_element(&mut writer, "link", &feed.link)?;
73 write_text_element(&mut writer, "description", &feed.description)?;
74 write_text_element(&mut writer, "language", &feed.language)?;
75 write_item(&mut writer, item)?;
76 writer.write_event(Event::End(BytesEnd::new("channel")))?;
77 writer.write_event(Event::End(BytesEnd::new("rss")))?;
78
79 writer_to_string(writer)
80}
81
82pub fn merge_appcast(existing: &str, item: &Item) -> Result<String> {
84 let mut reader = Reader::from_str(existing);
85 reader.config_mut().trim_text(false);
86 let mut writer = xml_writer();
87 let mut inserted = false;
88
89 loop {
90 match reader.read_event()? {
91 Event::Eof => break,
92 Event::Start(start) if start.name().as_ref() == b"item" => {
93 let events = collect_item_events(&mut reader, start.into_owned())?;
94 if !item_events_match_version(&events, &item.display_version)? {
95 write_events(&mut writer, &events)?;
96 }
97 }
98 Event::End(end) if end.name().as_ref() == b"channel" => {
99 if !inserted {
100 write_item(&mut writer, item)?;
101 inserted = true;
102 }
103 writer.write_event(Event::End(end.into_owned()))?;
104 }
105 event => writer.write_event(event.into_owned())?,
106 }
107 }
108
109 if !inserted {
110 write_item(&mut writer, item)?;
111 }
112
113 writer_to_string(writer)
114}
115
116fn collect_item_events(
117 reader: &mut Reader<&[u8]>,
118 start: BytesStart<'static>,
119) -> Result<Vec<Event<'static>>> {
120 let mut events = vec![Event::Start(start)];
121 let mut depth = 1usize;
122 while depth > 0 {
123 let event = reader.read_event()?.into_owned();
124 match &event {
125 Event::Start(_) => depth += 1,
126 Event::End(_) => depth -= 1,
127 _ => {}
128 }
129 events.push(event);
130 }
131 Ok(events)
132}
133
134fn item_events_match_version(events: &[Event<'static>], display_version: &str) -> Result<bool> {
135 let mut current: Option<Vec<u8>> = None;
136 for event in events {
137 match event {
138 Event::Start(start)
139 if start.name().as_ref() == b"sparkle:shortVersionString"
140 || start.name().as_ref() == b"sparkle:version" =>
141 {
142 current = Some(start.name().as_ref().to_vec());
143 }
144 Event::Text(text)
145 if current.is_some() && text.decode()?.as_ref() == display_version =>
146 {
147 return Ok(true);
148 }
149 Event::End(end)
150 if current
151 .as_deref()
152 .is_some_and(|name| name == end.name().as_ref()) =>
153 {
154 current = None;
155 }
156 _ => {}
157 }
158 }
159 Ok(false)
160}
161
162fn write_events(writer: &mut Writer<Cursor<Vec<u8>>>, events: &[Event<'static>]) -> Result<()> {
163 let mut index = 0;
164 while index < events.len() {
165 if is_stable_channel_triplet(events, index)? {
166 index += 3;
167 continue;
168 }
169 writer.write_event(events[index].clone())?;
170 index += 1;
171 }
172 Ok(())
173}
174
175fn is_stable_channel_triplet(events: &[Event<'static>], index: usize) -> Result<bool> {
176 let [Event::Start(start), Event::Text(text), Event::End(end)] =
177 events.get(index..index + 3).unwrap_or(&[])
178 else {
179 return Ok(false);
180 };
181 Ok(start.name().as_ref() == b"sparkle:channel"
182 && end.name().as_ref() == b"sparkle:channel"
183 && text.decode()?.as_ref() == "stable")
184}
185
186fn write_item(writer: &mut Writer<Cursor<Vec<u8>>>, item: &Item) -> Result<()> {
187 writer.write_event(Event::Start(BytesStart::new("item")))?;
188 write_text_element(writer, "title", &item.title)?;
189 write_text_element(writer, "sparkle:releaseNotesLink", &item.release_notes_url)?;
190 write_text_element(writer, "pubDate", &item.publication_date)?;
191 write_text_element(writer, "sparkle:version", &item.build_number)?;
192 write_text_element(writer, "sparkle:shortVersionString", &item.display_version)?;
193 if item.channel != "stable" {
194 write_text_element(writer, "sparkle:channel", &item.channel)?;
195 }
196 write_text_element(
197 writer,
198 "sparkle:minimumSystemVersion",
199 &item.minimum_system_version,
200 )?;
201
202 let mut enclosure = BytesStart::new("enclosure");
203 enclosure.push_attribute(("url", item.enclosure_url.as_str()));
204 enclosure.push_attribute(("length", item.enclosure_length.as_str()));
205 enclosure.push_attribute(("type", "application/octet-stream"));
206 enclosure.push_attribute(("sparkle:edSignature", item.ed_signature.as_str()));
207 writer.write_event(Event::Empty(enclosure))?;
208 writer.write_event(Event::End(BytesEnd::new("item")))?;
209 Ok(())
210}
211
212fn write_text_element(writer: &mut Writer<Cursor<Vec<u8>>>, name: &str, text: &str) -> Result<()> {
213 writer.write_event(Event::Start(BytesStart::new(name)))?;
214 writer.write_event(Event::Text(BytesText::new(text)))?;
215 writer.write_event(Event::End(BytesEnd::new(name)))?;
216 Ok(())
217}
218
219fn xml_writer() -> Writer<Cursor<Vec<u8>>> {
220 Writer::new_with_indent(Cursor::new(Vec::new()), b' ', 2)
221}
222
223fn writer_to_string(writer: Writer<Cursor<Vec<u8>>>) -> Result<String> {
224 String::from_utf8(writer.into_inner().into_inner()).context("appcast XML is not UTF-8")
225}