From 011d525e8de07d4a12bbcea361c6d44851bc52ee Mon Sep 17 00:00:00 2001 From: AskaEth Date: Sun, 8 Nov 2026 13:24:35 +0800 Subject: [PATCH] =?UTF-8?q?feat(addon):=20Modrinth=20=E5=89=8D=E7=BD=AE?= =?UTF-8?q?=E4=BE=9D=E8=B5=96=20BFS=20=E8=A7=A3=E6=9E=90=E4=B8=8E=E4=B8=A4?= =?UTF-8?q?=E6=A1=A3=E5=A4=B1=E8=B4=A5=E5=90=8D=E5=8D=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - model 纳入 `dependencies`（project_id / version_id / file_name + required / optional / incompatible / embedded / unknown 五值），只跟 required 递归； - 新增 `online::dependency`（请求/计划/跳过的形状）与 `online::resolve` （BFS：规范项目 id 去重防环、每项目只解一次版本、同层按项目键字典序、 默认深度 6 且截断写进计划、父子关系进 `required_by`）； - 失败从类型上分两档：`Incompatible`（所选版本/加载器没有匹配项）与 `Unreachable`（并保留叶子成因 NotFound/NotConnected/…），`retry_request()` 只含失败项，解析永不返回 Err（失败是数据，不连坐）； - 盘上第二道去重：`present_key` 归一化文件名（小写、砍路径、去 `.disabled`）， 命中即跳过下载，但依赖图仍然展开； - presenter 装入路径改成「解析计划 → 逐个下载」，文案把两档分开写并列出 「可只重试这 N 个」；`KNOWN_LOADERS` 补 iris/optifine（光影的加载器）； - 离线夹具覆盖：嵌套两层、环、扇入、深度截断、两档失败、已存在跳过、光影加载器。 --- crates/core/src/addon/online/dependency.rs | 287 ++++++++++++++++ crates/core/src/addon/online/mod.rs | 24 +- crates/core/src/addon/online/model/mod.rs | 4 +- crates/core/src/addon/online/model/parse.rs | 30 +- crates/core/src/addon/online/model/query.rs | 15 +- crates/core/src/addon/online/model/types.rs | 82 +++++ crates/core/src/addon/online/resolve.rs | 257 +++++++++++++++ .../core/src/addon/online/tests/dependency.rs | 306 ++++++++++++++++++ .../src/addon/online/tests/fixtures_deps.rs | 277 ++++++++++++++++ crates/core/src/addon/online/tests/mod.rs | 2 + crates/presenter/src/host/addon.rs | 4 +- crates/presenter/src/host/addon/install.rs | 191 +++++------ crates/presenter/src/host/addon/plan.rs | 218 +++++++++++++ crates/presenter/src/host/addon/tests.rs | 187 +++++++++++ 14 files changed, 1787 insertions(+), 97 deletions(-) create mode 100644 crates/core/src/addon/online/dependency.rs create mode 100644 crates/core/src/addon/online/resolve.rs create mode 100644 crates/core/src/addon/online/tests/dependency.rs create mode 100644 crates/core/src/addon/online/tests/fixtures_deps.rs create mode 100644 crates/presenter/src/host/addon/plan.rs diff --git a/crates/core/src/addon/online/dependency.rs b/crates/core/src/addon/online/dependency.rs new file mode 100644 index 0000000..12b2c5e --- /dev/null +++ b/crates/core/src/addon/online/dependency.rs @@ -0,0 +1,287 @@ +//! 依赖图谱的**形状**：一次解析要什么（[`ResolveRequest`]）、出什么（[`DependencyPlan`]）。 +//! +//! 算法在 [`super::resolve`]；本文件只放类型与不变量，于是「两档失败从类型上可分辨」这件事 +//! 不必读算法也能核对。 +//! +//! # 三份名单，一份都不许丢 +//! +//! | 名单 | 含义 | 上层该做什么 | +//! |------|------|--------------| +//! | [`DependencyPlan::nodes`] | 要下的（BFS 顺序、父子关系齐全） | 逐个下载 | +//! | [`DependencyPlan::skipped`] | 目标目录里已经有同名文件 | 提示「已存在，跳过」 | +//! | [`DependencyPlan::failures`] | 装不了的，**每条自带 [`FailureKind`]** | 两档分开说；进可重试名单 | +//! +//! `truncated` 是第四样东西：撞到 [`DEFAULT_MAX_DEPTH`] 而没展开的项目。它既不是成功也不是 +//! 失败（站点没拒绝，我们主动停），但**必须**露出来——静默截断会让用户看着「装好了」而缺前置。 +//! +//! # 两档为什么不能合成一句 +//! +//! 「所选版本/加载器没有匹配项」与「网络异常 / 项目不存在」要用户做的事完全不同： +//! 前者换版本或换加载器，后者检查网络再试。字符串错误只能靠 `contains("网络")` 猜， +//! 一改文案就失效；[`FailureKind`] 把判据放在类型上，叶子成因（404 / 连不上 / 5xx） +//! 另存在 [`DependencyFailure::cause`] 上，允许上层再细分而不用重新判。 + +use super::model::{VersionFile, VersionQuery}; + +/// 默认最大深度（根 = 0）。六层足够覆盖真实套娃（前置的前置的前置……）， +/// 同时给环与异常链一个硬边界——撞上就记 [`DependencyPlan::truncated`]，**不静默截断**。 +pub const DEFAULT_MAX_DEPTH: u8 = 6; + +/// 目标目录里已存在的文件（调用方扫描后给；core 不读盘）。 +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub struct PresentFile { + /// 文件名（可以带路径，比对时会砍掉） + pub name: String, +} + +impl PresentFile { + /// 记一个已存在的文件名。 + #[must_use] + pub fn new(name: impl Into) -> Self { + Self { name: name.into() } + } + + /// 归一化后的比对键（见 [`present_key`]）。 + #[must_use] + pub fn key(&self) -> String { + present_key(&self.name) + } +} + +/// 文件名 → 比对键：只留文件名、小写、去掉 `.disabled` 后缀。 +/// +/// 为什么带 `.disabled`：本仓用**路径后缀**表示禁用（`mods/x.jar.disabled`，见 +/// `core::addon::export`），禁用中的 jar 也是「装过」，再下一份会和它并存。 +#[must_use] +pub fn present_key(name: &str) -> String { + let base = name + .rsplit(['/', '\\']) + .next() + .unwrap_or(name) + .trim() + .to_ascii_lowercase(); + base.strip_suffix(".disabled").unwrap_or(&base).to_string() +} + +/// 一次解析请求。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResolveRequest { + /// 起点（项目 id 或 slug）；同层处理时按项目键字典序，与这里给的顺序无关 + pub roots: Vec, + /// 目标游戏版本（选版本用；`None` = 不限） + pub game_version: Option, + /// 目标加载器（选版本用；`None` = 不限） + pub loader: Option, + /// 最大深度（根 = 0，见 [`DEFAULT_MAX_DEPTH`]） + pub max_depth: u8, + /// 目标目录里已存在的文件（盘上去重的依据；空 = 目录是空的） + pub present: Vec, +} + +impl Default for ResolveRequest { + fn default() -> Self { + Self { + roots: Vec::new(), + game_version: None, + loader: None, + max_depth: DEFAULT_MAX_DEPTH, + present: Vec::new(), + } + } +} + +impl ResolveRequest { + /// 单根请求（内容库「装进实例」的入口形状）。 + #[must_use] + pub fn single(project: impl Into) -> Self { + Self { + roots: vec![project.into()], + ..Self::default() + } + } + + /// 这个项目的版本请求（过滤条件相同，只换项目）。 + #[must_use] + pub fn version_query(&self, project: &str) -> VersionQuery { + VersionQuery { + project: project.to_string(), + game_version: self.game_version.clone(), + loader: self.loader.clone(), + } + } +} + +/// 计划里的一条「要装什么」。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PlannedNode { + /// 规范项目 id（站点回的 `project_id`；空则用请求时的键） + pub project: String, + /// 当初请求它用的键（slug 或 id）——重试要用同一个 + pub requested_as: String, + /// 版本 id + pub version_id: String, + /// 版本名 + pub version_name: String, + /// 版本号 + pub version_number: String, + /// 要下载的那个文件（`primary` 优先，见 `Version::primary_file`） + pub file: VersionFile, + /// 距根的层数（根 = 0） + pub depth: u8, + /// 谁要求装它（规范项目 id，排序去重；根为空 = 用户自己点的） + pub required_by: Vec, +} + +impl PlannedNode { + /// 是用户点的那个项目吗（根 = 层数 0）。 + /// + /// 判据是 `depth` 而不是 `required_by.is_empty()`：环里根也会被别人「要求」 + /// （A ⇄ B 时 A 的 `required_by` 里有 B），但它在计划里仍是起点。 + #[must_use] + pub fn is_root(&self) -> bool { + self.depth == 0 + } +} + +/// 为什么跳过。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SkipReason { + /// 目标目录里已经有同名文件（含 `.disabled`） + AlreadyPresent, +} + +impl SkipReason { + /// 稳定字符串 id（日志 / DTO 用，**不要改名**）。 + #[must_use] + pub const fn as_str(self) -> &'static str { + match self { + Self::AlreadyPresent => "already_present", + } + } +} + +/// 一条被跳过的（本来要下载的）项目。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SkippedNode { + /// 规范项目 id + pub project: String, + /// 请求它用的键 + pub requested_as: String, + /// 计划里的文件名（在目录里找到了同名的那个） + pub file_name: String, + /// 距根的层数 + pub depth: u8, + /// 谁要求装它 + pub required_by: Vec, + /// 跳过原因 + pub reason: SkipReason, +} + +/// 失败的两档（**类型上就分开，不许拼成一句「下载失败」**）。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum FailureKind { + /// 站点有这个项目，但所选游戏版本 / 加载器下没有可装的条目 + /// （版本列表为空，或选中的版本没有可下载的主文件）。 + /// + /// 用户该做的动作是**换版本或换加载器**；原样重试得到的还是这一档。 + Incompatible, + /// 取不到：没联网 / 项目不存在 / 站点出错 / 响应坏。 + /// + /// 用户该做的动作是**检查网络后再试**；具体叶子成因保留在 + /// [`DependencyFailure::cause`] 上（`NotFound` 与 `NotConnected` 不能混为一谈）。 + Unreachable, +} + +impl FailureKind { + /// 稳定字符串 id（日志 / 命令行输出用，**不要改名**）。 + #[must_use] + pub const fn as_str(self) -> &'static str { + match self { + Self::Incompatible => "incompatible", + Self::Unreachable => "unreachable", + } + } +} + +/// 一条解析失败（进「可重试名单」的就是它们）。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DependencyFailure { + /// 请求它用的键（重试也用它） + pub requested_as: String, + /// 当初因为谁而被要求（规范项目 id；根为空） + pub required_by: Vec, + /// 距根的层数 + pub depth: u8, + /// 哪一档 + pub kind: FailureKind, + /// 叶子成因（只有 [`FailureKind::Unreachable`] 有） + pub cause: Option, + /// 人读说明（站点/引擎原话 + 上下文，不是界面文案） + pub message: String, +} + +/// 一次 BFS 的完整结果（成功、跳过、失败三份名单，都**不丢**）。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DependencyPlan { + /// 这次用的请求（重试要沿用同样的过滤条件与同一份 `present`） + pub request: ResolveRequest, + /// 要装的（BFS 顺序：层号小的在前，同层按项目键字典序） + pub nodes: Vec, + /// 目录里已经有了、不用再下的 + pub skipped: Vec, + /// 装不了的（两档混在同一个列表里，但每条自带 [`FailureKind`]） + pub failures: Vec, + /// 撞到 `max_depth` 而没展开的项目键（排序去重） + pub truncated: Vec, +} + +impl DependencyPlan { + /// 空计划（`resolve` 从这里开始填）。 + #[must_use] + pub fn new(request: &ResolveRequest) -> Self { + Self { + request: request.clone(), + nodes: Vec::new(), + skipped: Vec::new(), + failures: Vec::new(), + truncated: Vec::new(), + } + } + + /// 一条失败都没有吗（空循环也算干净）。 + #[must_use] + pub fn is_clean(&self) -> bool { + self.failures.is_empty() + } + + /// 某一档的失败（两档分开看时用）。 + pub fn failures_of(&self, kind: FailureKind) -> impl Iterator { + self.failures.iter().filter(move |item| item.kind == kind) + } + + /// 「可重试名单」：失败项原样重启一次解析的请求。 + /// + /// 只含失败项 ⇒ 用户只重试这一部分，**不重下**已经装好的文件（`present` 沿用）。 + /// 两档都在名单里，但每条自带 [`FailureKind`]：不兼容那一档重试前得换版本/加载器， + /// 换完再调它才有意义。**这不是「后台自动重试」**——本模块只给请求，什么时候发由上层决定。 + #[must_use] + pub fn retry_request(&self) -> ResolveRequest { + ResolveRequest { + roots: self + .failures + .iter() + .map(|failure| failure.requested_as.clone()) + .collect(), + ..self.request.clone() + } + } + + /// 这个项目为什么在计划里（规范 id → 要求装它的项目）。`None` = 不在计划里。 + #[must_use] + pub fn required_by(&self, project: &str) -> Option<&[String]> { + self.nodes + .iter() + .find(|node| node.project == project) + .map(|node| node.required_by.as_slice()) + } +} diff --git a/crates/core/src/addon/online/mod.rs b/crates/core/src/addon/online/mod.rs index 7886548..0c05038 100644 --- a/crates/core/src/addon/online/mod.rs +++ b/crates/core/src/addon/online/mod.rs @@ -46,23 +46,43 @@ //! | [`modrinth`] | 端点拼装与响应解析（纯逻辑，测试直接喂录制 JSON） | //! | [`download`] | 取下载地址之后那一步：引擎下载 + **sha1/sha512 复核** + 重试 + 不留半截文件 | //! | [`complete`] | 按摘要认文件（[`identity_of`]）：站点返回的版本里哪条才是我们要的那个 | +//! | [`dependency`] | 依赖图谱的形状（请求 / 计划 / **两档失败**） | +//! | [`resolve`] | BFS 解析（只跟 `required`）：去重、按项目缓存、深度上限、确定性顺序 | +//! +//! # 一次「装一个模组」到底发几个请求 +//! +//! M186 之前的实测口径（也是现在仍然成立的基座）：`GET /v2/project/{id}/version` 一次 +//! （带 `game_versions` / `loaders` 两个数组参数）＋ 文件下载一次 = **2 个请求**， +//! 其中**没有任何**依赖解析——`dependencies` 字段根本没进模型，所以「装了模组但进游戏崩」 +//! 这条路只能靠用户自己发现缺前置。 +//! +//! M186 之后：根项目同样是 2 个请求（版本 + 下载），每个 `required` 前置再各加 1 次版本 +//! 请求 + 1 次下载。与参考实现相比省掉了「每个前置再查一次 `/v2/project/{id}` 换 slug」， +//! 因为依赖里给的就是项目 id，而 `/project/{id}/version` 认 id。 pub mod complete; +pub mod dependency; pub mod download; pub mod model; pub mod modrinth; +pub mod resolve; pub mod transport; pub use complete::identity_of; +pub use dependency::{ + present_key, DependencyFailure, DependencyPlan, FailureKind, PlannedNode, PresentFile, + ResolveRequest, SkipReason, SkippedNode, DEFAULT_MAX_DEPTH, +}; pub use download::{ digest_file, download_verified, ArtifactFetcher, Digest, Downloaded, EngineArtifactFetcher, FetchArgs, RETRY_ATTEMPTS, }; pub use model::{ - ContentType, FileHashes, ProjectDetail, ProjectHit, SearchPage, SearchQuery, SortIndex, - Version, VersionFile, VersionQuery, VersionType, + ContentType, Dependency, DependencyType, FileHashes, ProjectDetail, ProjectHit, SearchPage, + SearchQuery, SortIndex, Version, VersionFile, VersionQuery, VersionType, }; pub use modrinth::{HashAlgorithm, Modrinth, MODRINTH_API}; +pub use resolve::resolve; pub use transport::{EngineTransport, OnlineError, OnlineErrorKind, OnlineFuture, Transport}; #[cfg(test)] diff --git a/crates/core/src/addon/online/model/mod.rs b/crates/core/src/addon/online/model/mod.rs index 5faf941..67af82b 100644 --- a/crates/core/src/addon/online/model/mod.rs +++ b/crates/core/src/addon/online/model/mod.rs @@ -32,6 +32,6 @@ mod types; pub use parse::{known_loaders, parse_project, parse_search, parse_version, parse_versions}; pub use query::{ContentType, SearchQuery, SortIndex, KNOWN_LOADERS}; pub use types::{ - FileHashes, ProjectDetail, ProjectHit, SearchPage, Version, VersionFile, VersionQuery, - VersionType, + Dependency, DependencyType, FileHashes, ProjectDetail, ProjectHit, SearchPage, Version, + VersionFile, VersionQuery, VersionType, }; diff --git a/crates/core/src/addon/online/model/parse.rs b/crates/core/src/addon/online/model/parse.rs index e7d1ceb..175810e 100644 --- a/crates/core/src/addon/online/model/parse.rs +++ b/crates/core/src/addon/online/model/parse.rs @@ -8,7 +8,10 @@ use std::collections::BTreeMap; use serde::Deserialize; use super::query::KNOWN_LOADERS; -use super::types::{ProjectDetail, ProjectHit, SearchPage, Version, VersionFile, VersionType}; +use super::types::{ + Dependency, DependencyType, ProjectDetail, ProjectHit, SearchPage, Version, VersionFile, + VersionType, +}; use crate::addon::online::transport::{OnlineError, OnlineErrorKind}; // --------------------------------------------------------------- 解析 @@ -112,6 +115,21 @@ struct RawVersion { downloads: u64, #[serde(default)] files: Vec, + #[serde(default)] + dependencies: Vec, +} + +#[derive(Debug, Default, Deserialize)] +struct RawDependency { + #[serde(default)] + project_id: Option, + #[serde(default)] + version_id: Option, + #[serde(default)] + file_name: Option, + // 站点给的是 `required` / `optional` / `incompatible` / `embedded`；认不出 ⇒ `Unknown` + #[serde(default)] + dependency_type: String, } #[derive(Debug, Default, Deserialize)] @@ -238,6 +256,16 @@ fn version_of(raw: RawVersion) -> Version { primary: file.primary, }) .collect(), + dependencies: raw + .dependencies + .into_iter() + .map(|dependency| Dependency { + project_id: non_empty(dependency.project_id), + version_id: non_empty(dependency.version_id), + file_name: non_empty(dependency.file_name), + dependency_type: DependencyType::parse(&dependency.dependency_type), + }) + .collect(), } } diff --git a/crates/core/src/addon/online/model/query.rs b/crates/core/src/addon/online/model/query.rs index 6c660e5..1e2b57f 100644 --- a/crates/core/src/addon/online/model/query.rs +++ b/crates/core/src/addon/online/model/query.rs @@ -83,7 +83,20 @@ impl SortIndex { /// 站点认的加载器 facet 值（`categories` 里混着 `optimization` 这种**分类标签**， /// 直接整份当加载器会画出假加载器）。 -pub const KNOWN_LOADERS: [&str; 6] = ["fabric", "forge", "neoforge", "quilt", "liteloader", "rift"]; +/// +/// 后两项是**光影**的加载器（Modrinth 把 shader 的 `iris` / `optifine` 也放在 `categories` +/// 里）：不登记它们，光影检索结果的 `loaders` 就会恒为空，页面既画不出「支持 Iris」， +/// 也用不上「只看 Iris」这种判断。 +pub const KNOWN_LOADERS: [&str; 8] = [ + "fabric", + "forge", + "neoforge", + "quilt", + "liteloader", + "rift", + "iris", + "optifine", +]; /// 一次检索请求（分页游标也在里面：换页就是换一份 query）。 #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/crates/core/src/addon/online/model/types.rs b/crates/core/src/addon/online/model/types.rs index 532fb64..8bb0af9 100644 --- a/crates/core/src/addon/online/model/types.rs +++ b/crates/core/src/addon/online/model/types.rs @@ -140,6 +140,67 @@ impl VersionType { } } +/// 前置依赖的类型（`/version` 的 `dependencies[].dependency_type`）。 +/// +/// # 为什么要留 `Unknown` 而不是「认不出就当可选」 +/// +/// 站点以后加新取值时，**只有 `Required` 才该触发递归**。认不出的值落进 `Unknown`， +/// 于是「站点改名」的下场是「少装一个前置」（可观察、可补），而不是「把所有建议项都当必备项 +/// 递归拉一遍」（一次装模组变成几十个请求，还装了一堆不兼容的东西）。 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)] +pub enum DependencyType { + /// 必须装（BFS **只跟这一档**） + Required, + /// 可选（装不装都能跑） + #[default] + Optional, + /// 明确不兼容（**不要**和它一起装） + Incompatible, + /// 已内嵌在被依赖的文件里（不用另外装） + Embedded, + /// 站点给了个我们不认识的取值 + Unknown, +} + +impl DependencyType { + /// 站点原文。 + #[must_use] + pub const fn as_str(self) -> &'static str { + match self { + Self::Required => "required", + Self::Optional => "optional", + Self::Incompatible => "incompatible", + Self::Embedded => "embedded", + Self::Unknown => "unknown", + } + } + + /// 从站点原文解析；认不出（含空串）返回 [`Self::Unknown`]。 + #[must_use] + pub fn parse(raw: &str) -> Self { + match raw.trim() { + "required" => Self::Required, + "optional" => Self::Optional, + "incompatible" => Self::Incompatible, + "embedded" => Self::Embedded, + _ => Self::Unknown, + } + } +} + +/// 版本声明的一条前置（`dependencies[]`）。 +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub struct Dependency { + /// 依赖的**项目** id（BFS 的地址；有了它就不用像参考实现那样再查一次 slug） + pub project_id: Option, + /// 依赖的版本 id（站点基本只对 `embedded` 给） + pub version_id: Option, + /// 站点给的文件名（只对 `embedded` / `incompatible` 有意义） + pub file_name: Option, + /// 依赖类型 + pub dependency_type: DependencyType, +} + /// 一个版本（`/v2/project/{id}/version[]` 与 `/v2/version_file/{hash}` 同一形状）。 #[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct Version { @@ -163,6 +224,8 @@ pub struct Version { pub downloads: u64, /// 文件列表 pub files: Vec, + /// 前置声明（站点原文顺序；空 = 站点没说 / 没有） + pub dependencies: Vec, } impl Version { @@ -176,6 +239,25 @@ impl Version { .find(|file| file.primary) .or_else(|| self.files.first()) } + + /// 要跟下去的**前置项目 id**：只取 `required`，去掉空值，**排序去重**。 + /// + /// 排序在这里做（不是让调用方排）：BFS 的展开顺序必须是数据本身决定的， + /// 否则站点把 `dependencies` 换个顺序、或者用 `HashMap` 收一遍，测试就会随机红。 + #[must_use] + pub fn required_project_ids(&self) -> Vec<&str> { + let mut ids: Vec<&str> = self + .dependencies + .iter() + .filter(|dependency| dependency.dependency_type == DependencyType::Required) + .filter_map(|dependency| dependency.project_id.as_deref()) + .map(str::trim) + .filter(|id| !id.is_empty()) + .collect(); + ids.sort_unstable(); + ids.dedup(); + ids + } } /// 版本里的一个文件。 diff --git a/crates/core/src/addon/online/resolve.rs b/crates/core/src/addon/online/resolve.rs new file mode 100644 index 0000000..977bda1 --- /dev/null +++ b/crates/core/src/addon/online/resolve.rs @@ -0,0 +1,257 @@ +//! BFS 依赖解析（**只跟 `required`**）。形状在 [`super::dependency`]，这里只有算法。 +//! +//! # 与参考实现（Python 版 Modrinth 下载器）的四处差别 +//! +//! | 参考实现 | 这里 | 为什么 | +//! |---|---|---| +//! | 每个前置再 `GET /v2/project/{id}` 换 slug | **不查**，直接拿 `dependencies[].project_id` 当地址 | 依赖里给的就是项目 id，`/project/{id}/version` 认它；一次安装省掉每个前置一个请求 | +//! | 失败名单是字符串，靠括号里的中文区分「不兼容」与「网络异常」 | [`FailureKind`] 枚举 | 「哪一档」要能从类型上判，不能靠 `contains("网络")` | +//! | 一个 dict 兼做缓存与去重 | 键 = **规范项目 id**，别名单设一张表 | 同一项目可能一次以 slug、一次以 id 出现；只按请求串去重会把它装两遍 | +//! | 队列按 `dependencies` 原文顺序展开 | 每层按项目键**字典序**处理 | 顺序必须是数据决定的，否则测试靠 HashMap 运气 | +//! +//! # 失败是**数据**，不是 `Err` +//! +//! [`resolve`] 永远返回一个 [`DependencyPlan`]：某个前置取不到版本时，它进 `failures`， +//! 解析继续做别的分支。若中途 `return Err`，用户看到的是「装这个模组失败」，而真正该看到的 +//! 是「主文件装上了，缺 fabric-api（不兼容 1.20.1/fabric）」＋一份可单独重试的名单。 +//! +//! # 两张去重网 +//! +//! 1. **图内**：同一项目只解一次版本（`nodes` 里每个项目最多一条），多条依赖路径折进 +//! [`PlannedNode::required_by`]； +//! 2. **盘上**：目标目录里已经有同名文件（`.disabled` 也算）就进 `skipped`、**不再下载**。 +//! 这是「已装过的同一项目跳过并提示」里我们真能判的那一半；另一半（同项目**另一个版本** +//! 已装）需要实例侧的已装清单，本模块判不出来（见报告）。 +//! +//! 盘上判定只比文件名（`present` 由调用方扫目录得到，core 不读盘）：内容级去重需要先算一份 +//! sha1，为了「跳过」把整个 `mods/` 哈希一遍不划算；同名文件就是同一份 jar 的最常见形态 +//! （我们落盘用站点给的文件名，不重命名）。 + +use std::collections::{BTreeMap, BTreeSet}; + +use super::dependency::{ + present_key, DependencyFailure, DependencyPlan, FailureKind, PlannedNode, PresentFile, + ResolveRequest, SkipReason, SkippedNode, +}; +use super::model::Version; +use super::modrinth::Modrinth; +use super::transport::Transport; + +/// 一层里还没处理的一项。 +struct Wave { + key: String, + depth: u8, + parents: Vec, +} + +/// BFS 解析。**不返回 `Err`**：失败进 [`DependencyPlan::failures`]（见模块文档）。 +pub async fn resolve( + client: &Modrinth<'_, T>, + request: &ResolveRequest, +) -> DependencyPlan { + let mut plan = DependencyPlan::new(request); + let present: BTreeSet = request.present.iter().map(PresentFile::key).collect(); + // 请求键 → 规范 id（同一项目可能一次给 slug、一次给 id） + let mut alias: BTreeMap = BTreeMap::new(); + let mut resolved: BTreeSet = BTreeSet::new(); + + let mut layer: Vec = Vec::new(); + for root in &request.roots { + let key = root.trim(); + if !key.is_empty() { + wave_in(&mut layer, key, 0, None); + } + } + + while !layer.is_empty() { + // 同层按项目键字典序：顺序由数据决定，不靠插入顺序或 HashMap 的运气。 + layer.sort_by(|left, right| left.key.cmp(&right.key)); + let mut next: Vec = Vec::new(); + for mut item in layer.drain(..) { + normalize(&mut item.parents); + // ① 已经解过（含「A 依赖 B、B 又依赖 A」的环）⇒ 只把父边折进已有节点 + if let Some(canonical) = alias.get(&item.key).cloned() { + fold_parents(&mut plan, &canonical, &item.parents); + continue; + } + let version = match client.versions(&request.version_query(&item.key)).await { + Ok(versions) => match versions.into_iter().next() { + Some(version) => version, + None => { + plan.failures.push(DependencyFailure { + requested_as: item.key, + required_by: item.parents, + depth: item.depth, + kind: FailureKind::Incompatible, + cause: None, + message: filter_message(request), + }); + continue; + } + }, + Err(error) => { + plan.failures.push(DependencyFailure { + requested_as: item.key, + required_by: item.parents, + depth: item.depth, + kind: FailureKind::Unreachable, + cause: Some(error.kind()), + message: format!( + "取版本失败（{}）：{}", + error.kind().as_str(), + error.message() + ), + }); + continue; + } + }; + let Some(file) = version + .primary_file() + .filter(|file| !file.url.trim().is_empty()) + .cloned() + else { + let message = format!( + "{} 的版本 {} 里没有可下载的主文件", + item.key, + version_label(&version) + ); + plan.failures.push(DependencyFailure { + requested_as: item.key, + required_by: item.parents, + depth: item.depth, + kind: FailureKind::Incompatible, + cause: None, + message, + }); + continue; + }; + + let canonical = canonical_of(&item.key, &version); + alias.insert(item.key.clone(), canonical.clone()); + alias + .entry(canonical.clone()) + .or_insert_with(|| canonical.clone()); + // ② 同一项目走了两条路（slug 与 id 各一次）⇒ 折边，不重复装 + if !resolved.insert(canonical.clone()) { + fold_parents(&mut plan, &canonical, &item.parents); + continue; + } + + let file_name = file.filename.clone(); + if present.contains(&present_key(&file_name)) { + plan.skipped.push(SkippedNode { + project: canonical.clone(), + requested_as: item.key.clone(), + file_name, + depth: item.depth, + required_by: item.parents.clone(), + reason: SkipReason::AlreadyPresent, + }); + } else { + plan.nodes.push(PlannedNode { + project: canonical.clone(), + requested_as: item.key.clone(), + version_id: version.id.clone(), + version_name: version.name.clone(), + version_number: version.version_number.clone(), + file, + depth: item.depth, + required_by: item.parents.clone(), + }); + } + + // 子项：只跟 required（排序去重由 `required_project_ids` 保证） + for dependency in version.required_project_ids() { + if item.depth >= request.max_depth { + plan.truncated.push(dependency.to_string()); + } else { + wave_in(&mut next, dependency, item.depth + 1, Some(&canonical)); + } + } + } + plan.truncated.sort(); + plan.truncated.dedup(); + layer = next; + } + + plan +} + +/// 把一项放进这一层的待处理表（同一个键已经排队 ⇒ 只追加父项目）。 +fn wave_in(layer: &mut Vec, key: &str, depth: u8, parent: Option<&str>) { + if let Some(existing) = layer.iter_mut().find(|item| item.key == key) { + if let Some(parent) = parent { + existing.parents.push(parent.to_string()); + } + return; + } + layer.push(Wave { + key: key.to_string(), + depth, + parents: parent + .map(|parent| vec![parent.to_string()]) + .unwrap_or_default(), + }); +} + +/// 往已经建好的节点上折一条父边（节点可能在被跳过的那一档，也可能只出现在失败名单里）。 +fn fold_parents(plan: &mut DependencyPlan, project: &str, parents: &[String]) { + if parents.is_empty() { + return; + } + let node = plan + .nodes + .iter_mut() + .find(|node| node.project == project) + .map(|node| &mut node.required_by); + let node = node.or_else(|| { + plan.skipped + .iter_mut() + .find(|node| node.project == project) + .map(|node| &mut node.required_by) + }); + if let Some(required_by) = node { + required_by.extend(parents.iter().cloned()); + normalize(required_by); + return; + } + if let Some(failure) = plan + .failures + .iter_mut() + .find(|failure| failure.requested_as == project) + { + failure.required_by.extend(parents.iter().cloned()); + normalize(&mut failure.required_by); + } +} + +fn normalize(list: &mut Vec) { + list.sort(); + list.dedup(); +} + +/// 规范身份：站点回的 `project_id` 才是身份；没给就退回请求键。 +fn canonical_of(key: &str, version: &Version) -> String { + let project_id = version.project_id.trim(); + if project_id.is_empty() { + key.to_string() + } else { + project_id.to_string() + } +} + +/// 「哪里没有匹配项」这句话（第一档的固定说法，带出用的是什么过滤条件）。 +fn filter_message(request: &ResolveRequest) -> String { + let game_version = request.game_version.as_deref().unwrap_or("不限"); + let loader = request.loader.as_deref().unwrap_or("不限"); + format!("没有匹配所选游戏版本/加载器（{game_version} / {loader}）的版本") +} + +fn version_label(version: &Version) -> String { + let number = version.version_number.trim(); + if number.is_empty() { + version.id.clone() + } else { + number.to_string() + } +} diff --git a/crates/core/src/addon/online/tests/dependency.rs b/crates/core/src/addon/online/tests/dependency.rs new file mode 100644 index 0000000..1a75948 --- /dev/null +++ b/crates/core/src/addon/online/tests/dependency.rs @@ -0,0 +1,306 @@ +//! 依赖解析的离线用例（录制 JSON 夹具，**不打真实网络**）。 +//! +//! 三条守门对应任务书的三条： +//! 1. [`two_nested_levels_are_pulled_in_a_predictable_order`] —— 嵌套两层能拉全，顺序确定； +//! 2. [`a_dependency_cycle_terminates_and_each_project_appears_once`] —— 环不无限递归； +//! 3. [`an_incompatible_dependency_lands_in_the_retry_list`] —— 不兼容进重试名单，不静默丢。 +//! +//! 每条都配过一次「把实现改坏就该红」的变异（过程写在 M186 报告里），所以断言不是装饰。 + +use crate::addon::online::dependency::{ + present_key, DependencyPlan, FailureKind, PresentFile, ResolveRequest, SkipReason, +}; +use crate::addon::online::model::parse_versions; +use crate::addon::online::{resolve, Modrinth, OnlineErrorKind, MODRINTH_API}; +use crate::download::blocking::block_on; + +use super::fixtures_deps as deps; +use super::support::FixtureTransport; + +const SODIUM_VERSIONS: &str = "https://api.modrinth.com/v2/project/sodium/version"; +const FABRIC_API_VERSIONS: &str = "https://api.modrinth.com/v2/project/P7dR8mSH/version"; +const YACL_VERSIONS: &str = "https://api.modrinth.com/v2/project/1eAoo2KR/version"; + +fn request(root: &str) -> ResolveRequest { + ResolveRequest { + roots: vec![root.to_string()], + game_version: Some("1.20.1".to_string()), + loader: Some("fabric".to_string()), + ..ResolveRequest::default() + } +} + +/// 三层链的传输层（sodium → fabric-api → yacl）。 +fn chain_transport() -> FixtureTransport { + FixtureTransport::new() + .with(SODIUM_VERSIONS, deps::SODIUM_WITH_DEPENDENCIES) + .with(FABRIC_API_VERSIONS, deps::FABRIC_API_WITH_DEPENDENCIES) + .with(YACL_VERSIONS, deps::YACL) +} + +fn resolve_with(transport: &FixtureTransport, request: &ResolveRequest) -> DependencyPlan { + let client = Modrinth::new(transport); + block_on(resolve(&client, request)) +} + +// ---------------------------------------------------------------- ① 嵌套两层 + +#[test] +fn two_nested_levels_are_pulled_in_a_predictable_order() { + let transport = chain_transport(); + let plan = resolve_with(&transport, &request("sodium")); + + assert!(plan.is_clean(), "不该有失败：{:?}", plan.failures); + // 顺序 = BFS 层序，同层按项目键字典序：根 → fabric-api → yacl + let order: Vec<(&str, u8)> = plan + .nodes + .iter() + .map(|node| (node.project.as_str(), node.depth)) + .collect(); + assert_eq!( + order, + vec![("AANobbMI", 0), ("P7dR8mSH", 1), ("1eAoo2KR", 2)] + ); + + // 「为什么装」：父子关系逐条对得上 + assert!(plan.required_by("AANobbMI").expect("根在计划里").is_empty()); + assert_eq!( + plan.required_by("P7dR8mSH").expect("fabric-api 在计划里"), + ["AANobbMI".to_string()].as_slice() + ); + assert_eq!( + plan.required_by("1eAoo2KR").expect("yacl 在计划里"), + ["P7dR8mSH".to_string()].as_slice() + ); + + // 只跟 required：optional / incompatible / embedded 三个 id 一次请求都没发 + let seen = transport.seen(); + assert_eq!(seen.len(), 3, "只该有 3 次版本请求：{seen:?}"); + for quiet in ["OCS3z7f6", "AAAABBBB", "embedded-lib"] { + assert!( + !seen.iter().any(|url| url.contains(quiet)), + "{quiet} 不该被跟：{seen:?}" + ); + } + + // 主文件取 primary（第一个是 sources.jar） + assert_eq!(plan.nodes[0].file.filename, "sodium-fabric-0.6.0.jar"); + assert_eq!(plan.nodes[1].file.filename, "fabric-api-0.92.2+1.20.1.jar"); +} + +#[test] +fn only_required_dependencies_are_followed() { + // 模型层：四值都解析得出来，`required_project_ids` 只吐 required 那一条。 + let versions = parse_versions(deps::SODIUM_WITH_DEPENDENCIES).expect("夹具该解析成功"); + let version = &versions[0]; + assert_eq!(version.dependencies.len(), 4); + let kinds: Vec<&str> = version + .dependencies + .iter() + .map(|dependency| dependency.dependency_type.as_str()) + .collect(); + assert_eq!(kinds, ["required", "optional", "incompatible", "embedded"]); + assert_eq!(version.required_project_ids(), ["P7dR8mSH"]); + // embedded 那条只有 file_name、没有 project_id，不该冒出一个空 id + assert!(version.dependencies[3].project_id.is_none()); +} + +#[test] +fn the_depth_limit_is_reported_instead_of_silently_cutting_the_chain() { + let transport = chain_transport(); + let mut request = request("sodium"); + request.max_depth = 1; + let plan = resolve_with(&transport, &request); + + assert_eq!(plan.nodes.len(), 2, "根 + 第一层"); + assert_eq!(plan.truncated, ["1eAoo2KR"], "截断必须写在计划里"); +} + +// ---------------------------------------------------------------- ② 环 + +#[test] +fn a_dependency_cycle_terminates_and_each_project_appears_once() { + let transport = FixtureTransport::new() + .with( + "https://api.modrinth.com/v2/project/cycle-a/version", + deps::CYCLE_A, + ) + .with( + "https://api.modrinth.com/v2/project/cycBid01/version", + deps::CYCLE_B, + ); + let plan = resolve_with(&transport, &request("cycle-a")); + + let projects: Vec<&str> = plan + .nodes + .iter() + .map(|node| node.project.as_str()) + .collect(); + assert_eq!(projects, ["cycAid01", "cycBid01"], "每个项目只出现一次"); + assert_eq!(transport.seen().len(), 2, "环不许把请求数放大"); + // B 是被 A 要来的；A 又被 B 要（环）——这条边折回已有节点，不新建节点 + assert_eq!( + plan.required_by("cycBid01").expect("B 在计划里"), + ["cycAid01".to_string()].as_slice() + ); + assert_eq!( + plan.required_by("cycAid01").expect("A 在计划里"), + ["cycBid01".to_string()].as_slice() + ); + assert!(plan.nodes[0].is_root(), "根判据是 depth，不是 required_by"); + assert!(!plan.nodes[1].is_root()); +} + +// ---------------------------------------------------------------- ③ 两档失败 + +#[test] +fn an_incompatible_dependency_lands_in_the_retry_list() { + // fabric-api 在 1.20.1/fabric 下没有条目（站点回空数组） + let transport = FixtureTransport::new() + .with(SODIUM_VERSIONS, deps::SODIUM_WITH_DEPENDENCIES) + .with(FABRIC_API_VERSIONS, "[]"); + let plan = resolve_with(&transport, &request("sodium")); + + // 根还在计划里（失败不连坐），缺的那条单独立案 + assert_eq!(plan.nodes.len(), 1); + assert_eq!(plan.failures.len(), 1, "不许静默丢：{:?}", plan.failures); + let failure = &plan.failures[0]; + assert_eq!(failure.kind, FailureKind::Incompatible); + assert_eq!(failure.requested_as, "P7dR8mSH"); + assert_eq!(failure.depth, 1); + assert_eq!(failure.required_by, ["AANobbMI".to_string()]); + assert!(failure.cause.is_none(), "这一档不是网络成因"); + assert!(failure.message.contains("1.20.1"), "文案要带过滤条件"); + assert!(plan.failures_of(FailureKind::Unreachable).next().is_none()); + + // 可重试名单只含失败项，过滤条件沿用 + let retry = plan.retry_request(); + assert_eq!(retry.roots, ["P7dR8mSH"]); + assert_eq!(retry.game_version.as_deref(), Some("1.20.1")); + assert_eq!(retry.loader.as_deref(), Some("fabric")); +} + +#[test] +fn a_missing_project_is_unreachable_and_keeps_its_leaf_cause() { + let transport = FixtureTransport::new() + .with(SODIUM_VERSIONS, deps::SODIUM_WITH_DEPENDENCIES) + .missing(FABRIC_API_VERSIONS); + let plan = resolve_with(&transport, &request("sodium")); + + let failure = &plan.failures[0]; + assert_eq!(failure.kind, FailureKind::Unreachable); + assert_eq!(failure.cause, Some(OnlineErrorKind::NotFound)); + // 两档从类型上就分得开：同一个计划里两种成因不会挤进一条 + assert_eq!(plan.failures_of(FailureKind::Incompatible).count(), 0); +} + +#[test] +fn a_version_without_a_usable_file_is_incompatible_not_a_network_error() { + let transport = FixtureTransport::new() + .with(SODIUM_VERSIONS, deps::SODIUM_WITH_DEPENDENCIES) + .with( + FABRIC_API_VERSIONS, + r#"[{"id": "ver-empty", "project_id": "P7dR8mSH", + "version_number": "0.0", "files": []}]"#, + ); + let plan = resolve_with(&transport, &request("sodium")); + assert_eq!(plan.failures[0].kind, FailureKind::Incompatible); + assert!(plan.failures[0].message.contains("没有可下载的主文件")); +} + +// ---------------------------------------------------------------- 两道去重 + +#[test] +fn one_project_required_by_two_parents_is_planned_once_with_both_parents() { + let transport = FixtureTransport::new() + .with( + "https://api.modrinth.com/v2/project/fanin-root/version", + deps::FANIN_ROOT, + ) + .with( + "https://api.modrinth.com/v2/project/BRANCHAA/version", + deps::FANIN_A, + ) + .with( + "https://api.modrinth.com/v2/project/BRANCHBB/version", + deps::FANIN_B, + ) + .with( + "https://api.modrinth.com/v2/project/SHARED01/version", + deps::SHARED_LIB, + ); + let plan = resolve_with(&transport, &request("fanin-root")); + + let projects: Vec<&str> = plan + .nodes + .iter() + .map(|node| node.project.as_str()) + .collect(); + assert_eq!( + projects, + ["ROOT0001", "BRANCHAA", "BRANCHBB", "SHARED01"], + "同层按项目键字典序，公共前置只出现一次" + ); + assert_eq!( + plan.required_by("SHARED01").expect("公共前置在计划里"), + ["BRANCHAA".to_string(), "BRANCHBB".to_string()].as_slice(), + "两条依赖路径都要留下" + ); + let shared_requests = transport + .seen() + .iter() + .filter(|url| url.contains("SHARED01")) + .count(); + assert_eq!(shared_requests, 1, "一个项目只解一次版本"); +} + +#[test] +fn a_file_that_already_exists_is_skipped_but_its_dependencies_are_still_walked() { + let mut request = request("sodium"); + // 禁用中的 jar 也算「装过」（本仓用 `.disabled` 后缀表示禁用） + request.present = vec![PresentFile::new("fabric-api-0.92.2+1.20.1.jar.disabled")]; + let transport = chain_transport(); + let plan = resolve_with(&transport, &request); + + assert_eq!(plan.skipped.len(), 1); + let skipped = &plan.skipped[0]; + assert_eq!(skipped.project, "P7dR8mSH"); + assert_eq!(skipped.reason, SkipReason::AlreadyPresent); + assert_eq!(skipped.file_name, "fabric-api-0.92.2+1.20.1.jar"); + // 跳过的是**下载**，不是图：fabric-api 的前置照样解析出来 + let projects: Vec<&str> = plan + .nodes + .iter() + .map(|node| node.project.as_str()) + .collect(); + assert_eq!(projects, ["AANobbMI", "1eAoo2KR"]); +} + +#[test] +fn present_keys_normalize_paths_case_and_the_disabled_suffix() { + assert_eq!(present_key("mods/Sodium-0.6.0.jar"), "sodium-0.6.0.jar"); + assert_eq!(present_key("a\\b\\x.jar.disabled"), "x.jar"); + assert_eq!(present_key(" y.jar "), "y.jar"); + assert_eq!(present_key(""), ""); +} + +// ---------------------------------------------------------------- 光影过滤器 + +#[test] +fn shader_loaders_are_recognised_in_search_hits() { + let transport = + FixtureTransport::new().with(&format!("{MODRINTH_API}/search"), deps::SEARCH_SHADER); + let client = Modrinth::new(&transport); + let page = block_on(client.search(&crate::addon::online::SearchQuery { + text: String::new(), + project_type: Some(crate::addon::online::ContentType::Shader), + limit: 1, + ..crate::addon::online::SearchQuery::default() + })) + .expect("解析应当成功"); + assert_eq!( + page.hits[0].loaders, + vec!["iris".to_string(), "optifine".to_string()], + "光影的加载器不该被当成分类标签丢掉" + ); +} diff --git a/crates/core/src/addon/online/tests/fixtures_deps.rs b/crates/core/src/addon/online/tests/fixtures_deps.rs new file mode 100644 index 0000000..4680eac --- /dev/null +++ b/crates/core/src/addon/online/tests/fixtures_deps.rs @@ -0,0 +1,277 @@ +//! 依赖解析用的录制响应（形状按站点原文；数值是示意，不是某天的真值）。 +//! +//! 从 `fixtures.rs` 分出来的原因很实在：那里已经在钉「字段名与 `primary`」这类解析细节， +//! 再往里塞四五个带 `dependencies` 的版本对象就会贴到 400 行硬线。 +//! +//! 三条刻意的布置： +//! - 根项目（`sodium`）的版本里**同时有四类依赖**：只有 `required` 该被跟； +//! - 每个版本都有 `primary: false` 的 `sources.jar`，取第一个就会装错； +//! - 环（`cycle-a` ⇄ `cycle-b`）与扇入（两个分支都要 `shared-lib`）各有一组独立夹具。 + +/// 根项目 `sodium` 的版本：一条 required + 一条 optional + 一条 incompatible + 一条 embedded。 +pub(super) const SODIUM_WITH_DEPENDENCIES: &str = r#"[ + { + "id": "ver-sodium", + "project_id": "AANobbMI", + "name": "Sodium 0.6.0 for 1.20.1", + "version_number": "mc1.20.1-0.6.0", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "date_published": "2026-02-01T12:00:00Z", + "downloads": 4321, + "files": [ + { + "hashes": {"sha1": "1111111111111111111111111111111111111111", "sha512": "aa"}, + "url": "https://cdn.modrinth.com/data/AANobbMI/versions/ver-sodium/sodium-sources.jar", + "filename": "sodium-sources.jar", + "size": 1000, + "primary": false + }, + { + "hashes": {"sha1": "2222222222222222222222222222222222222222", "sha512": "bb"}, + "url": "https://cdn.modrinth.com/data/AANobbMI/versions/ver-sodium/sodium-fabric-0.6.0.jar", + "filename": "sodium-fabric-0.6.0.jar", + "size": 2048, + "primary": true + } + ], + "dependencies": [ + {"version_id": null, "project_id": "P7dR8mSH", "file_name": null, "dependency_type": "required"}, + {"version_id": null, "project_id": "OCS3z7f6", "file_name": null, "dependency_type": "optional"}, + {"version_id": null, "project_id": "AAAABBBB", "file_name": null, "dependency_type": "incompatible"}, + {"version_id": "ver-embedded", "project_id": null, "file_name": "embedded-lib.jar", "dependency_type": "embedded"} + ] + } +]"#; + +/// `fabric-api`（`P7dR8mSH`）：它自己又要求 `yacl`（`1eAoo2KR`）⇒ 第二层嵌套。 +pub(super) const FABRIC_API_WITH_DEPENDENCIES: &str = r#"[ + { + "id": "ver-fabric-api", + "project_id": "P7dR8mSH", + "name": "Fabric API 0.92.2 for 1.20.1", + "version_number": "0.92.2+1.20.1", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "date_published": "2025-12-01T00:00:00Z", + "downloads": 9999, + "files": [ + { + "hashes": {"sha1": "3333333333333333333333333333333333333333", "sha512": "cc"}, + "url": "https://cdn.modrinth.com/data/P7dR8mSH/versions/ver-fabric-api/fabric-api-0.92.2-sources.jar", + "filename": "fabric-api-0.92.2-sources.jar", + "size": 512, + "primary": false + }, + { + "hashes": {"sha1": "4444444444444444444444444444444444444444", "sha512": "dd"}, + "url": "https://cdn.modrinth.com/data/P7dR8mSH/versions/ver-fabric-api/fabric-api-0.92.2+1.20.1.jar", + "filename": "fabric-api-0.92.2+1.20.1.jar", + "size": 4096, + "primary": true + } + ], + "dependencies": [ + {"version_id": null, "project_id": "1eAoo2KR", "file_name": null, "dependency_type": "required"} + ] + } +]"#; + +/// `yacl`（`1eAoo2KR`）：链的末端，没有依赖。 +pub(super) const YACL: &str = r#"[ + { + "id": "ver-yacl", + "project_id": "1eAoo2KR", + "name": "YetAnotherConfigLib 3.3.2", + "version_number": "3.3.2+1.20.1", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "date_published": "2025-11-01T00:00:00Z", + "downloads": 1234, + "files": [ + { + "hashes": {"sha1": "5555555555555555555555555555555555555555", "sha512": "ee"}, + "url": "https://cdn.modrinth.com/data/1eAoo2KR/versions/ver-yacl/yacl-3.3.2.jar", + "filename": "yacl-3.3.2+1.20.1.jar", + "size": 8192, + "primary": true + } + ], + "dependencies": [] + } +]"#; + +/// 扇入的根：两个 required 分支。 +pub(super) const FANIN_ROOT: &str = r#"[ + { + "id": "ver-root", + "project_id": "ROOT0001", + "name": "Fan-in Root 1.0", + "version_number": "1.0", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "files": [ + { + "hashes": {"sha1": "6666666666666666666666666666666666666666", "sha512": "ff"}, + "url": "https://cdn.modrinth.com/data/ROOT0001/versions/ver-root/fanin-root-1.0.jar", + "filename": "fanin-root-1.0.jar", + "size": 1024, + "primary": true + } + ], + "dependencies": [ + {"project_id": "BRANCHAA", "dependency_type": "required"}, + {"project_id": "BRANCHBB", "dependency_type": "required"} + ] + } +]"#; + +/// 分支 A：也要 `shared-lib`。 +pub(super) const FANIN_A: &str = r#"[ + { + "id": "ver-branch-a", + "project_id": "BRANCHAA", + "name": "Branch A 2.0", + "version_number": "2.0", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "files": [ + { + "hashes": {"sha1": "7777777777777777777777777777777777777777", "sha512": "ab"}, + "url": "https://cdn.modrinth.com/data/BRANCHAA/versions/ver-branch-a/branch-a-2.0.jar", + "filename": "branch-a-2.0.jar", + "size": 1024, + "primary": true + } + ], + "dependencies": [ + {"project_id": "SHARED01", "dependency_type": "required"} + ] + } +]"#; + +/// 分支 B：也要 `shared-lib`（同一项目两条路径 ⇒ 只装一次）。 +pub(super) const FANIN_B: &str = r#"[ + { + "id": "ver-branch-b", + "project_id": "BRANCHBB", + "name": "Branch B 3.0", + "version_number": "3.0", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "files": [ + { + "hashes": {"sha1": "8888888888888888888888888888888888888888", "sha512": "ac"}, + "url": "https://cdn.modrinth.com/data/BRANCHBB/versions/ver-branch-b/branch-b-3.0.jar", + "filename": "branch-b-3.0.jar", + "size": 1024, + "primary": true + } + ], + "dependencies": [ + {"project_id": "SHARED01", "dependency_type": "required"} + ] + } +]"#; + +/// 扇入的公共前置。 +pub(super) const SHARED_LIB: &str = r#"[ + { + "id": "ver-shared", + "project_id": "SHARED01", + "name": "Shared Lib 1.5", + "version_number": "1.5", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "files": [ + { + "hashes": {"sha1": "9999999999999999999999999999999999999999", "sha512": "ad"}, + "url": "https://cdn.modrinth.com/data/SHARED01/versions/ver-shared/shared-lib-1.5.jar", + "filename": "shared-lib-1.5.jar", + "size": 2048, + "primary": true + } + ], + "dependencies": [] + } +]"#; + +/// 环的一端：`cycle-a` 要求 `cycle-b`。 +pub(super) const CYCLE_A: &str = r#"[ + { + "id": "ver-cycle-a", + "project_id": "cycAid01", + "name": "Cycle A 1.0", + "version_number": "1.0", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "files": [ + { + "hashes": {"sha1": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "sha512": "a1"}, + "url": "https://cdn.modrinth.com/data/cycAid01/versions/ver-cycle-a/cycle-a-1.0.jar", + "filename": "cycle-a-1.0.jar", + "size": 1024, + "primary": true + } + ], + "dependencies": [ + {"project_id": "cycBid01", "dependency_type": "required"} + ] + } +]"#; + +/// 环的另一端：`cycle-b` 又要求 `cycle-a`（不设防就是无限递归）。 +pub(super) const CYCLE_B: &str = r#"[ + { + "id": "ver-cycle-b", + "project_id": "cycBid01", + "name": "Cycle B 1.0", + "version_number": "1.0", + "version_type": "release", + "loaders": ["fabric"], + "game_versions": ["1.20.1"], + "files": [ + { + "hashes": {"sha1": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "sha512": "b1"}, + "url": "https://cdn.modrinth.com/data/cycBid01/versions/ver-cycle-b/cycle-b-1.0.jar", + "filename": "cycle-b-1.0.jar", + "size": 1024, + "primary": true + } + ], + "dependencies": [ + {"project_id": "cycAid01", "dependency_type": "required"} + ] + } +]"#; + +/// 光影检索的一页：`categories` 里是 `iris` / `optifine`（光影的加载器）。 +pub(super) const SEARCH_SHADER: &str = r#"{ + "hits": [ + { + "project_id": "shader01", + "project_type": "shader", + "slug": "complementary-reimagined", + "author": "EminGT", + "title": "Complementary Reimagined", + "description": "A shader pack", + "categories": ["iris", "optifine", "shaders"], + "versions": ["1.20.1"], + "downloads": 1234567, + "follows": 4242, + "icon_url": "", + "date_modified": "2026-01-02T03:04:05Z" + } + ], + "offset": 0, + "limit": 1, + "total_hits": 1 +}"#; diff --git a/crates/core/src/addon/online/tests/mod.rs b/crates/core/src/addon/online/tests/mod.rs index f2509a1..24c2c8d 100644 --- a/crates/core/src/addon/online/tests/mod.rs +++ b/crates/core/src/addon/online/tests/mod.rs @@ -8,6 +8,8 @@ mod api; mod classify; +mod dependency; mod download; mod fixtures; +mod fixtures_deps; mod support; diff --git a/crates/presenter/src/host/addon.rs b/crates/presenter/src/host/addon.rs index be2e7c4..24246ab 100644 --- a/crates/presenter/src/host/addon.rs +++ b/crates/presenter/src/host/addon.rs @@ -24,7 +24,8 @@ //! |---|---| //! | [`sources`] | 两个站点的 JSON 方言 → [`crate::dto::ContentHit`] | //! | `http` | 取文本：无 header 走引擎、带 header 走 client + 退避、百分号编码 | -//! | `install` | 一键装入：解析文件 → 下载到实例目录 → 进度回流 | +//! | [`install`] | 一键装入：解析文件（含 `required` 前置）→ 下载到实例目录 → 进度回流 | +//! | [`plan`] | 依赖计划的宿主侧：扫目录、两档失败 → DTO 大类、人读文案 | //! //! ## 整合包与 CF 的边界（都写进报告） //! @@ -34,6 +35,7 @@ mod http; mod install; +mod plan; // M113: import/export —— 整合包导入/导出（拆成子目录：父文件只留既有内容 + mod） mod pack; mod sources; diff --git a/crates/presenter/src/host/addon/install.rs b/crates/presenter/src/host/addon/install.rs index e71388d..6f0a4e9 100644 --- a/crates/presenter/src/host/addon/install.rs +++ b/crates/presenter/src/host/addon/install.rs @@ -1,19 +1,33 @@ -//! 「一键装入指定实例」（M109）。 +//! 「一键装入指定实例」（M109；M186 起把前置一起装上）。 //! //! ## 网络只走 code 的在线内容源（M162 r1） //! -//! 解析「哪个文件」用 `core::addon::online::Modrinth::versions`（同一个引擎传输层 ⇒ 信号量、 -//! 源健康度、退避都在引擎里），下载用 `online::download_verified`（sha1 + sha512 双检）。 -//! 本文件**不再**自己拼 `api.modrinth.com` 的 URL，也不再自己 `serde_json::from_str`。 +//! 解析「哪个文件」用 `core::addon::online`（同一个引擎传输层 ⇒ 信号量、源健康度、退避都在 +//! 引擎里），下载用 `online::download_verified`（sha1 + sha512 双检）。本文件**不再**自己拼 +//! `api.modrinth.com` 的 URL，也不再自己 `serde_json::from_str`。 //! //! ## 它到底做了什么（诚实版） //! //! | 内容类型 | 做什么 | 状态 | //! |---|---|---| -//! | Mod / 资源包 / 光影 | 解析「该项目下匹配目标实例（版本 + 加载器）的那个文件」→ core 下载引擎下载到实例运行目录的 `mods/` `resourcepacks/` `shaderpacks/` → 进度经 `InstallProgressView` 回流（**复用下载页那块面板**） | 已接 | +//! | Mod / 资源包 / 光影 | 解析「该项目 + 它的 `required` 前置」在目标实例（版本 + 加载器）下的文件 → core 下载引擎下到 `mods/` `resourcepacks/` `shaderpacks/` → 进度经 `InstallProgressView` 回流 | 已接（M186 起含前置） | //! | 整合包 | 一律 `Failed` + 一句原因 | **未做**：core 没有「远程整合包装进实例」的管线（M111） | //! | CurseForge 文件解析 | 一律 `Failed` + 一句原因 | **未做**：需要带 key 的文件端点，本轮只做了 CF 的**检索** | //! +//! ## 前置的两档失败与重试名单（M186） +//! +//! 解析在 [`super::plan`] + `core::addon::online::resolve`：某个前置「不兼容所选版本/加载器」 +//! 与「取不到（网络 / 项目不存在）」是**两条**记录，本文件把两档分开写进失败文案，并把失败项 +//! 列成「可只重试这 N 个」。**这不是自动重试**：重试要用户（或将来 UI 的按钮）再发一次， +//! `DependencyPlan::retry_request()` 已经把请求备好了。 +//! +//! ## 光影与数据包：支持到哪一步（M186 核对过，别写成「都支持」） +//! +//! | 内容 | 检索 | 装入 | 差在哪 | +//! |---|---|---|---| +//! | 光影 | 支持（`project_type:shader`）；命中项的加载器标签现在认得 `iris` / `optifine`（`KNOWN_LOADERS`） | 支持（落 `shaderpacks/`） | 加载器**过滤**仍筛不了：`LoaderKind::OptiFine` 没有 facet（`loader_facet` 返回 `None`），所以「只看 Iris 光影」只能靠标签目测 | +//! | 数据包 | core 的 `ContentType::Datapack` 有 `datapack` facet | **不支持** | DTO 的 `ContentKind` 没有这一项；数据包还要落到「某个世界的 `datapacks/`」，现在没有选择世界这一步 | +//! //! ## 为什么进度只有阶段级，没有字节条 //! //! 字节级进度要走 `ProgressEmitter`（core 的 tokio 广播），而 presenter 的依赖表里没有 @@ -26,7 +40,7 @@ use std::path::PathBuf; use std::sync::atomic::{AtomicBool, Ordering}; use unlucky_core::addon::online::{ - download_verified, EngineArtifactFetcher, EngineTransport, Modrinth, VersionQuery, + download_verified, resolve, EngineArtifactFetcher, EngineTransport, Modrinth, PlannedNode, }; use unlucky_core::download::blocking::block_on; use unlucky_core::game::install::instance::read_instance_config; @@ -39,7 +53,7 @@ use crate::dto::{ use super::super::env::HostEnv; use super::super::job::{HostTask, JobSender}; -use super::sources::failure_of; +use super::{plan, sources::failure_of}; /// 跑一次装入（同步；由 [`super::spawn_install`] 放进后台线程）。 pub(super) fn install( @@ -112,7 +126,10 @@ fn fail(tx: &JobSender, mut progress: InstallProgressView, failure: ContentFailu }); } -/// 真正干活的那一段，返回一句人读的落盘描述（失败带**大类**，离线不等同于「查无此项」）。 +/// 真正干活的那一段：解析（含前置）→ 逐个下载 → 汇总。 +/// +/// 返回「装了哪些 / 跳过了哪些」的人读描述；解析阶段的两档失败由 +/// [`plan::failure_of_plan`] 变成一条带大类的失败（**前置缺了不算装成**）。 fn run( env: &HostEnv, request: &ContentInstallRequest, @@ -130,33 +147,90 @@ fn run( let target_dir = game_dir.join(dir); std::fs::create_dir_all(&target_dir) .map_err(|error| local(format!("建目录 {} 失败：{error}", target_dir.display())))?; - - let file = resolve_file(env, request)?; - if cancel.load(Ordering::SeqCst) { - return Err(local("已取消（下载开始前）")); + if request.source != ContentSource::Modrinth { + return Err(ContentFailure::unsupported( + "CurseForge 的文件解析未接通（要带 key 的文件端点；见报告「没验的部分」）", + )); } + + // 解析：根项目 + 只跟 `required` 的前置（顺序与父子关系由 core 给，这里不重排）。 + let resolve_request = plan::request( + &request.project, + &request.game_version, + loader_facet(request.loader), + plan::present_files(&target_dir), + ); + let core_engine = super::super::engine::engine(env); + let dependency_plan = { + let transport = EngineTransport::new(&core_engine); + let client = Modrinth::new(&transport); + block_on(resolve(&client, &resolve_request)) + }; + progress.stage = InstallStage::Downloading; - progress.message = file.name.clone(); + progress.files_total = dependency_plan.nodes.len() as u64; + progress.files_done = 0; + progress.message = if dependency_plan.nodes.is_empty() { + "没有要下载的文件".to_string() + } else { + format!( + "{} 个文件（含 {} 个前置）", + dependency_plan.nodes.len(), + dependency_plan + .nodes + .iter() + .filter(|node| !node.is_root()) + .count() + ) + }; let _ = tx.send(HostTask::Install { progress: Box::new(progress.clone()), epoch, }); - let dest = target_dir.join(&file.name); - // M162：走 `online::download_verified`——sha1 交给引擎流式校验、sha512 落盘后复核， - // 失败重试且不留半截文件（内容库安装与整合包导入用**同一段**校验，不各写一份）。 - let core_engine = super::super::engine::engine(env); let fetcher = EngineArtifactFetcher::new(&core_engine); - block_on(download_verified( - &fetcher, - &file.url, - file.sha1.as_deref(), - file.sha512.as_deref(), - file.size, - &dest, - )) - .map_err(failure_of)?; - Ok(format!("{}（{}）", file.name, dest.display())) + for node in &dependency_plan.nodes { + if cancel.load(Ordering::SeqCst) { + return Err(local("已取消（下载中途）")); + } + progress.message = node_label(node); + let _ = tx.send(HostTask::Install { + progress: Box::new(progress.clone()), + epoch, + }); + // M162：走 `online::download_verified`——sha1 交给引擎流式校验、sha512 落盘后复核， + // 失败重试且不留半截文件（内容库安装与整合包导入用**同一段**校验，不各写一份）。 + let dest = target_dir.join(safe_file_name(&node.file.filename)); + block_on(download_verified( + &fetcher, + &node.file.url, + node.file.sha1(), + node.file.sha512(), + (node.file.size > 0).then_some(node.file.size), + &dest, + )) + .map_err(failure_of)?; + progress.files_done += 1; + let _ = tx.send(HostTask::Install { + progress: Box::new(progress.clone()), + epoch, + }); + } + + // 解析阶段的失败在这里收口：两档分成两句话（不合并成「下载失败」），并列出可只重试的项目。 + if let Some(failure) = plan::failure_of_plan(&dependency_plan) { + return Err(failure); + } + Ok(plan::summary(&dependency_plan)) +} + +/// 进度面板上的那一行文件名（前置标出来，用户才知道多出来的文件是什么）。 +fn node_label(node: &PlannedNode) -> String { + if node.is_root() { + node.file.filename.clone() + } else { + format!("{}（前置）", node.file.filename) + } } /// 本地失败（找实例 / 建目录 / 取消）——不是网络问题，归到 `Other`。 @@ -187,69 +261,6 @@ fn game_dir_of(env: &HostEnv, instance: &InstanceSummary) -> Result, - sha512: Option, - size: Option, -} - -/// 解析「这个项目下最适合目标实例的那个文件」。 -fn resolve_file( - env: &HostEnv, - request: &ContentInstallRequest, -) -> Result { - match request.source { - ContentSource::Modrinth => modrinth_file(env, request), - ContentSource::Curseforge => Err(ContentFailure::unsupported( - "CurseForge 的文件解析未接通（要带 key 的文件端点；见报告「没验的部分」）", - )), - } -} - -/// 版本列表 → 目标文件：走 core 的在线内容源（**本文件不再拼 URL、不再自己解析 JSON**）。 -/// -/// 选 `primary: true` 的那个（Modrinth 官方口径）：直接取第一个会拿到 `sources.jar` 这类坑， -/// `Version::primary_file()` 就是为这件事存在的。 -fn modrinth_file( - env: &HostEnv, - request: &ContentInstallRequest, -) -> Result { - let core_engine = super::super::engine::engine(env); - let transport = EngineTransport::new(&core_engine); - let client = Modrinth::new(&transport); - let versions = block_on(client.versions(&VersionQuery { - project: request.project.clone(), - game_version: Some(request.game_version.clone()), - loader: loader_facet(request.loader).map(str::to_string), - })) - .map_err(failure_of)?; - let version = versions.first().ok_or_else(|| { - ContentFailure::new( - ContentFailureKind::NotFound, - "这个项目没有匹配目标实例（版本 / 加载器）的文件", - ) - })?; - let file = version - .primary_file() - .ok_or_else(|| ContentFailure::new(ContentFailureKind::NotFound, "版本里没有可用文件"))?; - if file.url.trim().is_empty() { - return Err(ContentFailure::new( - ContentFailureKind::Unsupported, - "版本里的主文件没有下载地址", - )); - } - Ok(RemoteFile { - url: file.url.clone(), - name: safe_file_name(&file.filename), - sha1: file.sha1().map(ToString::to_string), - sha512: file.sha512().map(ToString::to_string), - size: (file.size > 0).then_some(file.size), - }) -} - /// 只留文件名本身：站点给的名字可能带路径分隔符，落盘前必须砍掉 /// （与 `core::addon::pack::path` 的穿越双检同一条纪律）。 pub(super) fn safe_file_name(raw: &str) -> String { diff --git a/crates/presenter/src/host/addon/plan.rs b/crates/presenter/src/host/addon/plan.rs new file mode 100644 index 0000000..296e7fc --- /dev/null +++ b/crates/presenter/src/host/addon/plan.rs @@ -0,0 +1,218 @@ +//! 依赖计划的**宿主侧那一半**：扫目录、把两档失败映成 DTO 大类、拼给用户看的那句话。 +//! +//! # 为什么判定在 core、说话在 presenter +//! +//! 「哪个前置不兼容、哪个前置取不到」由 `unlucky_core::addon::online::resolve` 判定并可离线 +//! 测试（录制 JSON 夹具）。本文件只做三件宿主才知道的事： +//! +//! | 事 | 为什么只能在这里 | +//! |---|---| +//! | 目标目录里有什么 | core 不读盘（`PresentFile` 由调用方扫） | +//! | 失败大类怎么映 | DTO 在 presenter（`ContentFailureKind`） | +//! | 文案怎么说 | 界面文案不归 core | +//! +//! # 两档失败**分开说** +//! +//! 「不兼容所选版本/加载器」与「取不到（网络 / 项目不存在）」是两句话、两种用户动作， +//! 所以这里既不合并计数也不合并文案；DTO 大类按「用户接下来该做什么」选：离线优先说 +//! 检查网络，其次查无此项，只有**全是**不兼容时才说「这条路走不通」（换版本/加载器才有救）。 + +use std::path::Path; + +use unlucky_core::addon::online::{ + DependencyFailure, DependencyPlan, FailureKind, OnlineError, PresentFile, ResolveRequest, +}; + +use crate::dto::ContentFailureKind; + +use super::sources::failure_of; + +/// 扫目标目录（不递归）里已存在的文件名。 +/// +/// 只给名字，不算摘要：为了「跳过」把整个 `mods/` 哈希一遍不划算，同名就是同一份 jar 的 +/// 最常见形态（我们落盘用站点给的文件名，不重命名）。 +pub(super) fn present_files(dir: &Path) -> Vec { + let Ok(entries) = std::fs::read_dir(dir) else { + return Vec::new(); + }; + entries + .flatten() + .filter(|entry| entry.path().is_file()) + .map(|entry| PresentFile::new(entry.file_name().to_string_lossy())) + .collect() +} + +/// 一次装入要用的解析请求（过滤条件与落盘目录一致）。 +pub(super) fn request( + project: &str, + game_version: &str, + loader: Option<&str>, + present: Vec, +) -> ResolveRequest { + ResolveRequest { + roots: vec![project.to_string()], + game_version: Some(game_version.to_string()), + loader: loader.map(str::to_string), + present, + ..ResolveRequest::default() + } +} + +/// 计划里有失败吗 ⇒ 一条带大类的失败（`None` = 干净）。 +pub(super) fn failure_of_plan(plan: &DependencyPlan) -> Option { + if plan.is_clean() { + return None; + } + Some(crate::dto::ContentFailure::new( + overall_kind(plan), + report(plan), + )) +} + +/// 整体大类：按「用户接下来该做什么」排序，离线 > 查无此项 > 站点错 > 其它 > 不兼容。 +fn overall_kind(plan: &DependencyPlan) -> ContentFailureKind { + let kinds: Vec = plan.failures.iter().map(kind_of).collect(); + for wanted in [ + ContentFailureKind::Offline, + ContentFailureKind::NotFound, + ContentFailureKind::Server, + ContentFailureKind::Other, + ContentFailureKind::Unsupported, + ] { + if kinds.contains(&wanted) { + return wanted; + } + } + ContentFailureKind::Unsupported +} + +/// 单条失败的 DTO 大类（**复用** `sources::failure_of` 的映射表，不另写一份判据）。 +fn kind_of(failure: &DependencyFailure) -> ContentFailureKind { + match failure.cause { + Some(cause) => failure_of(OnlineError::new(cause, failure.message.clone())).kind, + // 不兼容那一档没有网络成因：它要用户换版本/加载器，不是「再试一次」 + None => ContentFailureKind::Unsupported, + } +} + +/// 失败清单（两档各起一段，各自的条数分开数）。 +fn report(plan: &DependencyPlan) -> String { + let mut lines: Vec = Vec::new(); + let incompatible: Vec = plan + .failures_of(FailureKind::Incompatible) + .map(describe) + .collect(); + let unreachable: Vec = plan + .failures_of(FailureKind::Unreachable) + .map(describe) + .collect(); + if !incompatible.is_empty() { + lines.push(format!( + "不兼容所选版本/加载器 {} 个：{}", + incompatible.len(), + incompatible.join("；") + )); + } + if !unreachable.is_empty() { + lines.push(format!( + "取不到（网络 / 项目不存在）{} 个：{}", + unreachable.len(), + unreachable.join("；") + )); + } + if !plan.nodes.is_empty() { + lines.push(format!("已装入 {} 个文件", plan.nodes.len())); + } + if !plan.skipped.is_empty() { + lines.push(format!("跳过 {} 个已存在的文件", plan.skipped.len())); + } + if !plan.truncated.is_empty() { + lines.push(format!( + "依赖层数超过上限，未展开：{}", + plan.truncated.join("、") + )); + } + // 可重试名单：只列失败项（重试时也只重解这些，不重下已装好的） + let retry: Vec<&str> = plan + .failures + .iter() + .map(|failure| failure.requested_as.as_str()) + .collect(); + if !retry.is_empty() { + lines.push(format!( + "可只重试这 {} 个：{}", + retry.len(), + retry.join("、") + )); + } + lines.join("\n") +} + +fn describe(failure: &DependencyFailure) -> String { + if failure.required_by.is_empty() { + format!("{}（{}）", failure.requested_as, failure.message) + } else { + format!( + "{}（{}；被 {} 要求）", + failure.requested_as, + failure.message, + failure.required_by.join("、") + ) + } +} + +/// 全部装成之后的落盘描述（含跳过与前置的条数、「为什么装」的父项目）。 +pub(super) fn summary(plan: &DependencyPlan) -> String { + if plan.nodes.is_empty() && plan.skipped.is_empty() { + return "没有要装的文件".to_string(); + } + let mut parts: Vec = Vec::new(); + if !plan.nodes.is_empty() { + let dependencies = plan.nodes.iter().filter(|node| !node.is_root()).count(); + // 「为什么装」：前置标出要求它的项目（根是用户自己点的，不标） + let names: Vec = plan + .nodes + .iter() + .map(|node| { + if node.is_root() { + node.file.filename.clone() + } else { + format!( + "{}（前置，被 {} 要求）", + node.file.filename, + node.required_by.join("、") + ) + } + }) + .collect(); + let head = if dependencies == 0 { + format!("装了 {} 个文件", plan.nodes.len()) + } else { + format!( + "装了 {} 个文件（含 {} 个前置）", + plan.nodes.len(), + dependencies + ) + }; + parts.push(format!("{head}：{}", names.join("、"))); + } + if !plan.skipped.is_empty() { + let names: Vec<&str> = plan + .skipped + .iter() + .map(|node| node.file_name.as_str()) + .collect(); + parts.push(format!( + "跳过 {} 个（目录里已存在，没有重复下载）：{}", + plan.skipped.len(), + names.join("、") + )); + } + if !plan.truncated.is_empty() { + parts.push(format!( + "依赖层数超过上限，未展开：{}", + plan.truncated.join("、") + )); + } + parts.join("\n") +} diff --git a/crates/presenter/src/host/addon/tests.rs b/crates/presenter/src/host/addon/tests.rs index 3c29d1e..1fe9bb9 100644 --- a/crates/presenter/src/host/addon/tests.rs +++ b/crates/presenter/src/host/addon/tests.rs @@ -115,3 +115,190 @@ fn core_errors_map_to_dto_failure_kinds() { "connect timed out" ); } + +// ------------------------------------------------ M186：前置解析的两档失败与可重试名单 + +use super::plan::{failure_of_plan, summary}; +use unlucky_core::addon::online::{ + DependencyFailure, DependencyPlan, FailureKind, PlannedNode, ResolveRequest, SkipReason, + SkippedNode, VersionFile, +}; + +fn node(project: &str, file: &str, depth: u8, required_by: &[&str]) -> PlannedNode { + PlannedNode { + project: project.to_string(), + requested_as: project.to_string(), + version_id: format!("ver-{project}"), + version_name: project.to_string(), + version_number: "1.0".to_string(), + file: VersionFile { + url: format!("https://cdn.modrinth.com/data/{project}/1.0/{file}"), + filename: file.to_string(), + size: 1024, + ..VersionFile::default() + }, + depth, + required_by: required_by + .iter() + .map(|parent| (*parent).to_string()) + .collect(), + } +} + +fn failure( + project: &str, + kind: FailureKind, + cause: Option, + message: &str, +) -> DependencyFailure { + DependencyFailure { + requested_as: project.to_string(), + required_by: vec!["AANobbMI".to_string()], + depth: 1, + kind, + cause, + message: message.to_string(), + } +} + +fn plan( + failures: Vec, + nodes: Vec, + skipped: Vec, +) -> DependencyPlan { + DependencyPlan { + request: ResolveRequest::single("sodium"), + nodes, + skipped, + failures, + truncated: Vec::new(), + } +} + +/// 全是「不兼容」时：说换版本/加载器，而不是「下载失败」，并且照样给重试名单。 +#[test] +fn an_incompatible_only_plan_is_not_reported_as_a_download_failure() { + let plan = plan( + vec![failure( + "P7dR8mSH", + FailureKind::Incompatible, + None, + "没有匹配所选游戏版本/加载器（1.20.1 / fabric）的版本", + )], + vec![node("AANobbMI", "sodium.jar", 0, &[])], + Vec::new(), + ); + let failure = failure_of_plan(&plan).expect("有失败就该给一条"); + assert_eq!(failure.kind, ContentFailureKind::Unsupported); + assert!(failure.detail.contains("不兼容所选版本/加载器 1 个")); + assert!(failure.detail.contains("可只重试这 1 个：P7dR8mSH")); + assert!(!failure.detail.contains("下载失败"), "{}", failure.detail); + assert!( + !failure.detail.contains("取不到"), + "两档不许混：{}", + failure.detail + ); +} + +/// 两档同时出现时：两段都写，大类按「用户接下来该做什么」选（查无此项 > 不兼容）。 +#[test] +fn a_mixed_plan_keeps_both_buckets_and_picks_the_actionable_kind() { + let plan = plan( + vec![ + failure( + "P7dR8mSH", + FailureKind::Incompatible, + None, + "没有匹配的版本", + ), + failure( + "1eAoo2KR", + FailureKind::Unreachable, + Some(OnlineErrorKind::NotFound), + "取版本失败（online_not_found）：HTTP 404", + ), + ], + Vec::new(), + Vec::new(), + ); + let failure = failure_of_plan(&plan).expect("有失败就该给一条"); + assert_eq!(failure.kind, ContentFailureKind::NotFound); + assert!(failure.detail.contains("不兼容所选版本/加载器 1 个")); + assert!(failure.detail.contains("取不到（网络 / 项目不存在）1 个")); + assert!(failure.detail.contains("可只重试这 2 个")); +} + +/// 没网那一档：大类是离线（页面据此画「检查网络」而不是「换个关键词」）。 +#[test] +fn an_offline_jump_wins_over_everything_else() { + let plan = plan( + vec![ + failure( + "P7dR8mSH", + FailureKind::Incompatible, + None, + "没有匹配的版本", + ), + failure( + "1eAoo2KR", + FailureKind::Unreachable, + Some(OnlineErrorKind::NotConnected), + "连不上 api.modrinth.com", + ), + ], + Vec::new(), + Vec::new(), + ); + let failure = failure_of_plan(&plan).expect("有失败就该给一条"); + assert_eq!(failure.kind, ContentFailureKind::Offline); + assert!(failure.is_offline()); +} + +/// 全装成的那句话要点出「含 N 个前置」与「跳过 M 个已存在」。 +#[test] +fn the_success_message_counts_dependencies_and_skipped_files() { + let plan = plan( + Vec::new(), + vec![ + node("AANobbMI", "sodium.jar", 0, &[]), + node("P7dR8mSH", "fabric-api.jar", 1, &["AANobbMI"]), + ], + vec![SkippedNode { + project: "1eAoo2KR".to_string(), + requested_as: "1eAoo2KR".to_string(), + file_name: "yacl.jar".to_string(), + depth: 2, + required_by: vec!["P7dR8mSH".to_string()], + reason: SkipReason::AlreadyPresent, + }], + ); + assert!(failure_of_plan(&plan).is_none()); + let message = summary(&plan); + assert!( + message.contains("装了 2 个文件（含 1 个前置）"), + "{message}" + ); + // 「为什么装」：前置那句要带出要求它的项目 + assert!( + message.contains("fabric-api.jar（前置，被 AANobbMI 要求）"), + "{message}" + ); + assert!(message.contains("跳过 1 个（目录里已存在，没有重复下载）：yacl.jar")); +} + +/// 扫目录只认文件、不认子目录（子目录不是 jar，混进来会让去重误判）。 +#[test] +fn present_files_lists_only_files_in_the_target_directory() { + let dir = std::env::temp_dir().join(format!("ull-m186-present-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(dir.join("nested")).expect("建临时目录"); + std::fs::write(dir.join("sodium.jar"), b"x").expect("写文件"); + std::fs::write(dir.join("yacl.jar.disabled"), b"x").expect("写文件"); + let mut names: Vec = super::plan::present_files(&dir) + .into_iter() + .map(|file| file.name) + .collect(); + names.sort(); + assert_eq!(names, ["sodium.jar", "yacl.jar.disabled"]); + let _ = std::fs::remove_dir_all(&dir); +}