use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DepDecl {
pub package: String,
pub version: String,
pub declared: String,
pub dts_root: Option<String>,
pub source: PathBuf,
}
impl DepDecl {
pub fn under(&self) -> Result<PathBuf, String> {
let declared = Path::new(&self.declared);
let Some(root) = &self.dts_root else {
return match declared.file_name() {
Some(name) => Ok(PathBuf::from(name)),
None => Err(self.says("is not a path to a file")),
};
};
declared
.strip_prefix(root)
.map(Path::to_path_buf)
.map_err(|_| {
self.says(&format!(
"does not start at the dts_root {root:?} that manifest declares"
))
})
}
pub fn target(&self, root: &Path) -> Result<PathBuf, String> {
Ok(root.join("types").join(&self.package).join(self.under()?))
}
fn says(&self, tail: &str) -> String {
format!(
"{} {} names {} in [package.metadata.htl] dts, which {tail}",
self.package, self.version, self.declared
)
}
}
fn carried_by_std(name: &str) -> bool {
#[cfg(feature = "std")]
{
name == crate::batteries::CRATE
}
#[cfg(not(feature = "std"))]
{
let _ = name;
false
}
}
fn slashed(p: &Path) -> String {
p.components()
.map(|c| c.as_os_str().to_string_lossy())
.collect::<Vec<_>>()
.join("/")
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Note {
#[serde(rename = "crate")]
pub package: String,
pub version: String,
pub files: Vec<String>,
}
impl Note {
fn text(&self) -> String {
let files: Vec<String> = self.files.iter().map(|f| format!("{f:?}")).collect();
format!(
"# Written by `htl dts`. The declarations in this directory were taken from the\n\
# crate named here, which is where a change to them belongs; this copy is\n\
# committed so that a checkout checks before anything is built.\n\
crate = {:?}\nversion = {:?}\nfiles = [{}]\n",
self.package,
self.version,
files.join(", ")
)
}
pub fn read(dir: &Path) -> Option<Note> {
let text = std::fs::read_to_string(dir.join(crate::DEP_TYPES_NOTE)).ok()?;
toml::from_str(&text).ok()
}
}
pub use crate::materialised_types_dirs as materialised_dirs;
fn cargo() -> std::ffi::OsString {
std::env::var_os("CARGO").unwrap_or_else(|| "cargo".into())
}
pub fn resolve(manifest_dir: &Path) -> Result<Vec<DepDecl>, String> {
let manifest = manifest_dir.join("Cargo.toml");
let mut cmd = std::process::Command::new(cargo());
cmd.args(["metadata", "--format-version", "1"]);
if manifest_dir.join("Cargo.lock").is_file() {
cmd.arg("--locked");
}
let out = cmd
.arg("--manifest-path")
.arg(&manifest)
.output()
.map_err(|e| format!("running `cargo metadata` for {}: {e}", manifest.display()))?;
if !out.status.success() {
let err = String::from_utf8_lossy(&out.stderr);
return Err(resolve_failed(manifest_dir, &manifest, &err));
}
let meta: serde_json::Value = serde_json::from_slice(&out.stdout)
.map_err(|e| format!("reading `cargo metadata`: {e}"))?;
decls(&meta)
}
fn resolve_failed(manifest_dir: &Path, manifest: &Path, stderr: &str) -> String {
if stderr.contains("--locked") && stderr.contains("lock file") {
return format!(
"{} does not cover {}, so the crate graph was not read and no dependency's \
declarations were materialised. `cargo update` writes it (`cargo \
generate-lockfile` if there is none yet); htl reads the graph with `--locked` so \
that checking a project never rewrites its lockfile",
manifest_dir.join("Cargo.lock").display(),
manifest.display()
);
}
let first = stderr
.lines()
.find(|l| !l.trim().is_empty())
.unwrap_or("no output");
format!("`cargo metadata` for {}: {first}", manifest.display())
}
fn decls(meta: &serde_json::Value) -> Result<Vec<DepDecl>, String> {
let Some(root) = meta["resolve"]["root"].as_str() else {
return Ok(Vec::new());
};
let mut edges: BTreeMap<&str, Vec<&str>> = BTreeMap::new();
for node in meta["resolve"]["nodes"].as_array().into_iter().flatten() {
let Some(id) = node["id"].as_str() else {
continue;
};
edges.insert(
id,
node["dependencies"]
.as_array()
.into_iter()
.flatten()
.filter_map(|d| d.as_str())
.collect(),
);
}
let mut seen: BTreeSet<&str> = BTreeSet::new();
let mut queue: Vec<&str> = edges.get(root).cloned().unwrap_or_default();
while let Some(id) = queue.pop() {
if !seen.insert(id) {
continue;
}
queue.extend(edges.get(id).into_iter().flatten().copied());
}
let mut out = Vec::new();
for pkg in meta["packages"].as_array().into_iter().flatten() {
if !pkg["id"].as_str().is_some_and(|id| seen.contains(id)) {
continue;
}
let (Some(name), Some(version), Some(mpath)) = (
pkg["name"].as_str(),
pkg["version"].as_str(),
pkg["manifest_path"].as_str(),
) else {
continue;
};
if carried_by_std(name) {
continue;
}
let dts = &pkg["metadata"]["htl"]["dts"];
if dts.is_null() {
continue;
}
let Some(list) = dts.as_array() else {
return Err(format!(
"{name} {version}: [package.metadata.htl] dts is not a list of paths"
));
};
let dts_root = match &pkg["metadata"]["htl"]["dts_root"] {
serde_json::Value::Null => None,
serde_json::Value::String(s) => Some(s.clone()),
_ => {
return Err(format!(
"{name} {version}: [package.metadata.htl] dts_root is not a path"
));
}
};
let dir = crate::parent_dir(Path::new(mpath));
for entry in list {
let Some(rel) = entry.as_str() else {
return Err(format!(
"{name} {version}: [package.metadata.htl] dts holds a value that is not a path"
));
};
for rel in expand(&dir, rel) {
out.push(DepDecl {
package: name.to_string(),
version: version.to_string(),
source: dir.join(&rel),
dts_root: dts_root.clone(),
declared: rel,
});
}
}
}
out.sort_by_cached_key(|d| {
(
d.package.clone(),
d.under().unwrap_or_else(|_| PathBuf::from(&d.declared)),
)
});
Ok(out)
}
fn expand(dir: &Path, rel: &str) -> Vec<String> {
let path = Path::new(rel);
let Some(pattern) = path.file_name().and_then(|f| f.to_str()) else {
return vec![rel.to_string()];
};
if !pattern.contains('*') {
return vec![rel.to_string()];
}
let parent = path.parent().unwrap_or(Path::new(""));
let Ok(read) = std::fs::read_dir(dir.join(parent)) else {
return vec![rel.to_string()];
};
let mut names: Vec<String> = read
.filter_map(|e| e.ok())
.filter_map(|e| e.file_name().into_string().ok())
.filter(|n| wildcard(pattern, n))
.collect();
if names.is_empty() {
return vec![rel.to_string()];
}
names.sort();
names
.into_iter()
.map(|n| parent.join(n).to_string_lossy().into_owned())
.collect()
}
fn wildcard(pattern: &str, name: &str) -> bool {
let mut parts = pattern.split('*');
let first = parts.next().unwrap_or("");
let Some(mut rest) = name.strip_prefix(first) else {
return false;
};
let parts: Vec<&str> = parts.collect();
let Some((last, middle)) = parts.split_last() else {
return rest.is_empty();
};
for part in middle {
let Some(i) = rest.find(part) else {
return false;
};
rest = &rest[i + part.len()..];
}
rest.ends_with(last)
}
pub fn materialise(root: &Path, decls: &[DepDecl]) -> (Vec<(PathBuf, bool)>, Vec<String>) {
let mut written = Vec::new();
let mut problems = Vec::new();
let mut notes: BTreeMap<&str, Note> = BTreeMap::new();
let mut taken: BTreeMap<PathBuf, &DepDecl> = BTreeMap::new();
for d in decls {
let under = match d.under() {
Ok(u) => u,
Err(e) => {
problems.push(e);
continue;
}
};
if !crate::is_declaration(&under) {
problems.push(d.says("is not a `.d.tl` file"));
continue;
}
let target = root.join("types").join(&d.package).join(&under);
if let Some(first) = taken.get(&target) {
problems.push(format!(
"{} {} names both {} and {} in [package.metadata.htl] dts, which would be one \
file under types/{}/",
d.package, d.version, first.declared, d.declared, d.package
));
continue;
}
let text = match std::fs::read_to_string(&d.source) {
Ok(t) => t,
Err(e) => {
problems.push(format!(
"{} {} names {} in [package.metadata.htl] dts: reading {}: {e}",
d.package,
d.version,
d.declared,
d.source.display()
));
continue;
}
};
match crate::write_if_changed(&target, &text) {
Ok(w) => {
taken.insert(target.clone(), d);
notes
.entry(&d.package)
.or_insert_with(|| Note {
package: d.package.clone(),
version: d.version.clone(),
files: Vec::new(),
})
.files
.push(slashed(&under));
written.push((target, w));
}
Err(e) => problems.push(format!(
"{} {} names {} in [package.metadata.htl] dts: writing {}: {e}",
d.package,
d.version,
d.declared,
target.display()
)),
}
}
for (pkg, note) in ¬es {
let dir = root.join("types").join(pkg);
if let Err(e) = crate::write_if_changed(&dir.join(crate::DEP_TYPES_NOTE), ¬e.text()) {
problems.push(format!(
"writing {}: {e}",
dir.join(crate::DEP_TYPES_NOTE).display()
));
}
}
(written, problems)
}
pub fn orphans(root: &Path, decls: &[DepDecl]) -> Vec<String> {
let types = root.join("types");
let mut current: BTreeMap<&str, BTreeSet<String>> = BTreeMap::new();
for d in decls {
if let Ok(under) = d.under() {
current
.entry(&d.package)
.or_default()
.insert(slashed(&under));
}
}
let mut out = Vec::new();
for dir in materialised_dirs(&types) {
let Some(note) = Note::read(&dir) else {
continue;
};
let live = current.get(note.package.as_str());
let mut files: Vec<PathBuf> = walkdir::WalkDir::new(&dir)
.sort_by_file_name()
.into_iter()
.filter_map(Result::ok)
.map(|e| e.into_path())
.filter(|p| p.is_file() && crate::is_declaration(p))
.collect();
files.sort();
for path in files {
let name = slashed(path.strip_prefix(&dir).unwrap_or(&path));
if live.is_some_and(|files| files.contains(&name)) {
continue;
}
let (why, advice) = if carried_by_std(¬e.package) {
(
format!(
"{} is on the path as std.* instead, and nothing preloads this copy's \
module name",
note.package
),
"delete it",
)
} else {
let why = match live {
Some(_) => format!("{} no longer ships it", note.package),
None => format!("{} is no longer a dependency", note.package),
};
(why, "delete it when nothing requires the module")
};
out.push(format!(
"{}: {why}; {advice}",
path.strip_prefix(root).unwrap_or(&path).display()
));
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn meta(json: &str) -> serde_json::Value {
serde_json::from_str(json).unwrap()
}
#[test]
fn a_lockfile_that_does_not_cover_the_manifest_is_said_as_that() {
let msg = resolve_failed(
Path::new("/w/app"),
Path::new("/w/app/Cargo.toml"),
"error: the lock file /w/app/Cargo.lock needs to be updated but --locked was \
passed to prevent this\nIf you want to try to generate the lock file without \
accessing the network, remove the --locked flag and use --offline instead.\n",
);
assert!(msg.contains("/w/app/Cargo.lock"), "{msg}");
assert!(msg.contains("cargo update"), "{msg}");
assert!(msg.contains("`--locked`"), "{msg}");
assert!(!msg.contains("remove the --locked flag"), "{msg}");
}
#[test]
fn another_failure_is_still_cargos_own_first_line() {
let msg = resolve_failed(
Path::new("/w/app"),
Path::new("/w/app/Cargo.toml"),
"\nerror: failed to parse manifest at `/w/app/Cargo.toml`\n\nCaused by:\n …\n",
);
assert_eq!(
msg,
"`cargo metadata` for /w/app/Cargo.toml: error: failed to parse manifest at `/w/app/Cargo.toml`"
);
}
#[test]
fn a_shipped_declaration_is_found_through_the_whole_graph() {
let d = decls(&meta(
r#"{
"packages": [
{"id": "root", "name": "app", "version": "0.1.0", "manifest_path": "/w/app/Cargo.toml"},
{"id": "mid", "name": "mid", "version": "0.2.0", "manifest_path": "/w/mid/Cargo.toml"},
{"id": "leaf", "name": "htl-mq", "version": "0.3.0", "manifest_path": "/w/mq/Cargo.toml",
"metadata": {"htl": {"dts": ["dts/mq.d.tl"]}}}
],
"resolve": {"root": "root", "nodes": [
{"id": "root", "dependencies": ["mid"]},
{"id": "mid", "dependencies": ["leaf"]},
{"id": "leaf", "dependencies": []}
]}
}"#,
))
.unwrap();
assert_eq!(d.len(), 1, "{d:?}");
assert_eq!(d[0].package, "htl-mq");
assert_eq!(d[0].under(), Ok(PathBuf::from("mq.d.tl")));
assert_eq!(d[0].source, PathBuf::from("/w/mq/dts/mq.d.tl"));
assert_eq!(
d[0].target(Path::new("/p")),
Ok(PathBuf::from("/p/types/htl-mq/mq.d.tl"))
);
}
#[test]
fn the_root_package_ships_to_itself_through_its_sources_not_through_this() {
let d = decls(&meta(
r#"{
"packages": [
{"id": "root", "name": "app", "version": "0.1.0", "manifest_path": "/w/app/Cargo.toml",
"metadata": {"htl": {"dts": ["dts/app.d.tl"]}}}
],
"resolve": {"root": "root", "nodes": [{"id": "root", "dependencies": []}]}
}"#,
))
.unwrap();
assert!(d.is_empty(), "{d:?}");
}
#[test]
fn a_package_outside_the_resolved_graph_is_not_a_dependency() {
let d = decls(&meta(
r#"{
"packages": [
{"id": "root", "name": "app", "version": "0.1.0", "manifest_path": "/w/app/Cargo.toml"},
{"id": "other", "name": "other", "version": "0.1.0", "manifest_path": "/w/o/Cargo.toml",
"metadata": {"htl": {"dts": ["dts/o.d.tl"]}}}
],
"resolve": {"root": "root", "nodes": [{"id": "root", "dependencies": []}]}
}"#,
))
.unwrap();
assert!(d.is_empty(), "{d:?}");
}
#[test]
fn a_dts_key_that_is_not_a_list_of_paths_is_an_error_naming_the_crate() {
let e = decls(&meta(
r#"{
"packages": [
{"id": "root", "name": "app", "version": "0.1.0", "manifest_path": "/w/app/Cargo.toml"},
{"id": "dep", "name": "dep", "version": "0.1.0", "manifest_path": "/w/d/Cargo.toml",
"metadata": {"htl": {"dts": "dts/dep.d.tl"}}}
],
"resolve": {"root": "root", "nodes": [
{"id": "root", "dependencies": ["dep"]}, {"id": "dep", "dependencies": []}]}
}"#,
))
.unwrap_err();
assert!(e.contains("dep 0.1.0"), "{e}");
assert!(e.contains("not a list of paths"), "{e}");
}
#[test]
fn a_star_in_the_file_name_is_every_matching_file_in_that_directory() {
let dir = std::env::temp_dir().join(format!("htl-dep-dts-glob-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(dir.join("types/b")).unwrap();
for f in ["json.d.tl", "env.d.tl", "README.md", "init.tl"] {
std::fs::write(dir.join("types/b").join(f), "").unwrap();
}
let manifest = dir.join("Cargo.toml").display().to_string();
let d = decls(&meta(&format!(
r#"{{
"packages": [
{{"id": "root", "name": "app", "version": "0.1.0", "manifest_path": "/w/app/Cargo.toml"}},
{{"id": "dep", "name": "b", "version": "0.7.0", "manifest_path": "{manifest}",
"metadata": {{"htl": {{"dts": ["types/b/*.d.tl", "extra/one.d.tl"]}}}}}}
],
"resolve": {{"root": "root", "nodes": [
{{"id": "root", "dependencies": ["dep"]}}, {{"id": "dep", "dependencies": []}}]}}
}}"#
)))
.unwrap();
let declared: Vec<&str> = d.iter().map(|d| d.declared.as_str()).collect();
assert_eq!(
declared,
["types/b/env.d.tl", "types/b/json.d.tl", "extra/one.d.tl"],
"{d:?}"
);
assert_eq!(d[0].source, dir.join("types/b/env.d.tl"));
assert_eq!(d[0].under(), Ok(PathBuf::from("env.d.tl")));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_star_that_matches_nothing_is_reported_as_the_pattern() {
let dir = std::env::temp_dir().join(format!("htl-dep-dts-noglob-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(dir.join("dts")).unwrap();
std::fs::write(dir.join("dts/notes.txt"), "").unwrap();
assert_eq!(expand(&dir, "dts/*.d.tl"), ["dts/*.d.tl"]);
assert_eq!(expand(&dir, "missing/*.d.tl"), ["missing/*.d.tl"]);
assert_eq!(expand(&dir, "dts/plain.d.tl"), ["dts/plain.d.tl"]);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_star_matches_a_run_of_anything_and_nothing_else_is_special() {
assert!(wildcard("*.d.tl", "json.d.tl"));
assert!(wildcard("*.d.tl", ".d.tl"));
assert!(!wildcard("*.d.tl", "json.tl"));
assert!(wildcard("mq_*.d.tl", "mq_a.d.tl"));
assert!(!wildcard("mq_*.d.tl", "a_mq_a.d.tl"));
assert!(wildcard("a*b*c", "abc"));
assert!(wildcard("a*b*c", "axxbyyc"));
assert!(!wildcard("a*bc*c", "abc"));
assert!(!wildcard("?.d.tl", "a.d.tl"));
}
fn rooted(root: &str, entries: &str, manifest: &str) -> Result<Vec<DepDecl>, String> {
decls(&meta(&format!(
r#"{{
"packages": [
{{"id": "root", "name": "app", "version": "0.1.0", "manifest_path": "/w/app/Cargo.toml"}},
{{"id": "dep", "name": "my-mod", "version": "0.1.0", "manifest_path": "{manifest}",
"metadata": {{"htl": {{"dts_root": {root}, "dts": {entries}}}}}}}
],
"resolve": {{"root": "root", "nodes": [
{{"id": "root", "dependencies": ["dep"]}}, {{"id": "dep", "dependencies": []}}]}}
}}"#
)))
}
#[test]
fn a_dts_root_keeps_the_path_below_it() {
let d = rooted(
"\"types\"",
"[\"types/mine/thing.d.tl\", \"types/a/log.d.tl\", \"types/b/log.d.tl\"]",
"/w/d/Cargo.toml",
)
.unwrap();
let under: Vec<String> = d.iter().map(|d| slashed(&d.under().unwrap())).collect();
assert_eq!(
under,
["a/log.d.tl", "b/log.d.tl", "mine/thing.d.tl"],
"{d:?}"
);
assert_eq!(
d[2].target(Path::new("/p")),
Ok(PathBuf::from("/p/types/my-mod/mine/thing.d.tl"))
);
assert_eq!(d[2].source, PathBuf::from("/w/d/types/mine/thing.d.tl"));
}
#[test]
fn an_entry_outside_the_dts_root_is_reported_naming_both() {
let d = rooted(
"\"types\"",
"[\"types/mine/thing.d.tl\", \"dts/stray.d.tl\"]",
"/w/d/Cargo.toml",
)
.unwrap();
assert_eq!(d.len(), 2, "{d:?}");
let stray = d.iter().find(|d| d.declared == "dts/stray.d.tl").unwrap();
let e = stray.under().unwrap_err();
assert!(e.contains("my-mod 0.1.0"), "{e}");
assert!(e.contains("dts/stray.d.tl"), "{e}");
assert!(e.contains("dts_root \"types\""), "{e}");
assert!(d.iter().any(|d| d.under().is_ok()), "{d:?}");
}
#[test]
fn a_dts_root_that_is_not_a_path_is_an_error_naming_the_crate() {
let e = rooted("42", "[\"types/a.d.tl\"]", "/w/d/Cargo.toml").unwrap_err();
assert!(e.contains("my-mod 0.1.0"), "{e}");
assert!(e.contains("dts_root is not a path"), "{e}");
}
#[test]
fn a_dts_root_and_a_star_compose() {
let dir = std::env::temp_dir().join(format!("htl-dep-dts-root-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(dir.join("types/mine")).unwrap();
for f in ["thing.d.tl", "other.d.tl", "notes.md"] {
std::fs::write(dir.join("types/mine").join(f), "").unwrap();
}
let d = rooted(
"\"types\"",
"[\"types/mine/*.d.tl\"]",
&dir.join("Cargo.toml").display().to_string(),
)
.unwrap();
let under: Vec<String> = d.iter().map(|d| slashed(&d.under().unwrap())).collect();
assert_eq!(under, ["mine/other.d.tl", "mine/thing.d.tl"], "{d:?}");
let _ = std::fs::remove_dir_all(&dir);
}
fn materialised(root: &Path, package: &str, files: &[&str]) {
let dir = root.join("types").join(package);
std::fs::create_dir_all(&dir).unwrap();
for f in files {
std::fs::write(dir.join(f), "return {}\n").unwrap();
}
let note = Note {
package: package.to_string(),
version: "0.1.0".into(),
files: files.iter().map(|f| f.to_string()).collect(),
};
std::fs::write(dir.join(crate::DEP_TYPES_NOTE), note.text()).unwrap();
}
#[cfg(feature = "std")]
#[test]
fn a_crate_this_build_carries_is_not_reported_as_a_departed_dependency() {
let dir = std::env::temp_dir().join(format!("htl-dep-dts-skip-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
materialised(&dir, crate::batteries::CRATE, &["json.d.tl"]);
materialised(&dir, "gone", &["gone.d.tl"]);
let out = orphans(&dir, &[]);
assert_eq!(out.len(), 2, "{out:?}");
let carried = out
.iter()
.find(|l| l.contains(crate::batteries::CRATE))
.unwrap();
assert!(
carried.contains("is on the path as std.* instead"),
"{carried}"
);
assert!(
carried.contains("nothing preloads this copy's module name"),
"{carried}"
);
assert!(!carried.contains("no longer"), "{carried}");
let departed = out.iter().find(|l| l.contains("types/gone/")).unwrap();
assert!(
departed.contains("gone is no longer a dependency"),
"{departed}"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_live_crates_own_files_are_not_orphans() {
let dir = std::env::temp_dir().join(format!("htl-dep-dts-live-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
materialised(&dir, "dep", &["dep.d.tl", "old.d.tl"]);
let live = DepDecl {
package: "dep".into(),
version: "0.1.0".into(),
declared: "dts/dep.d.tl".into(),
dts_root: None,
source: PathBuf::from("/w/d/dts/dep.d.tl"),
};
let out = orphans(&dir, std::slice::from_ref(&live));
assert_eq!(out.len(), 1, "{out:?}");
assert!(out[0].contains("types/dep/old.d.tl"), "{out:?}");
assert!(out[0].contains("dep no longer ships it"), "{out:?}");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn the_note_round_trips_and_marks_the_directory() {
let dir = std::env::temp_dir().join(format!("htl-dep-dts-note-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let note = Note {
package: "dep".into(),
version: "0.1.0".into(),
files: vec!["dep.d.tl".into()],
};
std::fs::create_dir_all(dir.join("types/dep")).unwrap();
crate::write_if_changed(
&dir.join("types/dep").join(crate::DEP_TYPES_NOTE),
¬e.text(),
)
.unwrap();
std::fs::create_dir_all(dir.join("types/socket")).unwrap();
std::fs::write(dir.join("types/socket/http.d.tl"), "return {}\n").unwrap();
assert_eq!(
materialised_dirs(&dir.join("types")),
vec![dir.join("types/dep")]
);
assert_eq!(Note::read(&dir.join("types/dep")), Some(note));
std::fs::remove_dir_all(&dir).unwrap();
}
}