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
use std::collections::{HashMap, HashSet};
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
use core::{Package, Manifest, SourceId, PackageId};
use util::{self, paths, CargoResult, human, Config, ChainError};
use util::important_paths::find_project_manifest_exact;
use util::toml::Layout;
pub fn read_manifest(contents: &[u8], layout: Layout, source_id: &SourceId,
config: &Config)
-> CargoResult<(Manifest, Vec<PathBuf>)> {
let root = layout.root.clone();
util::toml::to_manifest(contents, source_id, layout, config).chain_error(|| {
human(format!("failed to parse manifest at `{}`",
root.join("Cargo.toml").display()))
})
}
pub fn read_package(path: &Path, source_id: &SourceId, config: &Config)
-> CargoResult<(Package, Vec<PathBuf>)> {
trace!("read_package; path={}; source-id={}", path.display(), source_id);
let data = try!(paths::read(path));
let layout = Layout::from_project_path(path.parent().unwrap());
let (manifest, nested) =
try!(read_manifest(data.as_bytes(), layout, source_id, config));
Ok((Package::new(manifest, path), nested))
}
pub fn read_packages(path: &Path, source_id: &SourceId, config: &Config)
-> CargoResult<Vec<Package>> {
let mut all_packages = HashMap::new();
let mut visited = HashSet::<PathBuf>::new();
trace!("looking for root package: {}, source_id={}", path.display(), source_id);
try!(walk(path, &mut |dir| {
trace!("looking for child package: {}", dir.display());
if dir != path {
let name = dir.file_name().and_then(|s| s.to_str());
if name.map(|s| s.starts_with(".")) == Some(true) {
return Ok(false)
}
if fs::metadata(&dir.join(".git")).is_ok() {
return Ok(false)
}
}
if dir.file_name().and_then(|s| s.to_str()) == Some("target") &&
has_manifest(dir.parent().unwrap()) {
return Ok(false)
}
if has_manifest(dir) {
try!(read_nested_packages(dir, &mut all_packages, source_id, config,
&mut visited));
}
Ok(true)
}));
if all_packages.is_empty() {
Err(human(format!("Could not find Cargo.toml in `{}`", path.display())))
} else {
Ok(all_packages.into_iter().map(|(_, v)| v).collect())
}
}
fn walk(path: &Path, callback: &mut FnMut(&Path) -> CargoResult<bool>)
-> CargoResult<()> {
if !try!(callback(path)) {
trace!("not processing {}", path.display());
return Ok(())
}
let dirs = match fs::read_dir(path) {
Ok(dirs) => dirs,
Err(ref e) if e.kind() == io::ErrorKind::PermissionDenied => {
return Ok(())
}
Err(e) => {
return Err(human(e)).chain_error(|| {
human(format!("failed to read directory `{}`", path.display()))
})
}
};
for dir in dirs {
let dir = try!(dir);
if try!(dir.file_type()).is_dir() {
try!(walk(&dir.path(), callback));
}
}
Ok(())
}
fn has_manifest(path: &Path) -> bool {
find_project_manifest_exact(path, "Cargo.toml").is_ok()
}
fn read_nested_packages(path: &Path,
all_packages: &mut HashMap<PackageId, Package>,
source_id: &SourceId,
config: &Config,
visited: &mut HashSet<PathBuf>) -> CargoResult<()> {
if !visited.insert(path.to_path_buf()) { return Ok(()) }
let manifest = try!(find_project_manifest_exact(path, "Cargo.toml"));
let (pkg, nested) = try!(read_package(&manifest, source_id, config));
let pkg_id = pkg.package_id().clone();
if !all_packages.contains_key(&pkg_id) {
all_packages.insert(pkg_id, pkg);
} else {
info!("skipping nested package `{}` found at `{}`",
pkg.name(), path.to_string_lossy());
}
if !source_id.is_registry() {
for p in nested.iter() {
let path = util::normalize_path(&path.join(p));
try!(read_nested_packages(&path, all_packages, source_id,
config, visited));
}
}
Ok(())
}