Skip to main content

xtask_kit/sparkle/
mod.rs

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/// Static metadata for a Sparkle RSS appcast feed.
10#[derive(Clone, Debug)]
11pub struct Feed {
12    /// RSS channel title.
13    pub title: String,
14    /// Product or website URL.
15    pub link: String,
16    /// RSS channel description.
17    pub description: String,
18    /// RSS language code.
19    pub language: String,
20}
21
22/// One Sparkle release item.
23#[derive(Clone, Debug)]
24pub struct Item {
25    /// Display title, for example `ArcTap 1.2.0`.
26    pub title: String,
27    /// Release notes URL.
28    pub release_notes_url: String,
29    /// CFBundleVersion build number.
30    pub build_number: String,
31    /// CFBundleShortVersionString display version.
32    pub display_version: String,
33    /// Sparkle channel. `stable` is omitted from the XML.
34    pub channel: String,
35    /// Minimum supported macOS version.
36    pub minimum_system_version: String,
37    /// DMG download URL.
38    pub enclosure_url: String,
39    /// DMG file length in bytes.
40    pub enclosure_length: String,
41    /// Sparkle EdDSA signature.
42    pub ed_signature: String,
43    /// RFC 2822 publication date.
44    pub publication_date: String,
45}
46
47impl Item {
48    /// Fill `publication_date` with the current UTC time.
49    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
57/// Create a new appcast XML document containing `item`.
58pub 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
82/// Merge `item` into an existing appcast, removing any item for the same display version.
83pub 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}