use crate::{
Result,
local_mods::{LocalMod, ModSource},
};
use serde::Deserialize;
use std::{
fs,
io::{ErrorKind, Read},
};
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct Changelog {
pub releases: Vec<Release>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct Release {
pub version: String,
pub date: String,
pub categories: Vec<Category>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(default)]
pub struct Category {
pub name: String,
pub entries: Vec<String>,
}
/// Factorio's plain-text changelog. Keep file order and continuation line breaks.
pub fn parse(text: &str) -> Changelog {
let mut log = Changelog::default();
for line in text.trim_start_matches('\u{feff}').lines() {
let trimmed = line.trim();
if trimmed.is_empty() || (trimmed.len() >= 3 && trimmed.bytes().all(|b| b == b'-')) {
continue;
}
if let Some(version) = line.strip_prefix("Version:") {
log.releases.push(Release {
version: version.trim().into(),
..Default::default()
});
continue;
}
let Some(release) = log.releases.last_mut() else {
continue;
};
if let Some(date) = line.strip_prefix("Date:") {
release.date = date.trim().into();
} else if let Some(entry) = line.strip_prefix(" - ") {
if release.categories.is_empty() {
release.categories.push(Category::default());
}
release
.categories
.last_mut()
.unwrap()
.entries
.push(entry.trim_end().into());
} else if line.starts_with(" ") && !line.starts_with(" ") && trimmed.ends_with(':') {
release.categories.push(Category {
name: trimmed.trim_end_matches(':').into(),
entries: vec![],
});
} else if line.starts_with(" ")
&& let Some(entry) = release
.categories
.last_mut()
.and_then(|c| c.entries.last_mut())
{
entry.push('\n');
entry.push_str(trimmed);
}
}
log
}
/// Read only the mod-root changelog; never extract an archive to disk.
/// Missing files are ordinary absence; I/O and corrupt archive errors reach the caller.
pub fn read(mod_: &LocalMod) -> Result<Option<Changelog>> {
let text = match mod_.source {
ModSource::Folder | ModSource::Builtin => {
match fs::read_to_string(mod_.path.join("changelog.txt")) {
Ok(text) => text,
Err(e) if e.kind() == ErrorKind::NotFound => return Ok(None),
Err(e) => return Err(e.into()),
}
}
ModSource::Zip => {
let mut zip = zip::ZipArchive::new(fs::File::open(&mod_.path)?)?;
let names = zip
.file_names()
.collect::<zip::result::ZipResult<Vec<_>>>()?;
let root = names.iter().find_map(|n| {
n.split_once('/')
.filter(|(top, rest)| !top.is_empty() && *rest == "info.json")
.map(|(top, _)| top.to_string())
});
let Some(root) = root else { return Ok(None) };
let mut file = match zip.by_name(&format!("{root}/changelog.txt")) {
Ok(file) => file,
Err(zip::result::ZipError::FileNotFound) => return Ok(None),
Err(e) => return Err(e.into()),
};
let mut text = String::new();
file.read_to_string(&mut text)?;
text
}
};
let log = parse(&text);
Ok((!log.releases.is_empty()).then_some(log))
}
impl Changelog {
pub fn versions(&self) -> Vec<String> {
let mut versions = Vec::new();
for release in &self.releases {
let version = release
.version
.rsplit_once('.')
.map_or(release.version.as_str(), |(v, _)| v);
if !versions.iter().any(|v| v == version) {
versions.push(version.into());
}
}
versions
}
pub fn subversions(&self, version: &str) -> Vec<String> {
std::iter::once("All".into())
.chain(
self.releases
.iter()
.filter(|r| release_line(&r.version) == version)
.map(|r| r.version.clone()),
)
.collect()
}
pub fn display(&self, version: &str, subversion: &str, category: &str) -> (String, String) {
let releases: Vec<_> = self
.releases
.iter()
.filter(|r| {
release_line(&r.version) == version
&& (subversion == "All" || subversion == r.version)
})
.collect();
let mut dates: Vec<_> = releases
.iter()
.map(|r| r.date.as_str())
.filter(|d| !d.is_empty())
.collect();
dates.sort_unstable();
let date = match (dates.first(), dates.last()) {
(Some(first), Some(last)) if first != last => format!("{first} - {last}"),
(Some(date), _) => date.to_string(),
_ => String::new(),
};
let mut text = String::new();
for release in releases {
let categories: Vec<_> = release
.categories
.iter()
.filter(|c| category == "All" || c.name.eq_ignore_ascii_case(category))
.collect();
if categories.is_empty() && category != "All" {
continue;
}
if !text.is_empty() {
text.push('\n');
}
text.push_str(&format!(
"{}\nVersion: {}\n",
"-".repeat(99),
release.version
));
if !release.date.is_empty() {
text.push_str(&format!("Date: {}\n", release.date));
}
for c in categories {
text.push('\n');
if !c.name.is_empty() {
text.push_str(&format!(" {}:\n", c.name));
}
for entry in &c.entries {
let mut lines = entry.lines();
text.push_str(&format!(" - {}\n", lines.next().unwrap_or_default()));
for line in lines {
text.push_str(&format!(" {line}\n"));
}
}
}
}
(text, date)
}
}
fn release_line(version: &str) -> &str {
version.rsplit_once('.').map_or(version, |(line, _)| line)
}