1435 строк · 74 КиБ
code/crates/chl-core/src/library.rs
| 1 | //! Библиотека игр: что установлено и где лежит исполняемый файл. |
| 2 | //! |
| 3 | //! В StartWine этой сущности как таковой нет. Путь к exe передаётся в |
| 4 | //! `sw_runlib` аргументом командной строки (`sw_runlib:806`), а интерфейс |
| 5 | //! держит свой индекс в `~/.cache/sw_fm/exe_data.json` — то есть **в |
| 6 | //! кэше**. Потерять кэш означает потерять библиотеку, хотя это |
| 7 | //! пользовательские данные, а не кэш. |
| 8 | //! |
| 9 | //! Здесь библиотека — данные, и лежит она в каталоге данных, а не кэша |
| 10 | //! (см. [`crate::paths::Dirs`]). Это одна из причин разделения каталогов по |
| 11 | //! ценности. |
| 12 | |
| 13 | use std::collections::BTreeMap; |
| 14 | use std::path::{Path, PathBuf}; |
| 15 | |
| 16 | use anyhow::{Context, Result, bail}; |
| 17 | use serde::{Deserialize, Serialize}; |
| 18 | |
| 19 | /// Игра или обычная программа — Photoshop и подобные, добавленные тем же |
| 20 | /// «Открыть с помощью», что и любая игра. |
| 21 | /// |
| 22 | /// Отличие не про то, во что интереснее играть, а про то, какие настройки |
| 23 | /// вообще имеют смысл ([`crate::settings::NOT_FOR_APPLICATIONS`]) и что |
| 24 | /// лаунчер обязан сказать вслух при ручном добавлении |
| 25 | /// ([`APPLICATION_DISCLAIMER`]): |
| 26 | /// программа не покупается через магазин игр, и её лицензию человек несёт |
| 27 | /// сам. `Game` — умолчание: и старые записи библиотеки без этого поля |
| 28 | /// (`serde(default)`), и подавляющее большинство того, что здесь вообще |
| 29 | /// заводят. |
| 30 | #[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)] |
| 31 | pub enum GameKind { |
| 32 | #[default] |
| 33 | Game, |
| 34 | Application, |
| 35 | } |
| 36 | |
| 37 | impl GameKind { |
| 38 | pub fn title(&self) -> &'static str { |
| 39 | match self { |
| 40 | GameKind::Game => "Игра", |
| 41 | GameKind::Application => "Программа", |
| 42 | } |
| 43 | } |
| 44 | } |
| 45 | |
| 46 | /// Показывается при ручном добавлении, когда человек отмечает «Это не |
| 47 | /// игра, а обычная программа» — до того, как он нажмёт «Добавить», а не |
| 48 | /// после. Тон — не запрет и не мораль, а факт: лаунчер прогоняет |
| 49 | /// Windows-программы через Wine, лицензия программы в этом не участвует |
| 50 | /// и не проверяется, спрашивать её не с кого, кроме самого человека. |
| 51 | /// |
| 52 | /// Существование ровно одного текста, а не текста на каждую программу — |
| 53 | /// осознанное решение: он говорит о том, что делает (и чего не делает) |
| 54 | /// сам лаунчер, а не о конкретной программе, и это верно для любой из них. |
| 55 | pub const APPLICATION_DISCLAIMER: &str = "Лаунчер запускает эту программу через Wine — так же, как игру. Он не проверяет и не может проверить, куплена ли у неё лицензия: это касается только тебя и разработчика программы. Если программа платная — используй её на тех условиях, на которых её продают; если это невозможно там, где ты находишься, — решение и ответственность за него твои, не лаунчера. Поддержки конкретных программ (кроме отдельно перечисленных в базе знаний) нет: Wine — это совместимость, а не гарантия, что любая программа заработает так же, как под настоящей Windows."; |
| 56 | |
| 57 | /// Одна игра. |
| 58 | #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] |
| 59 | pub struct Game { |
| 60 | /// Исполняемый файл. Абсолютный путь либо путь внутри префикса. |
| 61 | pub exe: PathBuf, |
| 62 | /// Префикс, в котором игра живёт. |
| 63 | #[serde(default = "default_prefix")] |
| 64 | pub prefix: String, |
| 65 | /// Откуда игра появилась в библиотеке: вручную, из StartWine, из магазина. |
| 66 | #[serde(default)] |
| 67 | pub source: Source, |
| 68 | /// Идентификатор в Steam, если игра оттуда. |
| 69 | /// |
| 70 | /// Хранится, чтобы находить обложки и запускать игру через Proton самого |
| 71 | /// Steam. Без него пришлось бы угадывать игру по названию — а названия |
| 72 | /// совпадают чаще, чем кажется. |
| 73 | #[serde(default, skip_serializing_if = "Option::is_none")] |
| 74 | pub steam_appid: Option<u32>, |
| 75 | /// Путь к обложке. Если пусто — плитка рисуется названием на градиенте. |
| 76 | #[serde(default, skip_serializing_if = "Option::is_none")] |
| 77 | pub cover: Option<PathBuf>, |
| 78 | /// Путь к широкому баннеру для шапки страницы игры — отдельно от |
| 79 | /// [`Game::cover`], потому что это разные по форме картинки (баннер |
| 80 | /// широкий, обложка вертикальная), и обрезать одну до другой значит |
| 81 | /// потерять то, что на ней изображено. У Steam баннер всегда находится |
| 82 | /// сам ([`crate::steam`] — не через это поле); здесь он нужен для |
| 83 | /// источников, которые вертикальную обложку и широкий баннер отдают |
| 84 | /// отдельными картинками (например, у GOG `backgroundImage` — это как |
| 85 | /// раз баннер, не обложка, см. `chl_gog::library::Game`). |
| 86 | #[serde(default, skip_serializing_if = "Option::is_none")] |
| 87 | pub hero: Option<PathBuf>, |
| 88 | /// Не показывать в сетке библиотеки. |
| 89 | /// |
| 90 | /// Так живёт Windows-Steam: запускать его надо, и вся механика запуска |
| 91 | /// ему нужна ровно та же, что игре, — но он не игра, а магазин, и его |
| 92 | /// место в меню слева, а не среди плиток. Из библиотеки он при этом не |
| 93 | /// исчезает: `chl run Steam-Windows` работает. |
| 94 | #[serde(default, skip_serializing_if = "std::ops::Not::not")] |
| 95 | pub hidden: bool, |
| 96 | /// Игра или программа — см. [`GameKind`]. Записи, заведённые до этого |
| 97 | /// поля, читаются как `Game`: это и есть подавляющее большинство того, |
| 98 | /// что здесь уже лежит. |
| 99 | #[serde(default, skip_serializing_if = "is_default_kind")] |
| 100 | pub kind: GameKind, |
| 101 | } |
| 102 | |
| 103 | impl Library { |
| 104 | /// Игры, которые показываются в сетке. |
| 105 | pub fn visible(&self) -> impl Iterator<Item = (&String, &Game)> { |
| 106 | self.games.iter().filter(|(_, g)| !g.hidden) |
| 107 | } |
| 108 | |
| 109 | /// Переписывает пути игр, лежащих внутри старого каталога данных. |
| 110 | /// |
| 111 | /// Нужно при переезде в свой каталог: у игр, которые живут ВНУТРИ |
| 112 | /// префикса (встроенный «Сапёр», Windows-Steam), путь записан абсолютным |
| 113 | /// и указывает в каталог StartWine. После переноса файл лежит в другом |
| 114 | /// месте, и без этой правки игра просто перестанет находиться. |
| 115 | /// |
| 116 | /// Игры, лежащие снаружи — вроде RF Online в ~/Games, — не трогаются: |
| 117 | /// они никуда не переезжали. |
| 118 | /// |
| 119 | /// Возвращает, сколько путей переписано. |
| 120 | pub fn rebase(&mut self, from: &Path, to: &Path) -> usize { |
| 121 | let mut changed = 0; |
| 122 | for game in self.games.values_mut() { |
| 123 | let Ok(rest) = game.exe.strip_prefix(from) else { |
| 124 | continue; |
| 125 | }; |
| 126 | game.exe = to.join(rest); |
| 127 | changed += 1; |
| 128 | } |
| 129 | changed |
| 130 | } |
| 131 | |
| 132 | /// Прячет или показывает игру. Возвращает, изменилось ли что-нибудь. |
| 133 | pub fn set_hidden(&mut self, name: &str, hidden: bool) -> bool { |
| 134 | match self.games.get_mut(name) { |
| 135 | Some(g) if g.hidden != hidden => { |
| 136 | g.hidden = hidden; |
| 137 | true |
| 138 | } |
| 139 | _ => false, |
| 140 | } |
| 141 | } |
| 142 | } |
| 143 | |
| 144 | fn default_prefix() -> String { |
| 145 | "pfx_default".to_string() |
| 146 | } |
| 147 | |
| 148 | /// Чтобы `kind: Game` (подавляющее большинство записей) не писалось в |
| 149 | /// файл лишней строкой — та же экономия, что уже есть у `hidden`. |
| 150 | fn is_default_kind(kind: &GameKind) -> bool { |
| 151 | *kind == GameKind::default() |
| 152 | } |
| 153 | |
| 154 | #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)] |
| 155 | #[serde(rename_all = "lowercase")] |
| 156 | pub enum Source { |
| 157 | /// Добавлена пользователем. |
| 158 | #[default] |
| 159 | Manual, |
| 160 | /// Перенесена из StartWine. |
| 161 | Startwine, |
| 162 | /// Из магазина. |
| 163 | Store, |
| 164 | } |
| 165 | |
| 166 | impl Game { |
| 167 | /// Игра из Steam запускается самим Steam. |
| 168 | /// |
| 169 | /// Это не уступка, а правильный путь: Steam сам подберёт Proton, включит |
| 170 | /// облачные сохранения, оверлей и Steam Input. Подменять его своим Wine |
| 171 | /// значит терять всё это и получать проблемы с античитами. |
| 172 | pub fn is_steam(&self) -> bool { |
| 173 | self.steam_appid.is_some() |
| 174 | } |
| 175 | |
| 176 | /// Файлы игры на месте. |
| 177 | /// |
| 178 | /// У игр Steam в `exe` лежит каталог установки, а не исполняемый файл: |
| 179 | /// какой именно exe запускать, знает Steam. Поэтому проверка разная — |
| 180 | /// иначе все игры Steam помечались бы как потерянные. |
| 181 | /// |
| 182 | /// Для обычных игр проверка не различает регистр. Причина не |
| 183 | /// теоретическая: Steam ставит `Steam.exe` с заглавной, а после первого |
| 184 | /// самообновления переименовывает его в `steam.exe`. Записанный в |
| 185 | /// библиотеку путь после этого перестал бы существовать, и работающая |
| 186 | /// игра пометилась бы как потерянная. |
| 187 | pub fn is_present(&self) -> bool { |
| 188 | if !self.exe.is_absolute() { |
| 189 | // Путь внутри префикса — проверить без префикса нельзя. |
| 190 | return true; |
| 191 | } |
| 192 | if self.is_steam() { |
| 193 | return self.exe.is_dir(); |
| 194 | } |
| 195 | self.exe.is_file() || resolve_ci(&self.exe).is_some_and(|p| p.is_file()) |
| 196 | } |
| 197 | |
| 198 | /// Настоящий путь к исполняемому файлу с учётом смены регистра. |
| 199 | pub fn actual_exe(&self) -> Option<PathBuf> { |
| 200 | if self.exe.is_file() { |
| 201 | return Some(self.exe.clone()); |
| 202 | } |
| 203 | resolve_ci(&self.exe) |
| 204 | } |
| 205 | } |
| 206 | |
| 207 | impl Source { |
| 208 | pub fn as_str(self) -> &'static str { |
| 209 | match self { |
| 210 | Source::Manual => "вручную", |
| 211 | Source::Startwine => "из StartWine", |
| 212 | Source::Store => "из магазина", |
| 213 | } |
| 214 | } |
| 215 | } |
| 216 | |
| 217 | /// Итог подтягивания игры из Steam. |
| 218 | #[derive(Debug, Clone, PartialEq, Eq)] |
| 219 | pub enum SteamImport { |
| 220 | /// Игры не было — добавлена. |
| 221 | Added, |
| 222 | /// Игра была, но без обложки, а теперь Steam её скачал. |
| 223 | CoverUpdated, |
| 224 | /// Та же игра (тот же appid) лежала под другим названием — запись |
| 225 | /// переименована, настройки остались за ней. |
| 226 | /// |
| 227 | /// Зовущий обязан перенести файлы, названные по игре: конфиг, состояние |
| 228 | /// запусков, обложки автопоиска. В `chl-core` их пути неизвестны — |
| 229 | /// перенос делает тот, у кого есть `Dirs`. |
| 230 | Renamed { from: String }, |
| 231 | /// Всё уже как надо. |
| 232 | Unchanged, |
| 233 | } |
| 234 | |
| 235 | impl SteamImport { |
| 236 | /// Нужно ли сохранять библиотеку. |
| 237 | /// |
| 238 | /// Отдельный метод, потому что забыть про CoverUpdated легко: раньше |
| 239 | /// обложка обновлялась в памяти, а на диск не попадала, потому что |
| 240 | /// «добавленных ноль». |
| 241 | pub fn changed(&self) -> bool { |
| 242 | *self != SteamImport::Unchanged |
| 243 | } |
| 244 | |
| 245 | pub fn added(&self) -> bool { |
| 246 | *self == SteamImport::Added |
| 247 | } |
| 248 | |
| 249 | /// Под каким названием игра лежала раньше, если импорт её переименовал. |
| 250 | /// |
| 251 | /// Зовущему это нужно, чтобы перенести файлы, названные по игре: |
| 252 | /// настройки, состояние запусков, обложки автопоиска. |
| 253 | pub fn renamed_from(&self) -> Option<&str> { |
| 254 | match self { |
| 255 | SteamImport::Renamed { from } => Some(from), |
| 256 | _ => None, |
| 257 | } |
| 258 | } |
| 259 | } |
| 260 | |
| 261 | /// Итог добавления игры. |
| 262 | #[derive(Debug)] |
| 263 | pub struct Added { |
| 264 | /// Имя, под которым игра записана. |
| 265 | pub name: String, |
| 266 | /// Ровно тот же файл уже был в библиотеке под этим именем. |
| 267 | pub same_file: bool, |
| 268 | /// Под этим именем была записана другая игра — вот её файл. |
| 269 | /// |
| 270 | /// Молча подменить одну игру другой нельзя: человек рассчитывал |
| 271 | /// добавить, а не заменить. |
| 272 | pub replaced: Option<PathBuf>, |
| 273 | } |
| 274 | |
| 275 | /// Библиотека целиком. |
| 276 | #[derive(Debug, Clone, Default, Serialize, Deserialize)] |
| 277 | pub struct Library { |
| 278 | #[serde(default)] |
| 279 | pub games: BTreeMap<String, Game>, |
| 280 | } |
| 281 | |
| 282 | impl Library { |
| 283 | /// Игры, которые имеет смысл заводить ярлыками в Steam. |
| 284 | /// |
| 285 | /// Игры самого Steam исключены намеренно: они там уже есть. Ярлык на такую |
| 286 | /// игру создал бы в библиотеке Steam второй значок, ведущий не к Proton, а |
| 287 | /// к нашему Wine, — то есть худший из двух способов её запустить, и ещё |
| 288 | /// поди пойми, какой из двух значков какой. |
| 289 | pub fn exportable(&self) -> Vec<(&String, &Game)> { |
| 290 | // Спрятанные тоже мимо: это не игры, а магазины вроде Windows-Steam, |
| 291 | // и ярлык на них в Game Mode не нужен. |
| 292 | self.games |
| 293 | .iter() |
| 294 | .filter(|(_, g)| !g.is_steam() && !g.hidden) |
| 295 | .collect() |
| 296 | } |
| 297 | |
| 298 | /// Читает библиотеку. Отсутствие файла — не ошибка, а пустая библиотека. |
| 299 | pub fn load(path: &Path) -> Result<Self> { |
| 300 | match std::fs::read_to_string(path) { |
| 301 | Ok(text) => toml::from_str(&text) |
| 302 | .with_context(|| format!("не разбирается библиотека {}", path.display())), |
| 303 | Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Self::default()), |
| 304 | Err(e) => Err(e).with_context(|| format!("не читается {}", path.display())), |
| 305 | } |
| 306 | } |
| 307 | |
| 308 | /// Пишет библиотеку атомарно. |
| 309 | /// |
| 310 | /// Через временный файл и `rename`: обрыв записи не должен превращать |
| 311 | /// библиотеку в обрезанный файл, который потом не разберётся. |
| 312 | pub fn save(&self, path: &Path) -> Result<()> { |
| 313 | let mut document: toml::Value = match std::fs::read_to_string(path) { |
| 314 | Ok(text) => toml::from_str(&text).context("не разбирается прежняя библиотека")?, |
| 315 | Err(e) if e.kind() == std::io::ErrorKind::NotFound => toml::Value::Table(Default::default()), |
| 316 | Err(e) => return Err(e.into()), |
| 317 | }; |
| 318 | let original = document.get("games").and_then(toml::Value::as_table).cloned().unwrap_or_default(); |
| 319 | let mut games = toml::map::Map::new(); |
| 320 | for (name, game) in &self.games { |
| 321 | let mut fields = original.get(name).and_then(toml::Value::as_table).cloned().unwrap_or_default(); |
| 322 | for key in ["exe", "prefix", "source", "steam_appid", "cover", "hero", "hidden", "kind"] { |
| 323 | fields.remove(key); |
| 324 | } |
| 325 | fields.extend(toml::Value::try_from(game)?.as_table().context("не сериализуется игра")?.clone()); |
| 326 | games.insert(name.clone(), toml::Value::Table(fields)); |
| 327 | } |
| 328 | document.as_table_mut().context("библиотека должна быть таблицей")?.insert("games".into(), toml::Value::Table(games)); |
| 329 | let text = toml::to_string_pretty(&document).context("библиотека не сериализуется")?; |
| 330 | crate::paths::write_atomically(path, &text) |
| 331 | } |
| 332 | |
| 333 | /// Добавляет игру. Возвращает имя и то, была ли она уже в библиотеке. |
| 334 | /// |
| 335 | /// Отличать «добавлена» от «уже была» нужно, чтобы не отвечать |
| 336 | /// «добавлено» на повторное добавление того же файла: это выглядит как |
| 337 | /// успех, хотя ничего не произошло. |
| 338 | pub fn add(&mut self, exe: &Path, name: Option<&str>, prefix: Option<&str>, source: Source) -> Result<Added> { |
| 339 | // Имя без спроса берём с каталога игры, а не с файла: «Red Dead |
| 340 | // Redemption 2/RDR2.exe» — это «Red Dead Redemption 2», а не |
| 341 | // «RDR2», и уж точно не «launcher» от «launcher.exe». Имя из файла |
| 342 | // остаётся запасным вариантом — для случая, когда каталог ничего |
| 343 | // не говорит («Загрузки», `bin`). Это не косметика: по имени |
| 344 | // записи ищется обложка, и «launcher» находит обложку чего угодно. |
| 345 | let name = match name { |
| 346 | Some(n) => n.to_string(), |
| 347 | None => name_for_exe_dir(exe) |
| 348 | .map(|dir| { |
| 349 | let cleaned = crate::scan::suggested_name(&dir); |
| 350 | if cleaned.is_empty() { dir } else { cleaned } |
| 351 | }) |
| 352 | .or_else(|| name_for_exe(exe)) |
| 353 | .context("из имени файла не выводится имя игры — задай его явно")?, |
| 354 | }; |
| 355 | if name.is_empty() { |
| 356 | bail!("пустое имя игры"); |
| 357 | } |
| 358 | let previous = self.games.get(&name); |
| 359 | let existed = previous.map(|g| g.exe.clone()); |
| 360 | // Обложку с прошлого раза сохраняем: без этого повторный `add` (тот |
| 361 | // же `import`, переустановка через кнопку «Установить») тихо стирал |
| 362 | // бы уже выбранную или уже скачанную картинку до буквы на градиенте |
| 363 | // — тот же баг, который `add_steam` ниже уже не допускает. |
| 364 | let cover = previous.and_then(|g| g.cover.clone()).filter(|c| c.is_file()); |
| 365 | let hero = previous.and_then(|g| g.hero.clone()).filter(|h| h.is_file()); |
| 366 | self.games.insert( |
| 367 | name.clone(), |
| 368 | Game { |
| 369 | exe: exe.to_path_buf(), |
| 370 | prefix: prefix.unwrap_or("pfx_default").to_string(), |
| 371 | source, |
| 372 | steam_appid: None, |
| 373 | cover, |
| 374 | hero, |
| 375 | hidden: false, |
| 376 | kind: GameKind::default(), |
| 377 | }, |
| 378 | ); |
| 379 | Ok(Added { |
| 380 | same_file: existed.as_deref() == Some(exe), |
| 381 | replaced: existed.filter(|old| old != exe), |
| 382 | name, |
| 383 | }) |
| 384 | } |
| 385 | |
| 386 | /// То же самое, что [`Self::add`], плюс отметка «игра или программа». |
| 387 | /// |
| 388 | /// Отдельным методом, а не параметром у `add`: тот заведён отовсюду — |
| 389 | /// Steam, GOG, Epic, сканирование каталога, — и всюду, кроме ручного |
| 390 | /// добавления в интерфейсе, ответ известен заранее и всегда один и тот |
| 391 | /// же (`GameKind::Game`). Менять сигнатуру ради одного вызывающего |
| 392 | /// значило бы дописывать `GameKind::Game` во всех остальных. |
| 393 | pub fn add_with_kind( |
| 394 | &mut self, |
| 395 | exe: &Path, |
| 396 | name: Option<&str>, |
| 397 | prefix: Option<&str>, |
| 398 | source: Source, |
| 399 | kind: GameKind, |
| 400 | ) -> Result<Added> { |
| 401 | let added = self.add(exe, name, prefix, source)?; |
| 402 | if let Some(game) = self.games.get_mut(&added.name) { |
| 403 | game.kind = kind; |
| 404 | } |
| 405 | Ok(added) |
| 406 | } |
| 407 | |
| 408 | pub fn get(&self, name: &str) -> Option<&Game> { |
| 409 | self.games.get(name) |
| 410 | } |
| 411 | |
| 412 | /// Ищет игру по её исполняемому файлу — обратный поиск к [`Self::get`]. |
| 413 | /// |
| 414 | /// Нужен «Открыть с помощью» из файлового менеджера: там известен только |
| 415 | /// путь к `.exe`, а запускать его надо под тем именем и с теми |
| 416 | /// настройками, под которыми он уже лежит в библиотеке, — иначе каждый |
| 417 | /// такой клик заводил бы дубликат. Сначала сравнение как есть; если не |
| 418 | /// сошлось — через `canonicalize`, чтобы `../`, симлинки и разный |
| 419 | /// регистр пути к одному и тому же файлу не считались разными играми. |
| 420 | pub fn find_by_exe(&self, exe: &Path) -> Option<&str> { |
| 421 | if let Some((name, _)) = self.games.iter().find(|(_, g)| g.exe == exe) { |
| 422 | return Some(name.as_str()); |
| 423 | } |
| 424 | let real = exe.canonicalize().ok()?; |
| 425 | self.games |
| 426 | .iter() |
| 427 | .find(|(_, g)| g.exe.canonicalize().ok().as_deref() == Some(real.as_path())) |
| 428 | .map(|(name, _)| name.as_str()) |
| 429 | } |
| 430 | |
| 431 | pub fn remove(&mut self, name: &str) -> Option<Game> { |
| 432 | self.games.remove(name) |
| 433 | } |
| 434 | |
| 435 | /// Переименовывает игру в библиотеке — меняет только то, как она |
| 436 | /// называется в лончере (ключ в библиотеке), а не сам исполняемый файл |
| 437 | /// на диске: тот трогать незачем и небезопасно (некоторые игры проверяют |
| 438 | /// собственное имя файла при запуске). |
| 439 | pub fn rename(&mut self, old: &str, new: &str) -> Result<()> { |
| 440 | let new = new.trim(); |
| 441 | if new.is_empty() { |
| 442 | bail!("пустое имя игры"); |
| 443 | } |
| 444 | if new == old { |
| 445 | return Ok(()); |
| 446 | } |
| 447 | if self.games.contains_key(new) { |
| 448 | bail!("игра с именем {new:?} уже есть в библиотеке"); |
| 449 | } |
| 450 | let game = self |
| 451 | .games |
| 452 | .remove(old) |
| 453 | .with_context(|| format!("в библиотеке нет игры {old:?}"))?; |
| 454 | self.games.insert(new.to_string(), game); |
| 455 | Ok(()) |
| 456 | } |
| 457 | |
| 458 | /// Добавляет игру из Steam. |
| 459 | /// |
| 460 | /// Отдельный метод, а не `add` с параметрами: у игры Steam есть то, чего |
| 461 | /// нет у добавленной вручную — идентификатор приложения и готовая |
| 462 | /// обложка. Смешивать их в одном списке аргументов значило бы делать |
| 463 | /// подпись, где половина параметров всегда `None`. |
| 464 | pub fn add_steam( |
| 465 | &mut self, |
| 466 | name: &str, |
| 467 | appid: u32, |
| 468 | exe: &Path, |
| 469 | cover: Option<PathBuf>, |
| 470 | ) -> SteamImport { |
| 471 | // Уже добавленную игру не трогаем: у неё могли поменять префикс или |
| 472 | // исполняемый файл, и перезапись стёрла бы ручную настройку. |
| 473 | // |
| 474 | // Обложка — исключение. Steam скачивает картинки библиотеки не сразу: |
| 475 | // игра, добавленная сразу после установки, попадала к нам без |
| 476 | // обложки и оставалась без неё навсегда, хотя Steam картинку давно |
| 477 | // скачал. Обложку никто не настраивает руками, терять тут нечего. |
| 478 | // Сначала по appid, и только потом по названию. Игра узнаётся по |
| 479 | // идентификатору: Steam переименовывает игры (издание сменило |
| 480 | // название, вышло «Definitive Edition»), да и сам человек мог |
| 481 | // переименовать её у нас. Поиск по названию в этом случае добавлял |
| 482 | // вторую запись, а настройки, наигранное и обложка оставались за |
| 483 | // осиротевшей первой — и найти их было уже нечем. |
| 484 | if let Some(found) = self |
| 485 | .games |
| 486 | .iter() |
| 487 | .find(|(_, g)| g.steam_appid == Some(appid)) |
| 488 | .map(|(n, _)| n.clone()) |
| 489 | && found != name |
| 490 | { |
| 491 | // A renamed Steam title may already belong to a different card. |
| 492 | // Keep both cards and their configuration under their current names. |
| 493 | if self.games.contains_key(name) { |
| 494 | return SteamImport::Unchanged; |
| 495 | } |
| 496 | let mut game = self.games.remove(&found).expect("только что нашли"); |
| 497 | if cover.is_some() && game.cover.as_ref().is_none_or(|c| !c.is_file()) { |
| 498 | game.cover = cover; |
| 499 | } |
| 500 | self.games.insert(name.to_string(), game); |
| 501 | return SteamImport::Renamed { from: found }; |
| 502 | } |
| 503 | |
| 504 | if let Some(existing) = self.games.get_mut(name) { |
| 505 | match existing.steam_appid { |
| 506 | // Название занято другой игрой Steam. Одинаковые названия |
| 507 | // встречаются чаще, чем кажется, и раньше вторая игра молча |
| 508 | // не добавлялась вовсе — импорт считал её уже добавленной. |
| 509 | // Уточняем название идентификатором; переименовать потом |
| 510 | // можно как любую другую. |
| 511 | Some(other) if other != appid => { |
| 512 | let unique = format!("{name} ({appid})"); |
| 513 | if let std::collections::btree_map::Entry::Vacant(slot) = |
| 514 | self.games.entry(unique) |
| 515 | { |
| 516 | slot.insert( |
| 517 | Game { |
| 518 | exe: exe.to_path_buf(), |
| 519 | prefix: default_prefix(), |
| 520 | source: Source::Store, |
| 521 | steam_appid: Some(appid), |
| 522 | cover, |
| 523 | hero: None, |
| 524 | hidden: false, |
| 525 | kind: GameKind::default(), |
| 526 | }, |
| 527 | ); |
| 528 | return SteamImport::Added; |
| 529 | } |
| 530 | return SteamImport::Unchanged; |
| 531 | } |
| 532 | // Игра была добавлена вручную, а теперь нашлась в Steam: |
| 533 | // запоминаем идентификатор, чтобы дальше она узнавалась по |
| 534 | // нему, а не по названию, — и настройки при следующем |
| 535 | // переименовании остались за ней. |
| 536 | None => { |
| 537 | existing.steam_appid = Some(appid); |
| 538 | if cover.is_some() && existing.cover.as_ref().is_none_or(|c| !c.is_file()) { |
| 539 | existing.cover = cover; |
| 540 | } |
| 541 | return SteamImport::CoverUpdated; |
| 542 | } |
| 543 | _ => {} |
| 544 | } |
| 545 | if cover.is_some() && existing.cover.as_ref().is_none_or(|c| !c.is_file()) { |
| 546 | existing.cover = cover; |
| 547 | return SteamImport::CoverUpdated; |
| 548 | } |
| 549 | return SteamImport::Unchanged; |
| 550 | } |
| 551 | self.games.insert( |
| 552 | name.to_string(), |
| 553 | Game { |
| 554 | exe: exe.to_path_buf(), |
| 555 | prefix: default_prefix(), |
| 556 | source: Source::Store, |
| 557 | steam_appid: Some(appid), |
| 558 | cover, |
| 559 | hero: None, |
| 560 | hidden: false, |
| 561 | kind: GameKind::default(), |
| 562 | }, |
| 563 | ); |
| 564 | SteamImport::Added |
| 565 | } |
| 566 | |
| 567 | /// Переносит библиотеку из индекса StartWine. |
| 568 | /// |
| 569 | /// Формат (сверено по `sw_data.py`: `hash_()` и `class ExeData`): |
| 570 | /// ключ верхнего уровня — это `sha256(path).hexdigest()[:16]`, то есть |
| 571 | /// непрозрачный идентификатор, а не имя игры. Имя и путь лежат в полях |
| 572 | /// значения — `name` и `path`. |
| 573 | /// |
| 574 | /// Поле `platform` отличает игры из магазинов (`sw_func.py`): |
| 575 | /// - `"steam"` (~3052) — у такой записи в `path` не файл, а |
| 576 | /// `steam://rungameid/<id>`: своя, более полная библиотека Steam уже |
| 577 | /// есть отдельно (`chl_steam`), а подставить URI вместо пути в `exe` |
| 578 | /// значит сломать [`Game::is_present`] (не абсолютный путь — вернёт |
| 579 | /// «на месте», хотя файла нет) и [`Game::actual_exe`] (файла нет, |
| 580 | /// вернёт `None`). Такие записи пропускаются. |
| 581 | /// - `"epic"` (~4649) — путь настоящий, но собственный перенос Epic |
| 582 | /// (`chl_epic::installed`, из `installed.json` legendary/Heroic) точнее: |
| 583 | /// у него есть `app_name` для дедупликации одной и той же игры, |
| 584 | /// увиденной из двух чужих лаунчеров. Такие записи тоже пропускаются, |
| 585 | /// чтобы не завести дубликат хуже качеством. |
| 586 | /// - `"gog"` (~4589) — путь тоже настоящий, но своего переноса GOG нет |
| 587 | /// вообще, так что это единственный источник — переносятся как обычно. |
| 588 | /// - пусто/отсутствует — обычная вручную добавленная в StartWine игра, |
| 589 | /// переносится как есть. |
| 590 | /// |
| 591 | /// Запись без `name` не пропускается: имя выводится из пути (см. |
| 592 | /// [`name_for_exe`]) тем же правилом, что и при ручном добавлении. |
| 593 | /// Запись без `path` пропустить нечем — такая пропускается. |
| 594 | /// |
| 595 | /// Существование файла на диске при переносе не проверяется — так же, |
| 596 | /// как этого не делает [`Library::add`]; устаревший путь обнаружится |
| 597 | /// позже через [`Game::is_present`], как у любой другой игры. |
| 598 | /// |
| 599 | /// Возвращает число добавленных. Уже известные игры не перезаписываются: |
| 600 | /// перенос не должен затирать то, что пользователь успел настроить. |
| 601 | pub fn import_startwine(&mut self, exe_data_json: &Path) -> Result<usize> { |
| 602 | #[derive(Deserialize)] |
| 603 | struct Entry { |
| 604 | #[serde(default)] |
| 605 | name: Option<String>, |
| 606 | #[serde(default)] |
| 607 | path: Option<String>, |
| 608 | #[serde(default)] |
| 609 | platform: Option<String>, |
| 610 | } |
| 611 | |
| 612 | let text = match std::fs::read_to_string(exe_data_json) { |
| 613 | Ok(t) => t, |
| 614 | Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(0), |
| 615 | Err(e) => return Err(e).context("не читается индекс StartWine"), |
| 616 | }; |
| 617 | let raw: BTreeMap<String, serde_json::Value> = |
| 618 | serde_json::from_str(&text).context("exe_data.json не разбирается")?; |
| 619 | |
| 620 | let mut added = 0; |
| 621 | for value in raw.into_values() { |
| 622 | // Запись повреждена или не в ожидаемой форме — пропустить её, |
| 623 | // а не заваливать весь перенос из-за одной плохой записи. |
| 624 | let Ok(entry) = serde_json::from_value::<Entry>(value) else { |
| 625 | continue; |
| 626 | }; |
| 627 | if matches!(entry.platform.as_deref(), Some("steam") | Some("epic")) { |
| 628 | continue; |
| 629 | } |
| 630 | let Some(exe) = entry.path.filter(|p| !p.is_empty()) else { |
| 631 | continue; |
| 632 | }; |
| 633 | let exe = PathBuf::from(exe); |
| 634 | // Защита на случай, если platform не проставлен: настоящий |
| 635 | // файловый путь схемой вида "scheme://" не бывает. |
| 636 | if exe.to_string_lossy().contains("://") { |
| 637 | continue; |
| 638 | } |
| 639 | let Some(name) = entry |
| 640 | .name |
| 641 | .filter(|n| !n.is_empty()) |
| 642 | .or_else(|| name_for_exe(&exe)) |
| 643 | else { |
| 644 | continue; |
| 645 | }; |
| 646 | if self.games.contains_key(&name) { |
| 647 | continue; |
| 648 | } |
| 649 | self.games.insert( |
| 650 | name, |
| 651 | Game { |
| 652 | exe, |
| 653 | prefix: default_prefix(), |
| 654 | source: Source::Startwine, |
| 655 | steam_appid: None, |
| 656 | cover: None, |
| 657 | hero: None, |
| 658 | hidden: false, |
| 659 | kind: GameKind::default(), |
| 660 | }, |
| 661 | ); |
| 662 | added += 1; |
| 663 | } |
| 664 | Ok(added) |
| 665 | } |
| 666 | } |
| 667 | |
| 668 | /// Ищет файл, не различая регистр последнего сегмента пути. |
| 669 | /// |
| 670 | /// Полного обхода нет намеренно: меняется обычно имя файла, а не каталогов, |
| 671 | /// и перебирать все родительские каталоги значило бы читать полпрефикса ради |
| 672 | /// одной проверки. |
| 673 | fn resolve_ci(path: &Path) -> Option<PathBuf> { |
| 674 | let parent = path.parent()?; |
| 675 | let name = path.file_name()?.to_string_lossy().into_owned(); |
| 676 | std::fs::read_dir(parent) |
| 677 | .ok()? |
| 678 | .flatten() |
| 679 | .find(|e| e.file_name().to_string_lossy().eq_ignore_ascii_case(&name)) |
| 680 | .map(|e| e.path()) |
| 681 | } |
| 682 | |
| 683 | /// Выводит имя игры из пути к исполняемому файлу. |
| 684 | /// |
| 685 | /// Правило повторяет StartWine (`sw_runlib:807`): базовое имя без |
| 686 | /// расширения, пробелы заменены подчёркиваниями. Совпадение важно: именно |
| 687 | /// это имя служит именем файла конфига в `data/app_config/`, и разойтись с |
| 688 | /// ним значит потерять уже сделанные настройки при переносе. |
| 689 | pub fn name_for_exe(exe: &Path) -> Option<String> { |
| 690 | let base = exe.file_name()?.to_string_lossy(); |
| 691 | let stem = base |
| 692 | .rsplit_once('.') |
| 693 | .filter(|(_, ext)| { |
| 694 | matches!( |
| 695 | ext.to_ascii_lowercase().as_str(), |
| 696 | "exe" | "msi" | "bat" | "lnk" | "sh" |
| 697 | ) |
| 698 | }) |
| 699 | .map(|(s, _)| s) |
| 700 | .unwrap_or(&base); |
| 701 | let name = stem.replace(' ', "_"); |
| 702 | (!name.is_empty()).then_some(name) |
| 703 | } |
| 704 | |
| 705 | /// Каталоги, чьё имя ничего не говорит о самой игре, — через них поиск |
| 706 | /// названия проходит вверх, не останавливаясь: `bin`, `x64`, `Binaries` |
| 707 | /// и подобное встречается почти в каждой второй установке. |
| 708 | const GENERIC_DIRS: &[&str] = &[ |
| 709 | "bin", "bin32", "bin64", "binaries", "win32", "win64", "win64_shipping", "x64", "x86", |
| 710 | "x86_64", "game", "retail", "release", "shipping", "engine", "system", "data", "app", |
| 711 | "launcher", "exe", "executables", "build", |
| 712 | ]; |
| 713 | |
| 714 | /// Каталоги-«полки»: до них дошли — значит, ничего похожего на название |
| 715 | /// игры на пути нет, и лучше честно вернуть `None`, чем предложить |
| 716 | /// «Загрузки» или имя пользователя из `/home/<имя>`. |
| 717 | const CONTAINER_DIRS: &[&str] = &[ |
| 718 | "downloads", "загрузки", "desktop", "рабочий стол", "documents", "документы", "games", |
| 719 | "игры", "drive_c", "program files", "program files (x86)", "programdata", "users", "home", |
| 720 | "mnt", "media", "tmp", "run", "opt", "steamapps", "common", "gog games", "epic games", |
| 721 | ]; |
| 722 | |
| 723 | /// Выводит имя игры из каталога, в котором лежит исполняемый файл. |
| 724 | /// |
| 725 | /// Имя самого файла обычно бесполезно как название: `launcher.exe`, |
| 726 | /// `game.exe`, `RDR2.exe` — а вот каталог установки почти всегда называется |
| 727 | /// по игре («Red Dead Redemption 2/RDR2.exe»). Служебные подкаталоги |
| 728 | /// ([`GENERIC_DIRS`]) пропускаются, чтобы «Cyberpunk 2077/bin/x64/…» дало |
| 729 | /// «Cyberpunk 2077», а не «x64». Дойдя до каталога-полки |
| 730 | /// ([`CONTAINER_DIRS`]) или до корня, отвечает `None` — тогда вызывающему |
| 731 | /// остаётся [`name_for_exe`]. |
| 732 | /// |
| 733 | /// Пробелы здесь не заменяются на `_`, в отличие от [`name_for_exe`]: |
| 734 | /// то правило существует ради совместимости конфигов со StartWine, у |
| 735 | /// которого имя выводилось из файла, а не из каталога, — тут совпадать |
| 736 | /// не с чем, а название с подчёркиваниями на плитке выглядит как ошибка. |
| 737 | /// |
| 738 | /// Первый попавшийся служебный каталог — не всегда ответ: между |
| 739 | /// [`GENERIC_DIRS`] и настоящим названием бывает односложный каталог |
| 740 | /// движка или проекта, которого нет и не может быть в общем списке |
| 741 | /// (`Gameface` у GTA Trilogy, `Phoenix` у Hogwarts Legacy). Поэтому |
| 742 | /// поиск не останавливается на нём, а продолжается вверх до первого |
| 743 | /// каталога, похожего на **название** — из двух и более слов |
| 744 | /// ([`looks_like_title`]). Односложный кандидат при этом не теряется: если |
| 745 | /// выше ничего похожего на название не встретилось, возвращается он — |
| 746 | /// то же, что возвращалось раньше. |
| 747 | pub fn name_for_exe_dir(exe: &Path) -> Option<String> { |
| 748 | let mut dir = exe.parent()?; |
| 749 | // Самый глубокий неслужебный каталог — ответ по умолчанию, если выше |
| 750 | // ничего лучше не найдётся. |
| 751 | let mut fallback: Option<String> = None; |
| 752 | loop { |
| 753 | let Some(raw) = dir.file_name() else { |
| 754 | return fallback; |
| 755 | }; |
| 756 | let name = raw.to_string_lossy(); |
| 757 | let lower = name.trim().to_lowercase(); |
| 758 | if lower.is_empty() || CONTAINER_DIRS.contains(&lower.as_str()) { |
| 759 | return fallback; |
| 760 | } |
| 761 | if !GENERIC_DIRS.contains(&lower.as_str()) { |
| 762 | let candidate = name.trim().to_string(); |
| 763 | if looks_like_title(&candidate) { |
| 764 | return Some(candidate); |
| 765 | } |
| 766 | fallback.get_or_insert(candidate); |
| 767 | } |
| 768 | let Some(up) = dir.parent() else { |
| 769 | return fallback; |
| 770 | }; |
| 771 | dir = up; |
| 772 | } |
| 773 | } |
| 774 | |
| 775 | /// Похоже ли имя каталога на **название игры**, а не на служебное слово. |
| 776 | /// |
| 777 | /// Признак простой и намеренно грубый: два и более слова после разбиения |
| 778 | /// по пробелам, точкам, подчёркиваниям и дефисам. «Red Dead Redemption 2», |
| 779 | /// «Gothic.1.Remake-InsaneRamZes», «GTA III - Definitive Edition» — да; |
| 780 | /// «Gameface», «Phoenix», «Content» — нет. Односложные названия игр |
| 781 | /// («AERMemoriesOfOld») этим признаком отсекаются, поэтому он решает не |
| 782 | /// «годится ли имя», а только «стоит ли посмотреть ещё выше». |
| 783 | pub(crate) fn looks_like_title(name: &str) -> bool { |
| 784 | name.split(['.', '_', '-', ' ']) |
| 785 | .filter(|p| !p.trim().is_empty()) |
| 786 | .count() |
| 787 | >= 2 |
| 788 | } |
| 789 | |
| 790 | #[cfg(test)] |
| 791 | mod tests { |
| 792 | use std::path::{Path, PathBuf}; |
| 793 | |
| 794 | #[test] |
| 795 | fn save_preserves_unknown_fields_and_clears_known_defaults() { |
| 796 | let path = std::env::temp_dir().join(format!("chl-library-preserve-{}.toml", std::process::id())); |
| 797 | std::fs::write(&path, "future_root = 42\n[games.Game]\nexe = '/game'\nsource = 'store'\nhidden = true\nfuture_field = 'keep'\n[games.Removed]\nexe = '/removed'\nsource = 'store'\n").unwrap(); |
| 798 | let mut library = super::Library::load(&path).unwrap(); |
| 799 | library.games.get_mut("Game").unwrap().hidden = false; |
| 800 | library.games.remove("Removed"); |
| 801 | library.save(&path).unwrap(); |
| 802 | let document: toml::Value = toml::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap(); |
| 803 | assert_eq!(document["future_root"].as_integer(), Some(42)); |
| 804 | assert_eq!(document["games"]["Game"]["future_field"].as_str(), Some("keep")); |
| 805 | assert!(!super::Library::load(&path).unwrap().games["Game"].hidden); |
| 806 | assert!(document["games"].get("Removed").is_none()); |
| 807 | std::fs::remove_file(path).unwrap(); |
| 808 | } |
| 809 | |
| 810 | /// Игра Steam, уже лежащая в библиотеке под своим названием. |
| 811 | fn с_игрой(name: &str, appid: u32) -> super::Library { |
| 812 | let mut lib = super::Library::default(); |
| 813 | lib.add_steam(name, appid, Path::new("/steam/game/game.exe"), None); |
| 814 | lib |
| 815 | } |
| 816 | |
| 817 | #[test] |
| 818 | fn переименованная_в_steam_игра_не_двоится() { |
| 819 | // Steam переименовывает игры: вышло переиздание, сменилось название |
| 820 | // издания. Импорт искал запись по названию и добавлял вторую, а |
| 821 | // настройки, наигранное и обложка оставались за первой, найти их |
| 822 | // было уже нечем. |
| 823 | let mut lib = с_игрой("Game", 42); |
| 824 | let outcome = lib.add_steam("Game: Definitive Edition", 42, Path::new("/steam/game/game.exe"), None); |
| 825 | |
| 826 | assert_eq!(outcome.renamed_from(), Some("Game")); |
| 827 | assert_eq!(lib.games.len(), 1, "второй записи быть не должно"); |
| 828 | assert!(lib.games.contains_key("Game: Definitive Edition")); |
| 829 | assert_eq!(lib.games.values().next().unwrap().steam_appid, Some(42)); |
| 830 | } |
| 831 | |
| 832 | #[test] |
| 833 | fn переименование_сохраняет_настроенное_за_игрой() { |
| 834 | let mut lib = с_игрой("Game", 42); |
| 835 | // Человек поменял префикс и обложку — это и есть то, что нельзя |
| 836 | // потерять при переименовании. |
| 837 | let g = lib.games.get_mut("Game").unwrap(); |
| 838 | g.prefix = "pfx_свой".into(); |
| 839 | g.cover = Some(PathBuf::from("/своя/обложка.jpg")); |
| 840 | |
| 841 | lib.add_steam("Другое название", 42, Path::new("/steam/game/game.exe"), None); |
| 842 | |
| 843 | let g = lib.games.get("Другое название").expect("запись переехала"); |
| 844 | assert_eq!(g.prefix, "pfx_свой"); |
| 845 | assert_eq!(g.cover.as_deref(), Some(Path::new("/своя/обложка.jpg"))); |
| 846 | } |
| 847 | |
| 848 | #[test] |
| 849 | fn чужая_игра_с_тем_же_названием_не_переписывается() { |
| 850 | // Одинаковые названия у разных игр встречаются чаще, чем кажется. |
| 851 | // Совпадение по названию при разном appid — это две игры, а не одна. |
| 852 | let mut lib = с_игрой("Game", 42); |
| 853 | let outcome = lib.add_steam("Game", 777, Path::new("/steam/other/other.exe"), None); |
| 854 | assert!(outcome.added(), "другая игра должна добавиться, а не слиться"); |
| 855 | assert_eq!(lib.games.len(), 2); |
| 856 | assert!(lib.games.contains_key("Game (777)"), "название уточняется идентификатором"); |
| 857 | assert_eq!(lib.games["Game"].steam_appid, Some(42), "первая игра не тронута"); |
| 858 | } |
| 859 | |
| 860 | #[test] |
| 861 | fn добавленная_вручную_игра_подхватывает_appid_из_steam() { |
| 862 | // Игра была добавлена руками, потом нашлась в Steam. Идентификатор |
| 863 | // запоминается — дальше она узнаётся по нему, и переименование в |
| 864 | // Steam её больше не раздвоит. |
| 865 | let mut lib = super::Library::default(); |
| 866 | lib.add(Path::new("/games/game.exe"), Some("Game"), None, super::Source::Manual).unwrap(); |
| 867 | assert_eq!(lib.games["Game"].steam_appid, None); |
| 868 | |
| 869 | lib.add_steam("Game", 42, Path::new("/steam/game/game.exe"), None); |
| 870 | assert_eq!(lib.games["Game"].steam_appid, Some(42)); |
| 871 | assert_eq!(lib.games.len(), 1); |
| 872 | |
| 873 | // И теперь переименование в Steam её находит, а не двоит. |
| 874 | lib.add_steam("Game Remastered", 42, Path::new("/steam/game/game.exe"), None); |
| 875 | assert_eq!(lib.games.len(), 1); |
| 876 | assert!(lib.games.contains_key("Game Remastered")); |
| 877 | } |
| 878 | |
| 879 | #[test] |
| 880 | fn add_with_kind_отмечает_программу() { |
| 881 | let mut lib = super::Library::default(); |
| 882 | lib.add_with_kind( |
| 883 | Path::new("/programs/photoshop.exe"), |
| 884 | Some("Photoshop"), |
| 885 | None, |
| 886 | super::Source::Manual, |
| 887 | super::GameKind::Application, |
| 888 | ) |
| 889 | .unwrap(); |
| 890 | assert_eq!(lib.games["Photoshop"].kind, super::GameKind::Application); |
| 891 | |
| 892 | // Обычный `add` (все прочие вызывающие — Steam, GOG, Epic, |
| 893 | // сканирование) по-прежнему заводит игру, а не программу. |
| 894 | lib.add(Path::new("/games/game.exe"), Some("Game"), None, super::Source::Manual).unwrap(); |
| 895 | assert_eq!(lib.games["Game"].kind, super::GameKind::Game); |
| 896 | } |
| 897 | |
| 898 | /// Прогон на отказ: без `skip_serializing_if` эта проверка стала бы |
| 899 | /// ловить лишнюю строку `kind = "Game"` в файле у подавляющего |
| 900 | /// большинства записей библиотеки, где кроме `Game` ничего и не бывает. |
| 901 | #[test] |
| 902 | fn kind_game_не_пишется_в_файл() { |
| 903 | let mut lib = super::Library::default(); |
| 904 | lib.add(Path::new("/games/game.exe"), Some("Game"), None, super::Source::Manual).unwrap(); |
| 905 | let text = toml::to_string_pretty(&lib).unwrap(); |
| 906 | assert!(!text.contains("kind"), "умолчание не должно попадать в файл: {text}"); |
| 907 | } |
| 908 | |
| 909 | /// Файл библиотеки, набранный до появления `kind` (подавляющее |
| 910 | /// большинство существующих установок), обязан читаться как есть, а |
| 911 | /// не отказывать в разборе и не терять запись. |
| 912 | #[test] |
| 913 | fn старый_файл_без_kind_читается_как_игра() { |
| 914 | let toml = r#" |
| 915 | [games.Game] |
| 916 | exe = "/games/game.exe" |
| 917 | "#; |
| 918 | let lib: super::Library = toml::from_str(toml).unwrap(); |
| 919 | assert_eq!(lib.games["Game"].kind, super::GameKind::Game); |
| 920 | } |
| 921 | |
| 922 | #[test] |
| 923 | fn повторный_импорт_без_изменений_ничего_не_трогает() { |
| 924 | let mut lib = с_игрой("Game", 42); |
| 925 | let outcome = lib.add_steam("Game", 42, Path::new("/steam/game/game.exe"), None); |
| 926 | assert_eq!(outcome, super::SteamImport::Unchanged); |
| 927 | assert!(!outcome.changed()); |
| 928 | } |
| 929 | |
| 930 | #[test] |
| 931 | fn переезд_правит_только_игры_внутри_каталога() { |
| 932 | let mut lib = super::Library::default(); |
| 933 | lib.add( |
| 934 | std::path::Path::new("/старый/data/pfx/pfx_default/drive_c/game.exe"), |
| 935 | Some("Внутри"), |
| 936 | None, |
| 937 | super::Source::Manual, |
| 938 | ) |
| 939 | .unwrap(); |
| 940 | lib.add( |
| 941 | std::path::Path::new("/home/u/Games/RF/rf.exe"), |
| 942 | Some("Снаружи"), |
| 943 | None, |
| 944 | super::Source::Manual, |
| 945 | ) |
| 946 | .unwrap(); |
| 947 | |
| 948 | let n = lib.rebase( |
| 949 | std::path::Path::new("/старый"), |
| 950 | std::path::Path::new("/новый"), |
| 951 | ); |
| 952 | assert_eq!(n, 1, "переписан только тот путь, что был внутри"); |
| 953 | assert_eq!( |
| 954 | lib.get("Внутри").unwrap().exe, |
| 955 | std::path::PathBuf::from("/новый/data/pfx/pfx_default/drive_c/game.exe") |
| 956 | ); |
| 957 | assert_eq!( |
| 958 | lib.get("Снаружи").unwrap().exe, |
| 959 | std::path::PathBuf::from("/home/u/Games/RF/rf.exe"), |
| 960 | "игра снаружи никуда не переезжала" |
| 961 | ); |
| 962 | } |
| 963 | |
| 964 | #[test] |
| 965 | fn переименование_переносит_запись_под_новым_именем() { |
| 966 | let mut lib = super::Library::default(); |
| 967 | lib.add( |
| 968 | std::path::Path::new("/home/u/Games/RF/rf.exe"), |
| 969 | Some("Старое"), |
| 970 | None, |
| 971 | super::Source::Manual, |
| 972 | ) |
| 973 | .unwrap(); |
| 974 | lib.rename("Старое", "Новое").unwrap(); |
| 975 | assert!(lib.get("Старое").is_none()); |
| 976 | assert_eq!(lib.get("Новое").unwrap().exe, std::path::PathBuf::from("/home/u/Games/RF/rf.exe")); |
| 977 | } |
| 978 | |
| 979 | #[test] |
| 980 | fn переименование_в_занятое_имя_это_ошибка() { |
| 981 | let mut lib = super::Library::default(); |
| 982 | lib.add(std::path::Path::new("/a.exe"), Some("A"), None, super::Source::Manual).unwrap(); |
| 983 | lib.add(std::path::Path::new("/b.exe"), Some("B"), None, super::Source::Manual).unwrap(); |
| 984 | assert!(lib.rename("A", "B").is_err()); |
| 985 | // Ничего не пострадало при неудачной попытке. |
| 986 | assert!(lib.get("A").is_some()); |
| 987 | assert!(lib.get("B").is_some()); |
| 988 | } |
| 989 | |
| 990 | #[test] |
| 991 | fn переименование_в_то_же_имя_ничего_не_делает() { |
| 992 | let mut lib = super::Library::default(); |
| 993 | lib.add(std::path::Path::new("/a.exe"), Some("A"), None, super::Source::Manual).unwrap(); |
| 994 | lib.rename("A", "A").unwrap(); |
| 995 | assert!(lib.get("A").is_some()); |
| 996 | } |
| 997 | |
| 998 | #[test] |
| 999 | fn переименование_пустое_имя_это_ошибка() { |
| 1000 | let mut lib = super::Library::default(); |
| 1001 | lib.add(std::path::Path::new("/a.exe"), Some("A"), None, super::Source::Manual).unwrap(); |
| 1002 | assert!(lib.rename("A", "").is_err()); |
| 1003 | assert!(lib.get("A").is_some(), "неудачная попытка не должна удалить старую запись"); |
| 1004 | } |
| 1005 | |
| 1006 | #[test] |
| 1007 | fn повторное_добавление_отличается_от_первого() { |
| 1008 | // «Добавлено» в ответ на повторное добавление того же файла выглядит |
| 1009 | // как успех, хотя ничего не произошло. |
| 1010 | let mut lib = super::Library::default(); |
| 1011 | let exe = std::path::Path::new("/games/game.exe"); |
| 1012 | let first = lib |
| 1013 | .add(exe, Some("Игра"), None, super::Source::Manual) |
| 1014 | .unwrap(); |
| 1015 | assert!(!first.same_file && first.replaced.is_none()); |
| 1016 | |
| 1017 | let again = lib |
| 1018 | .add(exe, Some("Игра"), None, super::Source::Manual) |
| 1019 | .unwrap(); |
| 1020 | assert!(again.same_file, "тот же файл под тем же именем"); |
| 1021 | |
| 1022 | // А вот другой файл под тем же именем — это замена, и молчать о |
| 1023 | // ней нельзя: человек рассчитывал добавить, а не заменить. |
| 1024 | let other = lib |
| 1025 | .add( |
| 1026 | std::path::Path::new("/games/другая.exe"), |
| 1027 | Some("Игра"), |
| 1028 | None, |
| 1029 | super::Source::Manual, |
| 1030 | ) |
| 1031 | .unwrap(); |
| 1032 | assert!(!other.same_file); |
| 1033 | assert_eq!(other.replaced.as_deref(), Some(exe)); |
| 1034 | } |
| 1035 | |
| 1036 | #[test] |
| 1037 | fn повторное_добавление_не_стирает_уже_выбранную_обложку() { |
| 1038 | // Реальный сценарий: игру Epic/GOG поставили, выбрали обложку |
| 1039 | // руками, потом переустановили ту же игру (или заново прогнали |
| 1040 | // import) — `add()` вызывается снова с тем же именем и не должен |
| 1041 | // тихо вернуть обложку к букве на градиенте. |
| 1042 | let dir = std::env::temp_dir().join("chl-test-library-обложка-переустановка"); |
| 1043 | std::fs::create_dir_all(&dir).unwrap(); |
| 1044 | let cover = dir.join("cover.png"); |
| 1045 | std::fs::write(&cover, b"png").unwrap(); |
| 1046 | |
| 1047 | let mut lib = super::Library::default(); |
| 1048 | let exe = std::path::Path::new("/games/game.exe"); |
| 1049 | lib.add(exe, Some("Игра"), None, super::Source::Manual).unwrap(); |
| 1050 | lib.games.get_mut("Игра").unwrap().cover = Some(cover.clone()); |
| 1051 | |
| 1052 | lib.add(exe, Some("Игра"), None, super::Source::Manual).unwrap(); |
| 1053 | assert_eq!(lib.get("Игра").unwrap().cover.as_deref(), Some(cover.as_path())); |
| 1054 | |
| 1055 | std::fs::remove_dir_all(&dir).ok(); |
| 1056 | } |
| 1057 | |
| 1058 | #[test] |
| 1059 | fn обложка_на_несуществующий_файл_не_переносится() { |
| 1060 | // Путь мог устареть (кэш обложки почистили) — переносить мёртвую |
| 1061 | // ссылку хуже, чем оставить плитку с буквой: та хотя бы честная. |
| 1062 | let mut lib = super::Library::default(); |
| 1063 | let exe = std::path::Path::new("/games/game.exe"); |
| 1064 | lib.add(exe, Some("Игра"), None, super::Source::Manual).unwrap(); |
| 1065 | lib.games.get_mut("Игра").unwrap().cover = |
| 1066 | Some(std::path::PathBuf::from("/нет/такого/файла.png")); |
| 1067 | |
| 1068 | lib.add(exe, Some("Игра"), None, super::Source::Manual).unwrap(); |
| 1069 | assert_eq!(lib.get("Игра").unwrap().cover, None); |
| 1070 | } |
| 1071 | |
| 1072 | #[test] |
| 1073 | fn повторный_импорт_подтягивает_появившуюся_обложку() { |
| 1074 | // Steam скачивает картинки не сразу, и игра, добавленная сразу после |
| 1075 | // установки, иначе осталась бы без обложки навсегда. |
| 1076 | let d = std::env::temp_dir().join("chl-test-cover-refresh"); |
| 1077 | std::fs::create_dir_all(&d).unwrap(); |
| 1078 | let art = d.join("capsule.jpg"); |
| 1079 | std::fs::write(&art, b"x").unwrap(); |
| 1080 | |
| 1081 | let mut lib = super::Library::default(); |
| 1082 | let exe = std::path::Path::new("/games/steam/game"); |
| 1083 | assert!(lib.add_steam("Игра", 42, exe, None).added()); |
| 1084 | assert!(lib.get("Игра").unwrap().cover.is_none()); |
| 1085 | |
| 1086 | assert_eq!( |
| 1087 | lib.add_steam("Игра", 42, exe, Some(art.clone())), |
| 1088 | super::SteamImport::CoverUpdated |
| 1089 | ); |
| 1090 | assert_eq!(lib.get("Игра").unwrap().cover.as_ref(), Some(&art)); |
| 1091 | |
| 1092 | // А настроенное руками не трогаем: перезапись стёрла бы настройку. |
| 1093 | lib.games.get_mut("Игра").unwrap().prefix = "pfx_своя".into(); |
| 1094 | lib.add_steam("Игра", 42, std::path::Path::new("/другой"), Some(art)); |
| 1095 | let g = lib.get("Игра").unwrap(); |
| 1096 | assert_eq!(g.prefix, "pfx_своя"); |
| 1097 | assert_eq!(g.exe, exe); |
| 1098 | std::fs::remove_dir_all(&d).ok(); |
| 1099 | } |
| 1100 | |
| 1101 | #[test] |
| 1102 | fn игры_steam_не_идут_в_ярлыки_steam() { |
| 1103 | // Ярлык на игру, которая в Steam уже есть, дал бы второй значок, |
| 1104 | // ведущий к нашему Wine вместо Proton. |
| 1105 | let mut lib = super::Library::default(); |
| 1106 | lib.add_steam("Из Steam", 42, std::path::Path::new("/games/steam/game"), None); |
| 1107 | lib.add( |
| 1108 | std::path::Path::new("/games/my/game.exe"), |
| 1109 | Some("Своя"), |
| 1110 | None, |
| 1111 | super::Source::Manual, |
| 1112 | ) |
| 1113 | .unwrap(); |
| 1114 | let names: Vec<&str> = lib.exportable().iter().map(|(n, _)| n.as_str()).collect(); |
| 1115 | assert_eq!(names, ["Своя"]); |
| 1116 | } |
| 1117 | |
| 1118 | use super::*; |
| 1119 | |
| 1120 | #[test] |
| 1121 | fn имя_выводится_как_в_startwine() { |
| 1122 | assert_eq!(name_for_exe(Path::new("/g/My Game.exe")).unwrap(), "My_Game"); |
| 1123 | assert_eq!(name_for_exe(Path::new("/g/setup.MSI")).unwrap(), "setup"); |
| 1124 | assert_eq!(name_for_exe(Path::new("/g/run.bat")).unwrap(), "run"); |
| 1125 | // Не игровое расширение не отрезается: иначе version.dll стал бы version. |
| 1126 | assert_eq!(name_for_exe(Path::new("/g/данные.dat")).unwrap(), "данные.dat"); |
| 1127 | assert_eq!(name_for_exe(Path::new("/g/игра.exe")).unwrap(), "игра"); |
| 1128 | } |
| 1129 | |
| 1130 | #[test] |
| 1131 | fn добавление_и_чтение() { |
| 1132 | let mut lib = Library::default(); |
| 1133 | let name = lib |
| 1134 | .add(Path::new("/games/Half Life.exe"), None, None, Source::Manual) |
| 1135 | .unwrap(); |
| 1136 | assert_eq!(name.name, "Half_Life"); |
| 1137 | assert_eq!(lib.get("Half_Life").unwrap().prefix, "pfx_default"); |
| 1138 | } |
| 1139 | |
| 1140 | #[test] |
| 1141 | fn запись_и_чтение_туда_обратно() { |
| 1142 | let d = std::env::temp_dir().join("chl-test-lib"); |
| 1143 | std::fs::remove_dir_all(&d).ok(); |
| 1144 | let path = d.join("library.toml"); |
| 1145 | |
| 1146 | let mut lib = Library::default(); |
| 1147 | lib.add(Path::new("/g/игра.exe"), None, Some("pfx_игра"), Source::Manual) |
| 1148 | .unwrap(); |
| 1149 | lib.save(&path).unwrap(); |
| 1150 | |
| 1151 | let back = Library::load(&path).unwrap(); |
| 1152 | assert_eq!(back.games, lib.games); |
| 1153 | std::fs::remove_dir_all(&d).ok(); |
| 1154 | } |
| 1155 | |
| 1156 | #[test] |
| 1157 | fn отсутствие_файла_это_пустая_библиотека_а_не_ошибка() { |
| 1158 | let lib = Library::load(Path::new("/такого/файла/нет.toml")).unwrap(); |
| 1159 | assert!(lib.games.is_empty()); |
| 1160 | } |
| 1161 | |
| 1162 | /// Настоящая форма записи `exe_data.json` (`sw_data.py::ExeData`, |
| 1163 | /// `hash_()`): ключ верхнего уровня — sha256(path)[:16], имя и путь — |
| 1164 | /// в полях `name`/`path` значения. |
| 1165 | fn write_exe_data(json: &Path, entries: &[serde_json::Value]) { |
| 1166 | let mut map = serde_json::Map::new(); |
| 1167 | for (i, e) in entries.iter().enumerate() { |
| 1168 | // Реальный ключ — hex-хэш; для теста важна только его |
| 1169 | // непрозрачность, а не конкретное значение. |
| 1170 | map.insert(format!("{:016x}", i), e.clone()); |
| 1171 | } |
| 1172 | std::fs::write(json, serde_json::Value::Object(map).to_string()).unwrap(); |
| 1173 | } |
| 1174 | |
| 1175 | #[test] |
| 1176 | fn перенос_не_затирает_настроенное() { |
| 1177 | let d = std::env::temp_dir().join("chl-test-import"); |
| 1178 | std::fs::remove_dir_all(&d).ok(); |
| 1179 | std::fs::create_dir_all(&d).unwrap(); |
| 1180 | let json = d.join("exe_data.json"); |
| 1181 | write_exe_data( |
| 1182 | &json, |
| 1183 | &[ |
| 1184 | serde_json::json!({"name": "Игра", "path": "/из/startwine.exe"}), |
| 1185 | serde_json::json!({"name": "Другая", "path": "/тоже/да.exe"}), |
| 1186 | ], |
| 1187 | ); |
| 1188 | |
| 1189 | let mut lib = Library::default(); |
| 1190 | lib.add(Path::new("/мой/путь.exe"), Some("Игра"), None, Source::Manual) |
| 1191 | .unwrap(); |
| 1192 | |
| 1193 | let added = lib.import_startwine(&json).unwrap(); |
| 1194 | assert_eq!(added, 1, "должна добавиться только неизвестная игра"); |
| 1195 | assert_eq!(lib.get("Игра").unwrap().exe, PathBuf::from("/мой/путь.exe")); |
| 1196 | assert_eq!(lib.get("Другая").unwrap().source, Source::Startwine); |
| 1197 | assert_eq!( |
| 1198 | lib.get("Другая").unwrap().exe, |
| 1199 | PathBuf::from("/тоже/да.exe") |
| 1200 | ); |
| 1201 | std::fs::remove_dir_all(&d).ok(); |
| 1202 | } |
| 1203 | |
| 1204 | #[test] |
| 1205 | fn перенос_выводит_имя_из_пути_если_поле_name_пусто() { |
| 1206 | let d = std::env::temp_dir().join("chl-test-import-noname"); |
| 1207 | std::fs::remove_dir_all(&d).ok(); |
| 1208 | std::fs::create_dir_all(&d).unwrap(); |
| 1209 | let json = d.join("exe_data.json"); |
| 1210 | write_exe_data(&json, &[serde_json::json!({"path": "/g/Без Имени.exe"})]); |
| 1211 | |
| 1212 | let mut lib = Library::default(); |
| 1213 | let added = lib.import_startwine(&json).unwrap(); |
| 1214 | assert_eq!(added, 1); |
| 1215 | assert!( |
| 1216 | lib.get("Без_Имени").is_some(), |
| 1217 | "имя должно вывестись из пути тем же правилом, что и в name_for_exe" |
| 1218 | ); |
| 1219 | std::fs::remove_dir_all(&d).ok(); |
| 1220 | } |
| 1221 | |
| 1222 | #[test] |
| 1223 | fn перенос_пропускает_steam_псевдопуть() { |
| 1224 | // sw_func.py: exe_data.set_(app_path, "path", f'"steam://rungameid/{app_id}"') |
| 1225 | // — это не файл, а URI, и своя библиотека Steam для этого уже есть. |
| 1226 | let d = std::env::temp_dir().join("chl-test-import-steam"); |
| 1227 | std::fs::remove_dir_all(&d).ok(); |
| 1228 | std::fs::create_dir_all(&d).unwrap(); |
| 1229 | let json = d.join("exe_data.json"); |
| 1230 | write_exe_data( |
| 1231 | &json, |
| 1232 | &[serde_json::json!({ |
| 1233 | "name": "Из Steam", |
| 1234 | "path": "steam://rungameid/1904480", |
| 1235 | "platform": "steam", |
| 1236 | })], |
| 1237 | ); |
| 1238 | |
| 1239 | let mut lib = Library::default(); |
| 1240 | let added = lib.import_startwine(&json).unwrap(); |
| 1241 | assert_eq!(added, 0, "запись Steam с псевдопутём не должна попасть в библиотеку"); |
| 1242 | assert!(lib.get("Из Steam").is_none()); |
| 1243 | std::fs::remove_dir_all(&d).ok(); |
| 1244 | } |
| 1245 | |
| 1246 | #[test] |
| 1247 | fn перенос_пропускает_epic_свой_перенос_точнее() { |
| 1248 | // sw_func.py::set_epic_game_data — путь настоящий, но chl_epic::installed |
| 1249 | // читает installed.json legendary/Heroic напрямую и умеет различать |
| 1250 | // одну и ту же игру, увиденную из двух чужих лаунчеров (app_name), |
| 1251 | // чего у записи StartWine нет. |
| 1252 | let d = std::env::temp_dir().join("chl-test-import-epic"); |
| 1253 | std::fs::remove_dir_all(&d).ok(); |
| 1254 | std::fs::create_dir_all(&d).unwrap(); |
| 1255 | let json = d.join("exe_data.json"); |
| 1256 | write_exe_data( |
| 1257 | &json, |
| 1258 | &[serde_json::json!({ |
| 1259 | "name": "Fall Guys", |
| 1260 | "path": "/home/u/Games/Fall Guys/FallGuys_client_game.exe", |
| 1261 | "platform": "epic", |
| 1262 | })], |
| 1263 | ); |
| 1264 | |
| 1265 | let mut lib = Library::default(); |
| 1266 | let added = lib.import_startwine(&json).unwrap(); |
| 1267 | assert_eq!(added, 0, "Epic переносится своим импортом, не этим"); |
| 1268 | std::fs::remove_dir_all(&d).ok(); |
| 1269 | } |
| 1270 | |
| 1271 | #[test] |
| 1272 | fn перенос_забирает_gog_своего_переноса_у_gog_ещё_нет() { |
| 1273 | // sw_func.py::set_gog_game_data — путь настоящий, и в отличие от Epic |
| 1274 | // у GOG пока нет отдельного импорта, так что это единственный источник. |
| 1275 | let d = std::env::temp_dir().join("chl-test-import-gog"); |
| 1276 | std::fs::remove_dir_all(&d).ok(); |
| 1277 | std::fs::create_dir_all(&d).unwrap(); |
| 1278 | let json = d.join("exe_data.json"); |
| 1279 | write_exe_data( |
| 1280 | &json, |
| 1281 | &[serde_json::json!({ |
| 1282 | "name": "Cyberpunk 2077", |
| 1283 | "path": "/home/u/Games/Cyberpunk 2077/bin/x64/Cyberpunk2077.exe", |
| 1284 | "platform": "gog", |
| 1285 | })], |
| 1286 | ); |
| 1287 | |
| 1288 | let mut lib = Library::default(); |
| 1289 | let added = lib.import_startwine(&json).unwrap(); |
| 1290 | assert_eq!(added, 1, "своего импорта GOG нет — переносится отсюда"); |
| 1291 | let g = lib.get("Cyberpunk 2077").unwrap(); |
| 1292 | assert_eq!(g.source, Source::Startwine); |
| 1293 | assert_eq!( |
| 1294 | g.exe, |
| 1295 | PathBuf::from("/home/u/Games/Cyberpunk 2077/bin/x64/Cyberpunk2077.exe") |
| 1296 | ); |
| 1297 | std::fs::remove_dir_all(&d).ok(); |
| 1298 | } |
| 1299 | |
| 1300 | #[test] |
| 1301 | fn перенос_не_проверяет_существование_файла() { |
| 1302 | // Кэш StartWine может устареть — как и Library::add, перенос не |
| 1303 | // отказывает из-за этого: пропавший файл обнаружится позже через |
| 1304 | // Game::is_present, а не на этапе переноса. |
| 1305 | let d = std::env::temp_dir().join("chl-test-import-stale"); |
| 1306 | std::fs::remove_dir_all(&d).ok(); |
| 1307 | std::fs::create_dir_all(&d).unwrap(); |
| 1308 | let json = d.join("exe_data.json"); |
| 1309 | write_exe_data( |
| 1310 | &json, |
| 1311 | &[serde_json::json!({"name": "Устарела", "path": "/нет/такого/файла.exe"})], |
| 1312 | ); |
| 1313 | |
| 1314 | let mut lib = Library::default(); |
| 1315 | let added = lib.import_startwine(&json).unwrap(); |
| 1316 | assert_eq!(added, 1); |
| 1317 | assert!(!lib.get("Устарела").unwrap().is_present()); |
| 1318 | std::fs::remove_dir_all(&d).ok(); |
| 1319 | } |
| 1320 | |
| 1321 | #[test] |
| 1322 | fn смена_регистра_имени_файла_не_прячет_игру() { |
| 1323 | // Настоящий случай: Steam после самообновления переименовал |
| 1324 | // Steam.exe в steam.exe, и записанный путь перестал существовать. |
| 1325 | let d = std::env::temp_dir().join("chl-test-lib-case"); |
| 1326 | std::fs::remove_dir_all(&d).ok(); |
| 1327 | std::fs::create_dir_all(&d).unwrap(); |
| 1328 | std::fs::write(d.join("steam.exe"), b"x").unwrap(); |
| 1329 | |
| 1330 | let mut lib = Library::default(); |
| 1331 | lib.add(&d.join("Steam.exe"), Some("Steam"), None, Source::Manual) |
| 1332 | .unwrap(); |
| 1333 | let g = lib.get("Steam").unwrap(); |
| 1334 | assert!(g.is_present(), "игра не должна теряться из-за регистра"); |
| 1335 | assert!(g.actual_exe().unwrap().ends_with("steam.exe")); |
| 1336 | std::fs::remove_dir_all(&d).ok(); |
| 1337 | } |
| 1338 | |
| 1339 | #[test] |
| 1340 | fn игра_из_steam_несёт_идентификатор_и_обложку() { |
| 1341 | let mut lib = Library::default(); |
| 1342 | assert!(lib.add_steam("Absolum", 1904480, Path::new("/g/Absolum"), Some("/c.jpg".into())).added()); |
| 1343 | let g = lib.get("Absolum").unwrap(); |
| 1344 | assert_eq!(g.steam_appid, Some(1904480)); |
| 1345 | assert_eq!(g.source, Source::Store); |
| 1346 | assert!(g.cover.is_some()); |
| 1347 | } |
| 1348 | |
| 1349 | #[test] |
| 1350 | fn повторный_импорт_не_затирает_настроенное() { |
| 1351 | let mut lib = Library::default(); |
| 1352 | lib.add(Path::new("/мой/путь.exe"), Some("Absolum"), Some("pfx_свой"), Source::Manual) |
| 1353 | .unwrap(); |
| 1354 | assert!(!lib.add_steam("Absolum", 1904480, Path::new("/g/Absolum"), None).added()); |
| 1355 | assert_eq!(lib.get("Absolum").unwrap().prefix, "pfx_свой"); |
| 1356 | } |
| 1357 | |
| 1358 | #[test] |
| 1359 | fn пустой_индекс_startwine_не_ошибка() { |
| 1360 | let d = std::env::temp_dir().join("chl-test-import-empty"); |
| 1361 | std::fs::create_dir_all(&d).unwrap(); |
| 1362 | let json = d.join("exe_data.json"); |
| 1363 | std::fs::write(&json, "{}").unwrap(); |
| 1364 | let mut lib = Library::default(); |
| 1365 | assert_eq!(lib.import_startwine(&json).unwrap(), 0); |
| 1366 | std::fs::remove_dir_all(&d).ok(); |
| 1367 | } |
| 1368 | |
| 1369 | #[test] |
| 1370 | fn имя_из_каталога_берётся_с_папки_игры_а_не_из_файла() { |
| 1371 | use super::name_for_exe_dir; |
| 1372 | assert_eq!( |
| 1373 | name_for_exe_dir(Path::new("/home/u/Games/Red Dead Redemption 2/RDR2.exe")).unwrap(), |
| 1374 | "Red Dead Redemption 2" |
| 1375 | ); |
| 1376 | assert_eq!( |
| 1377 | name_for_exe_dir(Path::new("/home/u/Загрузки/The Last of Us Part I-InsaneRamZes/launcher.exe")) |
| 1378 | .unwrap(), |
| 1379 | "The Last of Us Part I-InsaneRamZes" |
| 1380 | ); |
| 1381 | } |
| 1382 | |
| 1383 | #[test] |
| 1384 | fn имя_из_каталога_пропускает_служебные_подкаталоги() { |
| 1385 | use super::name_for_exe_dir; |
| 1386 | assert_eq!( |
| 1387 | name_for_exe_dir(Path::new("/g/Cyberpunk 2077/bin/x64/Cyberpunk2077.exe")).unwrap(), |
| 1388 | "Cyberpunk 2077" |
| 1389 | ); |
| 1390 | // «Phoenix» — каталог проекта Unreal, а не название игры. Его в |
| 1391 | // общий список служебных не внести (у каждой игры он свой), но |
| 1392 | // из одного слова название игры почти никогда не состоит, и |
| 1393 | // поиск идёт выше — до «Hogwarts Legacy». |
| 1394 | assert_eq!( |
| 1395 | name_for_exe_dir(Path::new("/g/Hogwarts Legacy/Phoenix/Binaries/Win64/HogwartsLegacy.exe")) |
| 1396 | .unwrap(), |
| 1397 | "Hogwarts Legacy" |
| 1398 | ); |
| 1399 | // Тот же случай в библиотеке владельца: у GTA Trilogy полезное имя |
| 1400 | // — подпапка конкретной игры, а не корень репака и не «Gameface». |
| 1401 | assert_eq!( |
| 1402 | name_for_exe_dir(Path::new( |
| 1403 | "/home/u/Games/Grand.Theft.Auto.The.Trilogy.The.Definitive.Edition-InsaneRamZes/\ |
| 1404 | GTA III - Definitive Edition/Gameface/Binaries/Win64/LibertyCity.exe" |
| 1405 | )) |
| 1406 | .unwrap(), |
| 1407 | "GTA III - Definitive Edition" |
| 1408 | ); |
| 1409 | // Односложное название каталога не теряется: выше ничего похожего |
| 1410 | // на название нет, и возвращается именно оно. |
| 1411 | assert_eq!( |
| 1412 | name_for_exe_dir(Path::new("/home/u/Games/AERMemoriesOfOld/AER.exe")).unwrap(), |
| 1413 | "AERMemoriesOfOld" |
| 1414 | ); |
| 1415 | } |
| 1416 | |
| 1417 | #[test] |
| 1418 | fn имя_из_каталога_не_предлагает_полку_или_домашний_каталог() { |
| 1419 | use super::name_for_exe_dir; |
| 1420 | assert_eq!(name_for_exe_dir(Path::new("/home/u/Загрузки/setup.exe")), None); |
| 1421 | assert_eq!(name_for_exe_dir(Path::new("/home/u/Games/bin/game.exe")), None); |
| 1422 | assert_eq!(name_for_exe_dir(Path::new("/game.exe")), None); |
| 1423 | assert_eq!(name_for_exe_dir(Path::new("game.exe")), None); |
| 1424 | } |
| 1425 | |
| 1426 | #[test] |
| 1427 | fn поиск_по_exe_находит_игру_и_не_путает_с_другой() { |
| 1428 | let mut lib = Library::default(); |
| 1429 | lib.add(Path::new("/g/A/a.exe"), Some("A"), None, Source::Manual).unwrap(); |
| 1430 | lib.add(Path::new("/g/B/b.exe"), Some("B"), None, Source::Manual).unwrap(); |
| 1431 | assert_eq!(lib.find_by_exe(Path::new("/g/B/b.exe")), Some("B")); |
| 1432 | assert_eq!(lib.find_by_exe(Path::new("/g/C/c.exe")), None); |
| 1433 | } |
| 1434 | } |
| 1435 |