Skip to content

Commit 488e8d8

Browse files
borsbors
committed
Auto merge of #2192 - alexcrichton:search-cargo-home, r=brson
Don't require PATH modifications for new cargo subcommands by looking specifically in $CARGO_HOME/bin for installed commands. Closes #2189
2 parents 5227385 + 20b768e commit 488e8d8

File tree

4 files changed

+106
-126
lines changed

4 files changed

+106
-126
lines changed

‎src/bin/cargo.rs

+85-116
Original file line numberDiff line numberDiff line change
@@ -8,13 +8,10 @@ extern crate toml;
88
use std::collections::BTreeSet;
99
use std::env;
1010
use std::fs;
11-
use std::io;
12-
use std::path::{PathBuf, Path};
13-
use std::process::Command;
11+
use std::path::PathBuf;
1412

15-
use cargo::{execute_main_without_stdin, handle_error, shell};
16-
use cargo::core::MultiShell;
17-
use cargo::util::{CliError, CliResult, lev_distance, Config};
13+
use cargo::execute_main_without_stdin;
14+
use cargo::util::{self, CliResult, lev_distance, Config, human, CargoResult};
1815

1916
#[derive(RustcDecodable)]
2017
struct Flags {
@@ -61,35 +58,37 @@ fn main() {
6158
execute_main_without_stdin(execute, true, USAGE)
6259
}
6360

64-
macro_rules! each_subcommand{ ($mac:ident) => ({
65-
$mac!(bench);
66-
$mac!(build);
67-
$mac!(clean);
68-
$mac!(doc);
69-
$mac!(fetch);
70-
$mac!(generate_lockfile);
71-
$mac!(git_checkout);
72-
$mac!(help);
73-
$mac!(install);
74-
$mac!(locate_project);
75-
$mac!(login);
76-
$mac!(new);
77-
$mac!(owner);
78-
$mac!(package);
79-
$mac!(pkgid);
80-
$mac!(publish);
81-
$mac!(read_manifest);
82-
$mac!(run);
83-
$mac!(rustc);
84-
$mac!(rustdoc);
85-
$mac!(search);
86-
$mac!(test);
87-
$mac!(uninstall);
88-
$mac!(update);
89-
$mac!(verify_project);
90-
$mac!(version);
91-
$mac!(yank);
92-
}) }
61+
macro_rules! each_subcommand{
62+
($mac:ident) => ({
63+
$mac!(bench);
64+
$mac!(build);
65+
$mac!(clean);
66+
$mac!(doc);
67+
$mac!(fetch);
68+
$mac!(generate_lockfile);
69+
$mac!(git_checkout);
70+
$mac!(help);
71+
$mac!(install);
72+
$mac!(locate_project);
73+
$mac!(login);
74+
$mac!(new);
75+
$mac!(owner);
76+
$mac!(package);
77+
$mac!(pkgid);
78+
$mac!(publish);
79+
$mac!(read_manifest);
80+
$mac!(run);
81+
$mac!(rustc);
82+
$mac!(rustdoc);
83+
$mac!(search);
84+
$mac!(test);
85+
$mac!(uninstall);
86+
$mac!(update);
87+
$mac!(verify_project);
88+
$mac!(version);
89+
$mac!(yank);
90+
})
91+
}
9392

9493
/**
9594
The top-level `cargo` command handles configuration and project location
@@ -104,7 +103,7 @@ fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
104103

105104
if flags.flag_list {
106105
println!("Installed Commands:");
107-
for command in list_commands().into_iter() {
106+
for command in list_commands(config) {
108107
println!(" {}", command);
109108
};
110109
return Ok(None)
@@ -143,8 +142,8 @@ fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
143142
_ => env::args().collect(),
144143
};
145144

146-
macro_rules! cmd{ ($name:ident) => (
147-
if args[1] == stringify!($name).replace("_", "-") {
145+
macro_rules! cmd{
146+
($name:ident) => (if args[1] == stringify!($name).replace("_", "-") {
148147
mod $name;
149148
config.shell().set_verbose(true);
150149
let r = cargo::call_main_without_stdin($name::execute, config,
@@ -153,130 +152,100 @@ fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
153152
false);
154153
cargo::process_executed(r, &mut config.shell());
155154
return Ok(None)
156-
}
157-
) }
155+
})
156+
}
158157
each_subcommand!(cmd);
159158

160-
execute_subcommand(&args[1], &args, &mut config.shell());
159+
try!(execute_subcommand(config, &args[1], &args));
161160
Ok(None)
162161
}
163162

164-
fn find_closest(cmd: &str) -> Option<String> {
165-
let cmds = list_commands();
163+
fn find_closest(config: &Config, cmd: &str) -> Option<String> {
164+
let cmds = list_commands(config);
166165
// Only consider candidates with a lev_distance of 3 or less so we don't
167166
// suggest out-of-the-blue options.
168167
let mut filtered = cmds.iter().map(|c| (lev_distance(&c, cmd), c))
169168
.filter(|&(d, _)| d < 4)
170169
.collect::<Vec<_>>();
171170
filtered.sort_by(|a, b| a.0.cmp(&b.0));
172-
173-
if filtered.len() == 0 {
174-
None
175-
} else {
176-
Some(filtered[0].1.to_string())
177-
}
171+
filtered.get(0).map(|slot| slot.1.to_string())
178172
}
179173

180-
fn execute_subcommand(cmd: &str, args: &[String], shell: &mut MultiShell) {
181-
let command = match find_command(cmd) {
182-
Some(command) => command,
174+
fn execute_subcommand(config: &Config,
175+
cmd: &str,
176+
args: &[String]) -> CargoResult<()> {
177+
let command_exe = format!("cargo-{}{}", cmd, env::consts::EXE_SUFFIX);
178+
let path = search_directories(config)
179+
.iter()
180+
.map(|dir| dir.join(&command_exe))
181+
.filter_map(|dir| fs::metadata(&dir).ok().map(|m| (dir, m)))
182+
.find(|&(_, ref meta)| is_executable(meta));
183+
let command = match path {
184+
Some((command, _)) => command,
183185
None => {
184-
let msg = match find_closest(cmd) {
185-
Some(closest) => format!("No such subcommand\n\n\t\
186+
return Err(human(match find_closest(config, cmd) {
187+
Some(closest) => format!("no such subcommand\n\n\t\
186188
Did you mean `{}`?\n", closest),
187-
None => "No such subcommand".to_string()
188-
};
189-
return handle_error(CliError::new(&msg, 127), shell)
189+
None => "no such subcommand".to_string()
190+
}))
190191
}
191192
};
192-
match Command::new(&command).args(&args[1..]).status() {
193-
Ok(ref status) if status.success() => {}
194-
Ok(ref status) => {
195-
match status.code() {
196-
Some(code) => handle_error(CliError::new("", code), shell),
197-
None => {
198-
let msg = format!("subcommand failed with: {}", status);
199-
handle_error(CliError::new(&msg, 101), shell)
200-
}
201-
}
202-
}
203-
Err(ref e) if e.kind() == io::ErrorKind::NotFound => {
204-
handle_error(CliError::new("No such subcommand", 127), shell)
205-
}
206-
Err(err) => {
207-
let msg = format!("Subcommand failed to run: {}", err);
208-
handle_error(CliError::new(&msg, 127), shell)
209-
}
210-
}
193+
try!(util::process(&command).args(&args[1..]).exec());
194+
Ok(())
211195
}
212196

213197
/// List all runnable commands. find_command should always succeed
214198
/// if given one of returned command.
215-
fn list_commands() -> BTreeSet<String> {
216-
let command_prefix = "cargo-";
199+
fn list_commands(config: &Config) -> BTreeSet<String> {
200+
let prefix = "cargo-";
201+
let suffix = env::consts::EXE_SUFFIX;
217202
let mut commands = BTreeSet::new();
218-
for dir in list_command_directory().iter() {
203+
for dir in search_directories(config) {
219204
let entries = match fs::read_dir(dir) {
220205
Ok(entries) => entries,
221206
_ => continue
222207
};
223-
for entry in entries {
224-
let entry = match entry { Ok(e) => e, Err(..) => continue };
225-
let entry = entry.path();
226-
let filename = match entry.file_name().and_then(|s| s.to_str()) {
208+
for entry in entries.filter_map(|e| e.ok()) {
209+
let path = entry.path();
210+
let filename = match path.file_name().and_then(|s| s.to_str()) {
227211
Some(filename) => filename,
228212
_ => continue
229213
};
230-
if filename.starts_with(command_prefix) &&
231-
filename.ends_with(env::consts::EXE_SUFFIX) &&
232-
is_executable(&entry) {
233-
let command = &filename[
234-
command_prefix.len()..
235-
filename.len() - env::consts::EXE_SUFFIX.len()];
236-
commands.insert(command.to_string());
214+
if !filename.starts_with(prefix) || !filename.ends_with(suffix) {
215+
continue
216+
}
217+
if let Ok(meta) = entry.metadata() {
218+
if is_executable(&meta) {
219+
let end = filename.len() - suffix.len();
220+
commands.insert(filename[prefix.len()..end].to_string());
221+
}
237222
}
238223
}
239224
}
240225

241-
macro_rules! add_cmd{ ($cmd:ident) => ({
242-
commands.insert(stringify!($cmd).replace("_", "-"));
243-
}) }
226+
macro_rules! add_cmd {
227+
($cmd:ident) => (commands.insert(stringify!($cmd).replace("_", "-")))
228+
}
244229
each_subcommand!(add_cmd);
245230
commands
246231
}
247232

248233
#[cfg(unix)]
249-
fn is_executable(path: &Path) -> bool {
234+
fn is_executable(metadata: &fs::Metadata) -> bool {
250235
use std::os::unix::prelude::*;
251-
fs::metadata(path).map(|m| {
252-
m.permissions().mode() & 0o001 == 0o001
253-
}).unwrap_or(false)
236+
metadata.is_file() && metadata.permissions().mode() & 0o111 != 0
254237
}
255238
#[cfg(windows)]
256-
fn is_executable(path: &Path) -> bool {
257-
fs::metadata(path).map(|m| m.is_file()).unwrap_or(false)
239+
fn is_executable(metadata: &fs::Metadata) -> bool {
240+
metadata.is_file()
258241
}
259242

260-
/// Get `Command` to run given command.
261-
fn find_command(cmd: &str) -> Option<PathBuf> {
262-
let command_exe = format!("cargo-{}{}", cmd, env::consts::EXE_SUFFIX);
263-
let dirs = list_command_directory();
264-
let mut command_paths = dirs.iter().map(|dir| dir.join(&command_exe));
265-
command_paths.find(|path| fs::metadata(&path).is_ok())
266-
}
267-
268-
/// List candidate locations where subcommands might be installed.
269-
fn list_command_directory() -> Vec<PathBuf> {
270-
let mut dirs = vec![];
271-
if let Ok(mut path) = env::current_exe() {
272-
path.pop();
273-
dirs.push(path.join("../lib/cargo"));
274-
dirs.push(path);
275-
}
243+
fn search_directories(config: &Config) -> Vec<PathBuf> {
244+
let mut dirs = vec![config.home().join("bin")];
276245
if let Some(val) = env::var_os("PATH") {
277246
dirs.extend(env::split_paths(&val));
278247
}
279-
dirs
248+
return dirs
280249
}
281250

282251
fn init_git_transports(config: &Config) {

‎src/bin/run.rs

+1-6
Original file line numberDiff line numberDiff line change
@@ -84,12 +84,7 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
8484
target_rustc_args: None,
8585
};
8686

87-
let err = try!(ops::run(&root,
88-
&compile_opts,
89-
&options.arg_args).map_err(|err| {
90-
CliError::from_boxed(err, 101)
91-
}));
92-
match err {
87+
match try!(ops::run(&root, &compile_opts, &options.arg_args)) {
9388
None => Ok(None),
9489
Some(err) => {
9590
Err(match err.exit.as_ref().and_then(|e| e.code()) {

‎tests/test_cargo.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -62,8 +62,8 @@ test!(find_closest_biuld_to_build {
6262
pr.arg("biuld").cwd(&paths::root()).env("HOME", &paths::home());
6363

6464
assert_that(pr,
65-
execs().with_status(127)
66-
.with_stderr("No such subcommand
65+
execs().with_status(101)
66+
.with_stderr("no such subcommand
6767
6868
Did you mean `build`?
6969
@@ -76,8 +76,8 @@ test!(find_closest_dont_correct_nonsense {
7676
pr.arg("asdf").cwd(&paths::root()).env("HOME", &paths::home());
7777

7878
assert_that(pr,
79-
execs().with_status(127)
80-
.with_stderr("No such subcommand
79+
execs().with_status(101)
80+
.with_stderr("no such subcommand
8181
"));
8282
});
8383

‎tests/test_cargo_install.rs

+16
Original file line numberDiff line numberDiff line change
@@ -512,3 +512,19 @@ test!(uninstall_piecemeal {
512512
package id specification `foo` matched no packages
513513
"));
514514
});
515+
516+
test!(subcommand_works_out_of_the_box {
517+
Package::new("cargo-foo", "1.0.0")
518+
.file("src/main.rs", r#"
519+
fn main() {
520+
println!("bar");
521+
}
522+
"#)
523+
.publish();
524+
assert_that(cargo_process("install").arg("cargo-foo"),
525+
execs().with_status(0));
526+
assert_that(cargo_process("foo"),
527+
execs().with_status(0).with_stdout("bar\n"));
528+
assert_that(cargo_process("--list"),
529+
execs().with_status(0).with_stdout_contains(" foo\n"));
530+
});

0 commit comments

Comments
 (0)