Debian Codegraph @

.cargo/vendor/built/src/dependencies.rs

raw
1 use crate::util::TupleArrayDisplay;
2 use crate::{write_str_variable, write_variable};
3 use std::{collections, fs, io, path};
4
5 fn package_names<'a, I>(packages: I) -> Vec<(String, String)>
6 where
7 I: IntoIterator<Item = &'a cargo_lock::Package>,
8 {
9 let mut res = packages
10 .into_iter()
11 .map(|package| (package.name.to_string(), package.version.to_string()))
12 .collect::<collections::HashSet<_>>()
13 .into_iter()
14 .collect::<Vec<_>>();
15 res.sort_unstable();
16 res
17 }
18
19 fn find_lockfile(base: &path::Path) -> io::Result<path::PathBuf> {
20 base.ancestors()
21 .find_map(|p| {
22 let lockfile = p.join("Cargo.lock");
23 lockfile.exists().then(|| lockfile.to_owned())
24 })
25 .ok_or(io::Error::other("Cargo.lock not found"))
26 }
27
28 #[cfg(feature = "dependency-tree")]
29 struct Dependencies {
30 deps: Vec<(String, String)>,
31 direct_deps: Vec<(String, String)>,
32 indirect_deps: Vec<(String, String)>,
33 }
34
35 #[cfg(feature = "dependency-tree")]
36 impl Dependencies {
37 fn new(lockfile: &cargo_lock::Lockfile) -> Self {
38 use cargo_lock::dependency::graph::EdgeDirection;
39
40 let tree = lockfile
41 .dependency_tree()
42 .expect("properly formed lockfile");
43 let graph = tree.graph();
44
45 let root_pkg_idx = graph
46 .externals(EdgeDirection::Incoming)
47 .collect::<collections::HashSet<_>>();
48 let deps = package_names(graph.node_indices().filter_map(|idx| {
49 if root_pkg_idx.contains(&idx) {
50 None
51 } else {
52 Some(&graph[idx])
53 }
54 }));
55 let direct_deps_idx = root_pkg_idx
56 .iter()
57 .flat_map(|idx| graph.neighbors_directed(*idx, EdgeDirection::Outgoing))
58 .collect::<collections::HashSet<_>>();
59 let direct_deps = package_names(direct_deps_idx.iter().map(|dep_idx| &graph[*dep_idx]));
60 let indirect_deps = package_names(graph.node_indices().filter_map(|idx| {
61 if root_pkg_idx.contains(&idx) | direct_deps_idx.contains(&idx) {
62 None
63 } else {
64 Some(&graph[idx])
65 }
66 }));
67
68 Self {
69 deps,
70 direct_deps,
71 indirect_deps,
72 }
73 }
74 }
75
76 #[cfg(feature = "dependency-tree")]
77 pub fn write_dependencies(manifest_location: &path::Path, mut w: &fs::File) -> io::Result<()> {
78 use io::{Read, Write};
79
80 let mut lock_buf = String::new();
81 fs::File::open(find_lockfile(manifest_location)?)?.read_to_string(&mut lock_buf)?;
82 let lockfile = lock_buf.parse().expect("Failed to parse lockfile");
83
84 let dependencies = Dependencies::new(&lockfile);
85
86 write_variable!(
87 w,
88 "DEPENDENCIES",
89 format_args!("[(&str, &str); {}]", dependencies.deps.len()),
90 TupleArrayDisplay(&dependencies.deps),
91 "An array of effective dependencies as documented by `Cargo.lock`."
92 );
93 write_str_variable!(
94 w,
95 "DEPENDENCIES_STR",
96 dependencies
97 .deps
98 .iter()
99 .map(|(n, v)| format!("{n} {v}"))
100 .collect::<Vec<_>>()
101 .join(", "),
102 "The effective dependencies as a comma-separated string."
103 );
104
105 write_variable!(
106 w,
107 "DIRECT_DEPENDENCIES",
108 format_args!("[(&str, &str); {}]", dependencies.direct_deps.len()),
109 TupleArrayDisplay(&dependencies.direct_deps),
110 "An array of direct dependencies as documented by `Cargo.lock`."
111 );
112 write_str_variable!(
113 w,
114 "DIRECT_DEPENDENCIES_STR",
115 dependencies
116 .direct_deps
117 .iter()
118 .map(|(n, v)| format!("{n} {v}"))
119 .collect::<Vec<_>>()
120 .join(", "),
121 "The direct dependencies as a comma-separated string."
122 );
123
124 write_variable!(
125 w,
126 "INDIRECT_DEPENDENCIES",
127 format_args!("[(&str, &str); {}]", dependencies.indirect_deps.len()),
128 TupleArrayDisplay(&dependencies.indirect_deps),
129 "An array of indirect dependencies as documented by `Cargo.lock`."
130 );
131 write_str_variable!(
132 w,
133 "INDIRECT_DEPENDENCIES_STR",
134 dependencies
135 .indirect_deps
136 .iter()
137 .map(|(n, v)| format!("{n} {v}"))
138 .collect::<Vec<_>>()
139 .join(", "),
140 "The indirect dependencies as a comma-separated string."
141 );
142
143 Ok(())
144 }
145
146 #[cfg(not(feature = "dependency-tree"))]
147 pub fn write_dependencies(manifest_location: &path::Path, mut w: &fs::File) -> io::Result<()> {
148 use io::{Read, Write};
149
150 let mut lock_buf = String::new();
151 fs::File::open(find_lockfile(manifest_location)?)?.read_to_string(&mut lock_buf)?;
152 let lockfile: cargo_lock::Lockfile = lock_buf.parse().expect("Failed to parse lockfile");
153
154 let deps = package_names(&lockfile.packages);
155
156 write_variable!(
157 w,
158 "DEPENDENCIES",
159 format_args!("[(&str, &str); {}]", deps.len()),
160 TupleArrayDisplay(&deps),
161 "An array of effective dependencies as documented by `Cargo.lock`."
162 );
163 write_str_variable!(
164 w,
165 "DEPENDENCIES_STR",
166 deps.iter()
167 .map(|(n, v)| format!("{n} {v}"))
168 .collect::<Vec<_>>()
169 .join(", "),
170 "The effective dependencies as a comma-separated string."
171 );
172
173 Ok(())
174 }
175
176 #[cfg(test)]
177 mod tests {
178 static LOCK_TOML_BUFFER: &str = r#"
179 # This file is automatically @generated by Cargo.
180 # It is not intended for manual editing.
181 version = 3
182
183 [[package]]
184 name = "foo"
185 version = "0.0.0"
186 source = "registry+https://github.com/rust-lang/crates.io-index"
187 checksum = "f7dbb6acfeff1d490fba693a402456f76b344fea77a5e7cae43b5970c3332b8f"
188
189 [[package]]
190 name = "foobar"
191 version = "0.0.0"
192 source = "registry+https://github.com/rust-lang/crates.io-index"
193 checksum = "d9c0d152c1d2a9673211b9f3c02a4786715ce730dbd5f94f2f895fc0bb9eed63"
194
195 [[package]]
196 name = "memchr"
197 version = "2.6.3"
198 source = "registry+https://github.com/rust-lang/crates.io-index"
199 checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"
200
201 [[package]]
202 name = "minimal-lexical"
203 version = "0.2.1"
204 source = "registry+https://github.com/rust-lang/crates.io-index"
205 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
206
207 [[package]]
208 name = "nom"
209 version = "7.1.3"
210 source = "registry+https://github.com/rust-lang/crates.io-index"
211 checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
212 dependencies = [
213 "memchr",
214 "minimal-lexical",
215 ]
216
217 [[package]]
218 name = "dummy"
219 version = "0.1.0"
220 dependencies = [
221 "foo",
222 "foobar",
223 "nom",
224 ]
225 "#;
226
227 #[test]
228 fn parse_deps() {
229 let lockfile: cargo_lock::Lockfile =
230 LOCK_TOML_BUFFER.parse().expect("Failed to parse lockfile");
231 let deps = super::package_names(&lockfile.packages);
232 assert_eq!(
233 deps,
234 [
235 ("dummy".to_owned(), "0.1.0".to_owned()),
236 ("foo".to_owned(), "0.0.0".to_owned()),
237 ("foobar".to_owned(), "0.0.0".to_owned()),
238 ("memchr".to_owned(), "2.6.3".to_owned()),
239 ("minimal-lexical".to_owned(), "0.2.1".to_owned()),
240 ("nom".to_owned(), "7.1.3".to_owned()),
241 ]
242 );
243 }
244
245 #[test]
246 #[cfg(feature = "dependency-tree")]
247 fn direct_deps() {
248 let lockfile = LOCK_TOML_BUFFER.parse().expect("Failed to parse lockfile");
249 let dependencies = super::Dependencies::new(&lockfile);
250 assert_eq!(
251 dependencies.deps,
252 [
253 ("foo".to_owned(), "0.0.0".to_owned()),
254 ("foobar".to_owned(), "0.0.0".to_owned()),
255 ("memchr".to_owned(), "2.6.3".to_owned()),
256 ("minimal-lexical".to_owned(), "0.2.1".to_owned()),
257 ("nom".to_owned(), "7.1.3".to_owned()),
258 ]
259 );
260 assert_eq!(
261 dependencies.direct_deps,
262 [
263 ("foo".to_owned(), "0.0.0".to_owned()),
264 ("foobar".to_owned(), "0.0.0".to_owned()),
265 ("nom".to_owned(), "7.1.3".to_owned()),
266 ]
267 );
268 assert_eq!(
269 dependencies.indirect_deps,
270 [
271 ("memchr".to_owned(), "2.6.3".to_owned()),
272 ("minimal-lexical".to_owned(), "0.2.1".to_owned()),
273 ]
274 );
275 }
276 }