1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
//! Support for `type: composer` repositories.
//!
//! A Composer repository is a directory (or HTTP endpoint) hosting a
//! `packages.json` file. The legacy format embeds full package metadata
//! directly:
//!
//! ```json
//! {
//! "packages": {
//! "a/a": {
//! "dev-foobar": { "name": "a/a", "version": "dev-foobar", ... }
//! }
//! }
//! }
//! ```
//!
//! Mirrors `Composer\Repository\ComposerRepository` for the file:// case
//! used by the test fixtures. Lazy / v2 / provider-includes / metadata-url
//! variants are out of scope here — the in-process installer fixtures only
//! exercise the legacy embedded-packages form.
use super::packagist::PackagistVersion;
use super::repository_filter::RepositoryFilter;
use crate::package::RawRepository;
use indexmap::IndexSet;
use std::path::PathBuf;
/// One package version drawn from a `type: composer` repository.
pub struct ComposerRepoPackage {
pub name: String,
pub version: PackagistVersion,
}
/// Read every package version from `type: composer` repositories declared in
/// `composer.json`. Only `file://` URLs are supported here — they're what
/// the installer fixtures use after the harness rewrites
/// `file://foobar` → `file:///abs/path/to/fixtures/foobar`.
pub fn collect_composer_packages(repositories: &[RawRepository]) -> Vec<ComposerRepoPackage> {
let mut out = Vec::new();
let mut claimed: IndexSet<String> = IndexSet::new();
for repo in repositories {
if repo.repo_type != "composer" {
continue;
}
let Some(url) = repo.url.as_deref() else {
continue;
};
let Some(dir) = file_url_to_path(url) else {
continue;
};
let packages_json = dir.join("packages.json");
let Ok(content) = std::fs::read_to_string(&packages_json) else {
continue;
};
let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&content) else {
continue;
};
let Some(packages) = parsed.get("packages").and_then(|v| v.as_object()) else {
continue;
};
let filter = RepositoryFilter::from_repo(repo);
let mut names_this_repo: IndexSet<String> = IndexSet::new();
for (name, versions) in packages {
if !filter.is_allowed(name) {
continue;
}
if claimed.contains(name) {
continue;
}
let Some(versions_obj) = versions.as_object() else {
continue;
};
let mut emitted = false;
for (_, version_value) in versions_obj {
if let Ok(pv) = serde_json::from_value::<PackagistVersion>(version_value.clone()) {
out.push(ComposerRepoPackage {
name: name.clone(),
version: pv,
});
emitted = true;
}
}
if emitted {
names_this_repo.insert(name.clone());
}
}
if filter.canonical {
claimed.extend(names_this_repo);
}
}
out
}
/// Turn a `file://` URL into a filesystem path. Accepts both
/// `file:///abs/path` (RFC 8089 form) and `file://abs/path` (Composer's
/// loose form). Returns `None` for non-`file://` URLs.
fn file_url_to_path(url: &str) -> Option<PathBuf> {
let rest = url.strip_prefix("file://")?;
// RFC 8089: file:///abs/path → empty authority, rest starts with `/`.
// Composer's harness writes `file:///abs/...` after rewriting, so the
// typical input here is one leading `/`.
Some(PathBuf::from(rest))
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile::TempDir;
fn write_packages_json(dir: &std::path::Path, body: &str) {
fs::write(dir.join("packages.json"), body).unwrap();
}
fn composer_repo(url: String) -> RawRepository {
RawRepository {
repo_type: "composer".to_string(),
url: Some(url),
package: None,
only: None,
exclude: None,
canonical: None,
security_advisories: None,
}
}
#[test]
fn reads_legacy_packages_json() {
let tmp = TempDir::new().unwrap();
write_packages_json(
tmp.path(),
r#"{
"packages": {
"a/a": {
"dev-foobar": {
"name": "a/a",
"version": "dev-foobar",
"version_normalized": "dev-foobar"
}
}
}
}"#,
);
let url = format!("file://{}", tmp.path().display());
let repos = vec![composer_repo(url)];
let pkgs = collect_composer_packages(&repos);
assert_eq!(pkgs.len(), 1);
assert_eq!(pkgs[0].name, "a/a");
assert_eq!(pkgs[0].version.version, "dev-foobar");
}
#[test]
fn ignores_non_composer_types() {
let repos = vec![RawRepository {
repo_type: "vcs".to_string(),
url: Some("https://example.com/foo.git".to_string()),
package: None,
only: None,
exclude: None,
canonical: None,
security_advisories: None,
}];
assert!(collect_composer_packages(&repos).is_empty());
}
#[test]
fn skips_missing_packages_json() {
let tmp = TempDir::new().unwrap();
let url = format!("file://{}", tmp.path().display());
let repos = vec![composer_repo(url)];
assert!(collect_composer_packages(&repos).is_empty());
}
}
|
