Project Chimera
Меню

Исходники

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
13use std::collections::BTreeMap;
14use std::path::{Path, PathBuf};
15
16use anyhow::{Context, Result, bail};
17use 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)]
31pub enum GameKind {
32 #[default]
33 Game,
34 Application,
35}
36
37impl 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/// сам лаунчер, а не о конкретной программе, и это верно для любой из них.
55pub const APPLICATION_DISCLAIMER: &str = "Лаунчер запускает эту программу через Wine — так же, как игру. Он не проверяет и не может проверить, куплена ли у неё лицензия: это касается только тебя и разработчика программы. Если программа платная — используй её на тех условиях, на которых её продают; если это невозможно там, где ты находишься, — решение и ответственность за него твои, не лаунчера. Поддержки конкретных программ (кроме отдельно перечисленных в базе знаний) нет: Wine — это совместимость, а не гарантия, что любая программа заработает так же, как под настоящей Windows.";
56
57/// Одна игра.
58#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
59pub 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
103impl 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
144fn default_prefix() -> String {
145 "pfx_default".to_string()
146}
147
148/// Чтобы `kind: Game` (подавляющее большинство записей) не писалось в
149/// файл лишней строкой — та же экономия, что уже есть у `hidden`.
150fn 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")]
156pub enum Source {
157 /// Добавлена пользователем.
158 #[default]
159 Manual,
160 /// Перенесена из StartWine.
161 Startwine,
162 /// Из магазина.
163 Store,
164}
165
166impl 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
207impl 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)]
219pub 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
235impl 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)]
263pub 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)]
277pub struct Library {
278 #[serde(default)]
279 pub games: BTreeMap<String, Game>,
280}
281
282impl 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/// одной проверки.
673fn 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/// ним значит потерять уже сделанные настройки при переносе.
689pub 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/// и подобное встречается почти в каждой второй установке.
708const 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/<имя>`.
717const 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/// то же, что возвращалось раньше.
747pub 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/// «годится ли имя», а только «стоит ли посмотреть ещё выше».
783pub(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)]
791mod 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