";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
- try!(config.configure(options.flag_verbose,
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let ops = ops::TestOptions {
no_run: options.flag_no_run,
no_fail_fast: false,
},
};
- let ws = try!(Workspace::new(&root, config));
- let err = try!(ops::run_benches(&ws, &ops, &options.arg_args));
+ let ws = Workspace::new(&root, config)?;
+ let err = ops::run_benches(&ws, &ops, &options.arg_args)?;
match err {
None => Ok(None),
Some(err) => {
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
debug!("executing; cmd=cargo-build; args={:?}",
env::args().collect::<Vec<_>>());
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
let opts = CompileOptions {
config: config,
target_rustc_args: None,
};
- let ws = try!(Workspace::new(&root, config));
- try!(ops::compile(&ws, &opts));
+ let ws = Workspace::new(&root, config)?;
+ ops::compile(&ws, &opts)?;
Ok(None)
}
on this top-level information.
*/
fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(flags.flag_verbose,
+ config.configure(flags.flag_verbose,
flags.flag_quiet,
&flags.flag_color,
flags.flag_frozen,
- flags.flag_locked));
+ flags.flag_locked)?;
init_git_transports(config);
let _token = cargo::util::job::setup();
}
if let Some(ref code) = flags.flag_explain {
- let mut procss = try!(config.rustc()).process();
- try!(procss.arg("--explain").arg(code).exec().map_err(human));
+ let mut procss = config.rustc()?.process();
+ procss.arg("--explain").arg(code).exec().map_err(human)?;
return Ok(None)
}
return Ok(None)
}
- let alias_list = try!(aliased_command(&config, &args[1]));
+ let alias_list = aliased_command(&config, &args[1])?;
let args = match alias_list {
Some(alias_command) => {
let chain = args.iter().take(1)
}
None => args,
};
- try!(execute_subcommand(config, &args[1], &args));
+ execute_subcommand(config, &args[1], &args)?;
Ok(None)
}
}
},
Err(_) => {
- let value = try!(config.get_list(&alias_name));
+ let value = config.get_list(&alias_name)?;
if let Some(record) = value {
let alias_commands: Vec<String> = record.val.iter()
.map(|s| s.0.to_string()).collect();
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
debug!("executing; cmd=cargo-clean; args={:?}", env::args().collect::<Vec<_>>());
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
let opts = ops::CleanOptions {
config: config,
spec: &options.flag_package,
target: options.flag_target.as_ref().map(|s| &s[..]),
release: options.flag_release,
};
- let ws = try!(Workspace::new(&root, config));
- try!(ops::clean(&ws, &opts));
+ let ws = Workspace::new(&root, config)?;
+ ops::clean(&ws, &opts)?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
let empty = Vec::new();
let doc_opts = ops::DocOptions {
},
};
- let ws = try!(Workspace::new(&root, config));
- try!(ops::doc(&ws, &doc_opts));
+ let ws = Workspace::new(&root, config)?;
+ ops::doc(&ws, &doc_opts)?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
- let ws = try!(Workspace::new(&root, config));
- try!(ops::fetch(&ws));
+ options.flag_locked)?;
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
+ let ws = Workspace::new(&root, config)?;
+ ops::fetch(&ws)?;
Ok(None)
}
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
debug!("executing; cmd=cargo-generate-lockfile; args={:?}", env::args().collect::<Vec<_>>());
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ options.flag_locked)?;
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
- let ws = try!(Workspace::new(&root, config));
- try!(ops::generate_lockfile(&ws));
+ let ws = Workspace::new(&root, config)?;
+ ops::generate_lockfile(&ws)?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let Options { flag_url: url, flag_reference: reference, .. } = options;
- let url = try!(url.to_url());
+ let url = url.to_url()?;
let reference = GitReference::Branch(reference.clone());
let source_id = SourceId::for_git(&url, reference);
let mut source = GitSource::new(&source_id, config);
- try!(source.update());
+ source.update()?;
Ok(None)
}
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
debug!("executing; cmd=cargo-init; args={:?}", env::args().collect::<Vec<_>>());
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let Options { flag_bin, flag_lib, arg_path, flag_name, flag_vcs, .. } = options;
flag_name.as_ref().map(|s| s.as_ref()));
let opts_lib = opts.lib;
- try!(ops::init(opts, config));
+ ops::init(opts, config)?;
- try!(config.shell().status("Created", format!("{} project",
+ config.shell().status("Created", format!("{} project",
if opts_lib { "library" }
- else {"binary (application)"})));
+ else {"binary (application)"}))?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let compile_opts = ops::CompileOptions {
config: config,
};
let source = if let Some(url) = options.flag_git {
- let url = try!(url.to_url());
+ let url = url.to_url()?;
let gitref = if let Some(branch) = options.flag_branch {
GitReference::Branch(branch)
} else if let Some(tag) = options.flag_tag {
};
SourceId::for_git(&url, gitref)
} else if let Some(path) = options.flag_path {
- try!(SourceId::for_path(&config.cwd().join(path)))
+ SourceId::for_path(&config.cwd().join(path))?
} else if options.arg_crate == None {
- try!(SourceId::for_path(&config.cwd()))
+ SourceId::for_path(&config.cwd())?
} else {
- try!(SourceId::crates_io(config))
+ SourceId::crates_io(config)?
};
let krate = options.arg_crate.as_ref().map(|s| &s[..]);
let root = options.flag_root.as_ref().map(|s| &s[..]);
if options.flag_list {
- try!(ops::install_list(root, config));
+ ops::install_list(root, config)?;
} else {
- try!(ops::install(root, krate, &source, vers, &compile_opts, options.flag_force));
+ ops::install(root, krate, &source, vers, &compile_opts, options.flag_force)?;
}
Ok(None)
}
pub fn execute(flags: LocateProjectFlags,
config: &Config) -> CliResult<Option<ProjectLocation>> {
- let root = try!(find_root_manifest_for_wd(flags.flag_manifest_path, config.cwd()));
+ let root = find_root_manifest_for_wd(flags.flag_manifest_path, config.cwd())?;
- let string = try!(root.to_str()
+ let string = root.to_str()
.chain_error(|| human("Your project path contains \
characters not representable in \
Unicode"))
- .map_err(|e| CliError::new(e, 1)));
+ .map_err(|e| CliError::new(e, 1))?;
Ok(Some(ProjectLocation { root: string.to_string() }))
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let token = match options.arg_token.clone() {
Some(token) => token,
None => {
- let src = try!(SourceId::crates_io(config));
+ let src = SourceId::crates_io(config)?;
let mut src = RegistrySource::remote(&src, config);
- try!(src.update());
- let config = try!(src.config()).unwrap();
+ src.update()?;
+ let config = src.config()?.unwrap();
let host = options.flag_host.clone().unwrap_or(config.api);
println!("please visit {}me and paste the API Token below", host);
let mut line = String::new();
let input = io::stdin();
- try!(input.lock().read_line(&mut line).chain_error(|| {
+ input.lock().read_line(&mut line).chain_error(|| {
human("failed to read stdin")
- }));
+ })?;
line
}
};
let token = token.trim().to_string();
- try!(ops::registry_login(config, token));
+ ops::registry_login(config, token)?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<ExportInfo>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
- let manifest = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ options.flag_locked)?;
+ let manifest = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
let options = OutputMetadataOptions {
features: options.flag_features,
version: options.flag_format_version,
};
- let ws = try!(Workspace::new(&manifest, config));
- let result = try!(output_metadata(&ws, &options));
+ let ws = Workspace::new(&manifest, config)?;
+ let result = output_metadata(&ws, &options)?;
Ok(Some(result))
}
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
debug!("executing; cmd=cargo-new; args={:?}", env::args().collect::<Vec<_>>());
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let Options { flag_bin, flag_lib, arg_path, flag_name, flag_vcs, .. } = options;
flag_name.as_ref().map(|s| s.as_ref()));
let opts_lib = opts.lib;
- try!(ops::new(opts, config));
+ ops::new(opts, config)?;
- try!(config.shell().status("Created", format!("{} `{}` project",
+ config.shell().status("Created", format!("{} `{}` project",
if opts_lib { "library" }
else {"binary (application)"},
- arg_path)));
+ arg_path))?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let opts = ops::OwnersOptions {
krate: options.arg_crate,
token: options.flag_token,
to_remove: options.flag_remove,
list: options.flag_list,
};
- try!(ops::modify_owners(config, &opts));
+ ops::modify_owners(config, &opts)?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
- let ws = try!(Workspace::new(&root, config));
- try!(ops::package(&ws, &ops::PackageOpts {
+ options.flag_locked)?;
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
+ let ws = Workspace::new(&root, config)?;
+ ops::package(&ws, &ops::PackageOpts {
config: config,
verify: !options.flag_no_verify,
list: options.flag_list,
check_metadata: !options.flag_no_metadata,
allow_dirty: options.flag_allow_dirty,
jobs: options.flag_jobs,
- }));
+ })?;
Ok(None)
}
pub fn execute(options: Options,
config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path.clone(), config.cwd()));
- let ws = try!(Workspace::new(&root, config));
+ options.flag_locked)?;
+ let root = find_root_manifest_for_wd(options.flag_manifest_path.clone(), config.cwd())?;
+ let ws = Workspace::new(&root, config)?;
let spec = if options.arg_spec.is_some() {
options.arg_spec
None
};
let spec = spec.as_ref().map(|s| &s[..]);
- let spec = try!(ops::pkgid(&ws, spec));
+ let spec = ops::pkgid(&ws, spec)?;
println!("{}", spec);
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let Options {
flag_token: token,
flag_host: host,
..
} = options;
- let root = try!(find_root_manifest_for_wd(flag_manifest_path.clone(), config.cwd()));
- let ws = try!(Workspace::new(&root, config));
- try!(ops::publish(&ws, &ops::PublishOpts {
+ let root = find_root_manifest_for_wd(flag_manifest_path.clone(), config.cwd())?;
+ let ws = Workspace::new(&root, config)?;
+ ops::publish(&ws, &ops::PublishOpts {
config: config,
token: token,
index: host,
allow_dirty: allow_dirty,
jobs: jobs,
dry_run: dry_run,
- }));
+ })?;
Ok(None)
}
pub fn execute(options: Options, config: &Config) -> CliResult<Option<Package>> {
debug!("executing; cmd=cargo-read-manifest; args={:?}",
env::args().collect::<Vec<_>>());
- try!(config.shell().set_color_config(options.flag_color.as_ref().map(|s| &s[..])));
+ config.shell().set_color_config(options.flag_color.as_ref().map(|s| &s[..]))?;
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
- let pkg = try!(Package::for_path(&root, config));
+ let pkg = Package::for_path(&root, config)?;
Ok(Some(pkg))
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
let (mut examples, mut bins) = (Vec::new(), Vec::new());
if let Some(s) = options.flag_bin {
target_rustc_args: None,
};
- let ws = try!(Workspace::new(&root, config));
- match try!(ops::run(&ws, &compile_opts, &options.arg_args)) {
+ let ws = Workspace::new(&root, config)?;
+ match ops::run(&ws, &compile_opts, &options.arg_args)? {
None => Ok(None),
Some(err) => {
// If we never actually spawned the process then that sounds pretty
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
debug!("executing; cmd=cargo-rustc; args={:?}",
env::args().collect::<Vec<_>>());
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path,
- config.cwd()));
+ let root = find_root_manifest_for_wd(options.flag_manifest_path,
+ config.cwd())?;
let mode = match options.flag_profile.as_ref().map(|t| &t[..]) {
Some("dev") | None => CompileMode::Build,
Some("test") => CompileMode::Test,
target_rustc_args: options.arg_opts.as_ref().map(|a| &a[..]),
};
- let ws = try!(Workspace::new(&root, config));
- try!(ops::compile(&ws, &opts));
+ let ws = Workspace::new(&root, config)?;
+ ops::compile(&ws, &opts)?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path,
- config.cwd()));
+ let root = find_root_manifest_for_wd(options.flag_manifest_path,
+ config.cwd())?;
let doc_opts = ops::DocOptions {
open_result: options.flag_open,
},
};
- let ws = try!(Workspace::new(&root, config));
- try!(ops::doc(&ws, &doc_opts));
+ let ws = Workspace::new(&root, config)?;
+ ops::doc(&ws, &doc_opts)?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let Options {
flag_host: host,
flag_limit: limit,
..
} = options;
- try!(ops::search(&query.join("+"), config, host, cmp::min(100, limit.unwrap_or(10)) as u8));
+ ops::search(&query.join("+"), config, host, cmp::min(100, limit.unwrap_or(10)) as u8)?;
Ok(None)
}
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
let empty = Vec::new();
let (mode, filter);
},
};
- let ws = try!(Workspace::new(&root, config));
- let err = try!(ops::run_tests(&ws, &ops, &options.arg_args));
+ let ws = Workspace::new(&root, config)?;
+ let err = ops::run_tests(&ws, &ops, &options.arg_args)?;
match err {
None => Ok(None),
Some(err) => {
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
+ options.flag_locked)?;
let root = options.flag_root.as_ref().map(|s| &s[..]);
- try!(ops::uninstall(root, &options.arg_spec, &options.flag_bin, config));
+ ops::uninstall(root, &options.arg_spec, &options.flag_bin, config)?;
Ok(None)
}
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
debug!("executing; cmd=cargo-update; args={:?}", env::args().collect::<Vec<_>>());
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
- let root = try!(find_root_manifest_for_wd(options.flag_manifest_path, config.cwd()));
+ options.flag_locked)?;
+ let root = find_root_manifest_for_wd(options.flag_manifest_path, config.cwd())?;
let update_opts = ops::UpdateOptions {
aggressive: options.flag_aggressive,
config: config,
};
- let ws = try!(Workspace::new(&root, config));
- try!(ops::update_lockfile(&ws, &update_opts));
+ let ws = Workspace::new(&root, config)?;
+ ops::update_lockfile(&ws, &update_opts)?;
Ok(None)
}
";
pub fn execute(args: Flags, config: &Config) -> CliResult<Option<Error>> {
- try!(config.configure(args.flag_verbose,
+ config.configure(args.flag_verbose,
args.flag_quiet,
&args.flag_color,
args.flag_frozen,
- args.flag_locked));
+ args.flag_locked)?;
let mut contents = String::new();
let filename = args.flag_manifest_path.unwrap_or("Cargo.toml".into());
";
pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
- try!(config.configure(options.flag_verbose,
+ config.configure(options.flag_verbose,
options.flag_quiet,
&options.flag_color,
options.flag_frozen,
- options.flag_locked));
- try!(ops::yank(config,
+ options.flag_locked)?;
+ ops::yank(config,
options.arg_crate,
options.flag_vers,
options.flag_token,
options.flag_index,
- options.flag_undo));
+ options.flag_undo)?;
Ok(None)
}
deprecated_extra: Option<(&PackageId, &Config)>)
-> CargoResult<DependencyInner> {
let (specified_req, version_req) = match version {
- Some(v) => (true, try!(DependencyInner::parse_with_deprecated(v, deprecated_extra))),
+ Some(v) => (true, DependencyInner::parse_with_deprecated(v, deprecated_extra)?),
None => (false, VersionReq::any())
};
this warning.
",
req, inside.name(), inside.version(), requirement);
- try!(config.shell().warn(&msg));
+ config.shell().warn(&msg)?;
Ok(requirement)
}
pub fn for_path(manifest_path: &Path, config: &Config) -> CargoResult<Package> {
let path = manifest_path.parent().unwrap();
- let source_id = try!(SourceId::for_path(path));
- let (pkg, _) = try!(ops::read_package(&manifest_path, &source_id,
- config));
+ let source_id = SourceId::for_path(path)?;
+ let (pkg, _) = ops::read_package(&manifest_path, &source_id,
+ config)?;
Ok(pkg)
}
}
pub fn get(&self, id: &PackageId) -> CargoResult<&Package> {
- let slot = try!(self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
+ let slot = self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
internal(format!("couldn't find `{}` in package set", id))
- }));
+ })?;
let slot = &slot.1;
if let Some(pkg) = slot.borrow() {
return Ok(pkg)
}
let mut sources = self.sources.borrow_mut();
- let source = try!(sources.get_mut(id.source_id()).chain_error(|| {
+ let source = sources.get_mut(id.source_id()).chain_error(|| {
internal(format!("couldn't find source for `{}`", id))
- }));
- let pkg = try!(source.download(id).chain_error(|| {
+ })?;
+ let pkg = source.download(id).chain_error(|| {
human("unable to get packages from source")
- }));
+ })?;
assert!(slot.fill(pkg).is_ok());
Ok(slot.borrow().unwrap())
}
impl Decodable for PackageId {
fn decode<D: Decoder>(d: &mut D) -> Result<PackageId, D::Error> {
- let string: String = try!(Decodable::decode(d));
+ let string: String = Decodable::decode(d)?;
let regex = Regex::new(r"^([^ ]+) ([^ ]+) \(([^\)]+)\)$").unwrap();
- let captures = try!(regex.captures(&string).ok_or_else(|| {
+ let captures = regex.captures(&string).ok_or_else(|| {
d.error("invalid serialized PackageId")
- }));
+ })?;
let name = captures.at(1).unwrap();
let version = captures.at(2).unwrap();
let url = captures.at(3).unwrap();
- let version = try!(semver::Version::parse(version).map_err(|_| {
+ let version = semver::Version::parse(version).map_err(|_| {
d.error("invalid version")
- }));
- let source_id = try!(SourceId::from_url(url).map_err(|e| {
+ })?;
+ let source_id = SourceId::from_url(url).map_err(|e| {
d.error(&e.to_string())
- }));
+ })?;
Ok(PackageId {
inner: Arc::new(PackageIdInner {
impl PackageId {
pub fn new<T: ToSemver>(name: &str, version: T,
sid: &SourceId) -> CargoResult<PackageId> {
- let v = try!(version.to_semver().map_err(PackageIdError::InvalidVersion));
+ let v = version.to_semver().map_err(PackageIdError::InvalidVersion)?;
Ok(PackageId {
inner: Arc::new(PackageIdInner {
name: name.to_string(),
impl fmt::Display for PackageId {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
- try!(write!(f, "{} v{}", self.inner.name, self.inner.version));
+ write!(f, "{} v{}", self.inner.name, self.inner.version)?;
if !self.inner.source_id.is_default_registry() {
- try!(write!(f, " ({})", self.inner.source_id));
+ write!(f, " ({})", self.inner.source_id)?;
}
Ok(())
let mut parts = spec.splitn(2, ':');
let name = parts.next().unwrap();
let version = match parts.next() {
- Some(version) => Some(try!(Version::parse(version).map_err(human))),
+ Some(version) => Some(Version::parse(version).map_err(human)?),
None => None,
};
for ch in name.chars() {
pub fn query_str<'a, I>(spec: &str, i: I) -> CargoResult<&'a PackageId>
where I: IntoIterator<Item=&'a PackageId>
{
- let spec = try!(PackageIdSpec::parse(spec).chain_error(|| {
+ let spec = PackageIdSpec::parse(spec).chain_error(|| {
human(format!("invalid package id specification: `{}`", spec))
- }));
+ })?;
spec.query(i)
}
let frag = url.fragment().map(|s| s.to_owned());
url.set_fragment(None);
let (name, version) = {
- let mut path = try!(url.path_segments().chain_error(|| {
+ let mut path = url.path_segments().chain_error(|| {
human(format!("pkgid urls must have a path: {}", url))
- }));
- let path_name = try!(path.next_back().chain_error(|| {
+ })?;
+ let path_name = path.next_back().chain_error(|| {
human(format!("pkgid urls must have at least one path \
component: {}", url))
- }));
+ })?;
match frag {
Some(fragment) => {
let mut parts = fragment.splitn(2, ':');
let name_or_version = parts.next().unwrap();
match parts.next() {
Some(part) => {
- let version = try!(part.to_semver().map_err(human));
+ let version = part.to_semver().map_err(human)?;
(name_or_version.to_string(), Some(version))
}
None => {
.is_alphabetic() {
(name_or_version.to_string(), None)
} else {
- let version = try!(name_or_version.to_semver()
- .map_err(human));
+ let version = name_or_version.to_semver()
+ .map_err(human)?;
(path_name.to_string(), Some(version))
}
}
match self.url {
Some(ref url) => {
if url.scheme() == "cargo" {
- try!(write!(f, "{}{}", url.host().unwrap(), url.path()));
+ write!(f, "{}{}", url.host().unwrap(), url.path())?;
} else {
- try!(write!(f, "{}", url));
+ write!(f, "{}", url)?;
}
if url.path_segments().unwrap().next_back().unwrap() != &self.name {
printed_name = true;
- try!(write!(f, "#{}", self.name));
+ write!(f, "#{}", self.name)?;
}
}
- None => { printed_name = true; try!(write!(f, "{}", self.name)) }
+ None => { printed_name = true; write!(f, "{}", self.name)? }
}
match self.version {
Some(ref v) => {
- try!(write!(f, "{}{}", if printed_name {":"} else {"#"}, v));
+ write!(f, "{}{}", if printed_name {":"} else {"#"}, v)?;
}
None => {}
}
impl<'cfg> PackageRegistry<'cfg> {
pub fn new(config: &'cfg Config) -> CargoResult<PackageRegistry<'cfg>> {
- let source_config = try!(SourceConfigMap::new(config));
+ let source_config = SourceConfigMap::new(config)?;
Ok(PackageRegistry {
sources: SourceMap::new(),
source_ids: HashMap::new(),
}
}
- try!(self.load(namespace, kind));
+ self.load(namespace, kind)?;
Ok(())
}
pub fn add_sources(&mut self, ids: &[SourceId]) -> CargoResult<()> {
for id in ids.iter() {
- try!(self.ensure_loaded(id, Kind::Locked));
+ self.ensure_loaded(id, Kind::Locked)?;
}
Ok(())
}
fn load(&mut self, source_id: &SourceId, kind: Kind) -> CargoResult<()> {
(|| {
- let source = try!(self.source_config.load(source_id));
+ let source = self.source_config.load(source_id)?;
if kind == Kind::Override {
self.overrides.push(source_id.clone());
for s in self.overrides.iter() {
let src = self.sources.get_mut(s).unwrap();
let dep = Dependency::new_override(dep.name(), s);
- let mut results = try!(src.query(&dep));
+ let mut results = src.query(&dep)?;
if results.len() > 0 {
return Ok(Some(results.remove(0)))
}
override_summary: &Summary,
real_summary: &Summary) -> CargoResult<()> {
let real = real_summary.package_id();
- let map = try!(self.locked.get(real.source_id()).chain_error(|| {
+ let map = self.locked.get(real.source_id()).chain_error(|| {
human(format!("failed to find lock source of {}", real))
- }));
- let list = try!(map.get(real.name()).chain_error(|| {
+ })?;
+ let list = map.get(real.name()).chain_error(|| {
human(format!("failed to find lock name of {}", real))
- }));
- let &(_, ref real_deps) = try!(list.iter().find(|&&(ref id, _)| {
+ })?;
+ let &(_, ref real_deps) = list.iter().find(|&&(ref id, _)| {
real == id
}).chain_error(|| {
human(format!("failed to find lock version of {}", real))
- }));
+ })?;
let mut real_deps = real_deps.clone();
let boilerplate = "\
dependencies; the dependency on `{}` was either added or\n\
modified to not match the previously resolved version\n\n\
{}", override_summary.package_id().name(), dep.name(), boilerplate);
- try!(self.source_config.config().shell().warn(&msg));
+ self.source_config.config().shell().warn(&msg)?;
return Ok(())
}
path override for crate `{}` has altered the original list of
dependencies; the dependency on `{}` was removed\n\n
{}", override_summary.package_id().name(), id.name(), boilerplate);
- try!(self.source_config.config().shell().warn(&msg));
+ self.source_config.config().shell().warn(&msg)?;
return Ok(())
}
impl<'cfg> Registry for PackageRegistry<'cfg> {
fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
// Ensure the requested source_id is loaded
- try!(self.ensure_loaded(dep.source_id(), Kind::Normal).chain_error(|| {
+ self.ensure_loaded(dep.source_id(), Kind::Normal).chain_error(|| {
human(format!("failed to load source for a dependency \
on `{}`", dep.name()))
- }));
+ })?;
- let override_summary = try!(self.query_overrides(&dep));
+ let override_summary = self.query_overrides(&dep)?;
let real_summaries = match self.sources.get_mut(dep.source_id()) {
- Some(src) => Some(try!(src.query(&dep))),
+ Some(src) => Some(src.query(&dep)?),
None => None,
};
if summaries.len() != 1 {
bail!("found an override with a non-locked list");
}
- try!(self.warn_bad_override(&candidate, &summaries[0]));
+ self.warn_bad_override(&candidate, &summaries[0])?;
vec![candidate]
}
(Some(_), None) => bail!("override found but no real ones"),
// We failed to find a local package in the workspace.
// It must have been removed and should be ignored.
None => continue,
- Some(source) => try!(PackageId::new(&pkg.name, &pkg.version, source))
+ Some(source) => PackageId::new(&pkg.name, &pkg.version, source)?
};
assert!(live_pkgs.insert(enc_id, (id, pkg)).is_none())
};
for edge in deps.iter() {
- if let Some(to_depend_on) = try!(lookup_id(edge)) {
+ if let Some(to_depend_on) = lookup_id(edge)? {
g.link(id.clone(), to_depend_on);
}
}
for &(ref id, ref pkg) in live_pkgs.values() {
if let Some(ref replace) = pkg.replace {
assert!(pkg.dependencies.is_none());
- if let Some(replace_id) = try!(lookup_id(replace)) {
+ if let Some(replace_id) = lookup_id(replace)? {
replacements.insert(id.clone(), replace_id);
}
}
for (k, v) in metadata.iter().filter(|p| p.0.starts_with(prefix)) {
to_remove.push(k.to_string());
let k = &k[prefix.len()..];
- let enc_id: EncodablePackageId = try!(k.parse().chain_error(|| {
+ let enc_id: EncodablePackageId = k.parse().chain_error(|| {
internal("invalid encoding of checksum in lockfile")
- }));
+ })?;
let id = match lookup_id(&enc_id) {
Ok(Some(id)) => id,
_ => continue,
impl fmt::Display for EncodablePackageId {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{} {}", self.name, self.version));
+ write!(f, "{} {}", self.name, self.version)?;
if let Some(ref s) = self.source {
- try!(write!(f, " ({})", s.to_url()));
+ write!(f, " ({})", s.to_url())?;
}
Ok(())
}
fn from_str(s: &str) -> CargoResult<EncodablePackageId> {
let regex = Regex::new(r"^([^ ]+) ([^ ]+)(?: \(([^\)]+)\))?$").unwrap();
- let captures = try!(regex.captures(s).ok_or_else(|| {
+ let captures = regex.captures(s).ok_or_else(|| {
internal("invalid serialized PackageId")
- }));
+ })?;
let name = captures.at(1).unwrap();
let version = captures.at(2).unwrap();
let source_id = match captures.at(3) {
- Some(s) => Some(try!(SourceId::from_url(s))),
+ Some(s) => Some(SourceId::from_url(s)?),
None => None,
};
impl fmt::Debug for Resolve {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(fmt, "graph: {:?}\n", self.graph));
- try!(write!(fmt, "\nfeatures: {{\n"));
+ write!(fmt, "graph: {:?}\n", self.graph)?;
+ write!(fmt, "\nfeatures: {{\n")?;
for (pkg, features) in &self.features {
- try!(write!(fmt, " {}: {:?}\n", pkg, features));
+ write!(fmt, " {}: {:?}\n", pkg, features)?;
}
write!(fmt, "}}")
}
replacements: replacements,
};
let _p = profile::start(format!("resolving"));
- let cx = try!(activate_deps_loop(cx, registry, summaries));
+ let cx = activate_deps_loop(cx, registry, summaries)?;
let mut resolve = Resolve {
graph: cx.resolve_graph,
resolve.checksums.insert(summary.package_id().clone(), cksum);
}
- try!(check_cycles(&resolve, &cx.activations));
+ check_cycles(&resolve, &cx.activations)?;
trace!("resolved: {:?}", resolve);
Ok(resolve)
}
};
- let deps = try!(cx.build_deps(registry, &candidate, method));
+ let deps = cx.build_deps(registry, &candidate, method)?;
Ok(Some(DepsFrame {
parent: candidate,
debug!("initial activation: {}", summary.package_id());
let summary = Rc::new(summary.clone());
let candidate = Candidate { summary: summary, replace: None };
- remaining_deps.extend(try!(activate(&mut cx, registry, None, candidate,
- method)));
+ remaining_deps.extend(activate(&mut cx, registry, None, candidate,
+ method)?);
}
// Main resolution loop, this is the workhorse of the resolution algorithm.
};
trace!("{}[{}]>{} trying {}", parent.name(), cur, dep.name(),
candidate.summary.version());
- remaining_deps.extend(try!(activate(&mut cx, registry, Some(&parent),
- candidate, &method)));
+ remaining_deps.extend(activate(&mut cx, registry, Some(&parent),
+ candidate, &method)?);
}
Ok(cx)
match *method {
Method::Everything => {
for key in s.features().keys() {
- try!(add_feature(s, key, &mut deps, &mut used, &mut visited));
+ add_feature(s, key, &mut deps, &mut used, &mut visited)?;
}
for dep in s.dependencies().iter().filter(|d| d.is_optional()) {
- try!(add_feature(s, dep.name(), &mut deps, &mut used,
- &mut visited));
+ add_feature(s, dep.name(), &mut deps, &mut used,
+ &mut visited)?;
}
}
Method::Required { features: requested_features, .. } => {
for feat in requested_features.iter() {
- try!(add_feature(s, feat, &mut deps, &mut used, &mut visited));
+ add_feature(s, feat, &mut deps, &mut used, &mut visited)?;
}
}
}
Method::Everything |
Method::Required { uses_default_features: true, .. } => {
if s.features().get("default").is_some() {
- try!(add_feature(s, "default", &mut deps, &mut used,
- &mut visited));
+ add_feature(s, "default", &mut deps, &mut used,
+ &mut visited)?;
}
}
Method::Required { uses_default_features: false, .. } => {}
match s.features().get(feat) {
Some(recursive) => {
for f in recursive {
- try!(add_feature(s, f, deps, used, visited));
+ add_feature(s, f, deps, used, visited)?;
}
}
None => {
// First, figure out our set of dependencies based on the requsted set
// of features. This also calculates what features we're going to enable
// for our own dependencies.
- let deps = try!(self.resolve_features(candidate, method));
+ let deps = self.resolve_features(candidate, method)?;
// Next, transform all dependencies into a list of possible candidates
// which can satisfy that dependency.
- let mut deps = try!(deps.into_iter().map(|(dep, features)| {
- let mut candidates = try!(self.query(registry, &dep));
+ let mut deps = deps.into_iter().map(|(dep, features)| {
+ let mut candidates = self.query(registry, &dep)?;
// When we attempt versions for a package, we'll want to start at
// the maximum version and work our way down.
candidates.sort_by(|a, b| {
b.summary.version().cmp(a.summary.version())
});
Ok((dep, candidates, features))
- }).collect::<CargoResult<Vec<DepInfo>>>());
+ }).collect::<CargoResult<Vec<DepInfo>>>()?;
// Attempt to resolve dependencies with fewer candidates before trying
// dependencies with more candidates. This way if the dependency with
fn query(&self,
registry: &mut Registry,
dep: &Dependency) -> CargoResult<Vec<Candidate>> {
- let summaries = try!(registry.query(dep));
+ let summaries = registry.query(dep)?;
summaries.into_iter().map(Rc::new).map(|summary| {
// get around lack of non-lexical lifetimes
let summary2 = summary.clone();
};
debug!("found an override for {} {}", dep.name(), dep.version_req());
- let mut summaries = try!(registry.query(dep)).into_iter();
- let s = try!(summaries.next().chain_error(|| {
+ let mut summaries = registry.query(dep)?.into_iter();
+ let s = summaries.next().chain_error(|| {
human(format!("no matching package for override `{}` found\n\
location searched: {}\n\
version required: {}",
spec, dep.source_id(), dep.version_req()))
- }));
+ })?;
let summaries = summaries.collect::<Vec<_>>();
if summaries.len() > 0 {
let bullets = summaries.iter().map(|s| {
let deps = candidate.dependencies();
let deps = deps.iter().filter(|d| d.is_transitive() || dev_deps);
- let (mut feature_deps, used_features) = try!(build_features(candidate,
- method));
+ let (mut feature_deps, used_features) = build_features(candidate,
+ method)?;
let mut ret = Vec::new();
// Next, sanitize all requested features by whitelisting all the
let mut checked = HashSet::new();
for pkg in all_packages {
if !checked.contains(pkg) {
- try!(visit(resolve,
+ visit(resolve,
pkg,
&summaries,
&mut HashSet::new(),
- &mut checked))
+ &mut checked)?
}
}
return Ok(());
});
let mut empty = HashSet::new();
let visited = if is_transitive {&mut *visited} else {&mut empty};
- try!(visit(resolve, dep, summaries, visited, checked));
+ visit(resolve, dep, summaries, visited, checked)?;
}
}
fn get_term(out: Box<Write + Send>) -> CargoResult<AdequateTerminal> {
// Check if the creation of a console will succeed
if ::term::WinConsole::new(vec![0u8; 0]).is_ok() {
- let t = try!(::term::WinConsole::new(out));
+ let t = ::term::WinConsole::new(out)?;
if !t.supports_color() {
Ok(NoColor(Box::new(t)))
} else {
}
pub fn say<T: ToString>(&mut self, message: T, color: Color) -> CargoResult<()> {
- try!(self.reset());
- if color != BLACK { try!(self.fg(color)); }
- try!(write!(self, "{}\n", message.to_string()));
- try!(self.reset());
- try!(self.flush());
+ self.reset()?;
+ if color != BLACK { self.fg(color)?; }
+ write!(self, "{}\n", message.to_string())?;
+ self.reset()?;
+ self.flush()?;
Ok(())
}
-> CargoResult<()>
where T: fmt::Display, U: fmt::Display
{
- try!(self.reset());
- if color != BLACK { try!(self.fg(color)); }
- if self.supports_attr(Attr::Bold) { try!(self.attr(Attr::Bold)); }
+ self.reset()?;
+ if color != BLACK { self.fg(color)?; }
+ if self.supports_attr(Attr::Bold) { self.attr(Attr::Bold)?; }
if justified {
- try!(write!(self, "{:>12}", status.to_string()));
+ write!(self, "{:>12}", status.to_string())?;
} else {
- try!(write!(self, "{}", status));
+ write!(self, "{}", status)?;
}
- try!(self.reset());
- try!(write!(self, " {}\n", message));
- try!(self.flush());
+ self.reset()?;
+ write!(self, " {}\n", message)?;
+ self.flush()?;
Ok(())
}
let colored = self.colored();
match self.terminal {
- Colored(ref mut c) if colored => try!(c.fg(color)),
+ Colored(ref mut c) if colored => c.fg(color)?,
_ => return Ok(false),
}
Ok(true)
let colored = self.colored();
match self.terminal {
- Colored(ref mut c) if colored => try!(c.attr(attr)),
+ Colored(ref mut c) if colored => c.attr(attr)?,
_ => return Ok(false)
}
Ok(true)
let colored = self.colored();
match self.terminal {
- Colored(ref mut c) if colored => try!(c.reset()),
+ Colored(ref mut c) if colored => c.reset()?,
_ => ()
}
Ok(())
pub fn from_url(string: &str) -> CargoResult<SourceId> {
let mut parts = string.splitn(2, '+');
let kind = parts.next().unwrap();
- let url = try!(parts.next().ok_or(human(format!("invalid source `{}`", string))));
+ let url = parts.next().ok_or(human(format!("invalid source `{}`", string)))?;
match kind {
"git" => {
- let mut url = try!(url.to_url());
+ let mut url = url.to_url()?;
let mut reference = GitReference::Branch("master".to_string());
for (k, v) in url.query_pairs() {
match &k[..] {
Ok(SourceId::for_git(&url, reference).with_precise(precise))
},
"registry" => {
- let url = try!(url.to_url());
+ let url = url.to_url()?;
Ok(SourceId::new(Kind::Registry, url)
.with_precise(Some("locked".to_string())))
}
"path" => {
- let url = try!(url.to_url());
+ let url = url.to_url()?;
Ok(SourceId::new(Kind::Path, url))
}
kind => Err(human(format!("unsupported source protocol: {}", kind)))
// Pass absolute path
pub fn for_path(path: &Path) -> CargoResult<SourceId> {
- let url = try!(path.to_url());
+ let url = path.to_url()?;
Ok(SourceId::new(Kind::Path, url))
}
}
pub fn for_local_registry(path: &Path) -> CargoResult<SourceId> {
- let url = try!(path.to_url());
+ let url = path.to_url()?;
Ok(SourceId::new(Kind::LocalRegistry, url))
}
pub fn for_directory(path: &Path) -> CargoResult<SourceId> {
- let url = try!(path.to_url());
+ let url = path.to_url()?;
Ok(SourceId::new(Kind::Directory, url))
}
/// This is the main cargo registry by default, but it can be overridden in
/// a `.cargo/config`.
pub fn crates_io(config: &Config) -> CargoResult<SourceId> {
- let cfg = try!(ops::registry_configuration(config));
+ let cfg = ops::registry_configuration(config)?;
let url = if let Some(ref index) = cfg.index {
static WARNED: AtomicBool = ATOMIC_BOOL_INIT;
if !WARNED.swap(true, SeqCst) {
- try!(config.shell().warn("custom registry support via \
+ config.shell().warn("custom registry support via \
the `registry.index` configuration is \
being removed, this functionality \
- will not work in the future"));
+ will not work in the future")?;
}
&index[..]
} else {
CRATES_IO
};
- let url = try!(url.to_url());
+ let url = url.to_url()?;
Ok(SourceId::for_registry(&url))
}
impl Decodable for SourceId {
fn decode<D: Decoder>(d: &mut D) -> Result<SourceId, D::Error> {
- let string: String = try!(Decodable::decode(d));
+ let string: String = Decodable::decode(d)?;
SourceId::from_url(&string).map_err(|e| {
d.error(&e.to_string())
})
}
SourceIdInner { kind: Kind::Git(ref reference), ref url,
ref precise, .. } => {
- try!(write!(f, "{}{}", url, reference.url_ref()));
+ write!(f, "{}{}", url, reference.url_ref())?;
if let Some(ref s) = *precise {
let len = cmp::min(s.len(), 8);
- try!(write!(f, "#{}", &s[..len]));
+ write!(f, "#{}", &s[..len])?;
}
Ok(())
}
/// before returning it, so `Ok` is only returned for valid workspaces.
pub fn new(manifest_path: &Path, config: &'cfg Config)
-> CargoResult<Workspace<'cfg>> {
- let target_dir = try!(config.target_dir());
+ let target_dir = config.target_dir()?;
let mut ws = Workspace {
config: config,
target_dir: target_dir,
members: Vec::new(),
};
- ws.root_manifest = try!(ws.find_root(manifest_path));
- try!(ws.find_members());
- try!(ws.validate());
+ ws.root_manifest = ws.find_root(manifest_path)?;
+ ws.find_members()?;
+ ws.validate()?;
Ok(ws)
}
ws.target_dir = if let Some(dir) = target_dir {
Some(dir)
} else {
- try!(ws.config.target_dir())
+ ws.config.target_dir()?
};
ws.members.push(ws.current_manifest.clone());
}
fn find_root(&mut self, manifest_path: &Path)
-> CargoResult<Option<PathBuf>> {
{
- let current = try!(self.packages.load(&manifest_path));
+ let current = self.packages.load(&manifest_path)?;
match *current.workspace_config() {
WorkspaceConfig::Root { .. } => {
debug!("find_root - is root {}", manifest_path.display());
}
};
let members = {
- let root = try!(self.packages.load(&root_manifest));
+ let root = self.packages.load(&root_manifest)?;
match *root.workspace_config() {
WorkspaceConfig::Root { ref members } => members.clone(),
_ => bail!("root of a workspace inferred but wasn't a root: {}",
let root = root_manifest.parent().unwrap();
for path in list {
let manifest_path = root.join(path).join("Cargo.toml");
- try!(self.find_path_deps(&manifest_path));
+ self.find_path_deps(&manifest_path)?;
}
}
self.members.push(manifest_path.to_path_buf());
let candidates = {
- let pkg = match *try!(self.packages.load(manifest_path)) {
+ let pkg = match *self.packages.load(manifest_path)? {
MaybePackage::Package(ref p) => p,
MaybePackage::Virtual(_) => return Ok(()),
};
.collect::<Vec<_>>()
};
for candidate in candidates {
- try!(self.find_path_deps(&candidate));
+ self.find_path_deps(&candidate)?;
}
Ok(())
}
}
for member in self.members.clone() {
- let root = try!(self.find_root(&member));
+ let root = self.find_root(&member)?;
if root == self.root_manifest {
continue
}
root_manifest.display());
//TODO: remove `Eq` bound from `Profiles` when the warning is removed.
- try!(self.config.shell().warn(&message));
+ self.config.shell().warn(&message)?;
}
}
}
match self.packages.entry(key.to_path_buf()) {
Entry::Occupied(e) => Ok(e.into_mut()),
Entry::Vacant(v) => {
- let source_id = try!(SourceId::for_path(key));
- let pair = try!(ops::read_manifest(&manifest_path, &source_id,
- self.config));
+ let source_id = SourceId::for_path(key)?;
+ let pair = ops::read_manifest(&manifest_path, &source_id,
+ self.config)?;
let (manifest, _nested_paths) = pair;
Ok(v.insert(match manifest {
EitherManifest::Real(manifest) => {
options_first: bool) -> CliResult<Option<V>>
where V: Encodable, T: Decodable
{
- let flags = try!(flags_from_args::<T>(usage, args, options_first));
+ let flags = flags_from_args::<T>(usage, args, options_first)?;
exec(flags, config)
}
{
let mut config = None;
let result = (|| {
- config = Some(try!(Config::default()));
+ config = Some(Config::default()?);
let args: Vec<_> = try!(env::args_os().map(|s| {
s.into_string().map_err(|s| {
human(format!("invalid unicode in argument: {:?}", s))
return rm_rf(&target_dir);
}
- let mut registry = try!(PackageRegistry::new(opts.config));
- let resolve = try!(ops::resolve_ws(&mut registry, ws));
+ let mut registry = PackageRegistry::new(opts.config)?;
+ let resolve = ops::resolve_ws(&mut registry, ws)?;
let packages = ops::get_resolved_packages(&resolve, registry);
let profiles = ws.profiles();
- let host_triple = try!(opts.config.rustc()).host.clone();
- let mut cx = try!(Context::new(ws, &resolve, &packages, opts.config,
+ let host_triple = opts.config.rustc()?.host.clone();
+ let mut cx = Context::new(ws, &resolve, &packages, opts.config,
BuildConfig {
host_triple: host_triple,
requested_target: opts.target.map(|s| s.to_owned()),
release: opts.release,
..BuildConfig::default()
},
- profiles));
+ profiles)?;
let mut units = Vec::new();
for spec in opts.spec {
// Translate the spec to a Package
- let pkgid = try!(resolve.query(spec));
- let pkg = try!(packages.get(&pkgid));
+ let pkgid = resolve.query(spec)?;
+ let pkg = packages.get(&pkgid)?;
// Generate all relevant `Unit` targets for this package
for target in pkg.targets() {
}
}
- try!(cx.probe_target_info(&units));
+ cx.probe_target_info(&units)?;
for unit in units.iter() {
let layout = cx.layout(unit);
- try!(rm_rf(&layout.proxy().fingerprint(&unit.pkg)));
- try!(rm_rf(&layout.build(&unit.pkg)));
+ rm_rf(&layout.proxy().fingerprint(&unit.pkg))?;
+ rm_rf(&layout.build(&unit.pkg))?;
let root = cx.out_dir(&unit);
- for (filename, _) in try!(cx.target_filenames(&unit)) {
- try!(rm_rf(&root.join(&filename)));
+ for (filename, _) in cx.target_filenames(&unit)? {
+ rm_rf(&root.join(&filename))?;
}
}
fn rm_rf(path: &Path) -> CargoResult<()> {
let m = fs::metadata(path);
if m.as_ref().map(|s| s.is_dir()).unwrap_or(false) {
- try!(fs::remove_dir_all(path).chain_error(|| {
+ fs::remove_dir_all(path).chain_error(|| {
human("could not remove build directory")
- }));
+ })?;
} else if m.is_ok() {
- try!(fs::remove_file(path).chain_error(|| {
+ fs::remove_file(path).chain_error(|| {
human("failed to remove build artifact")
- }));
+ })?;
}
Ok(())
}
pub fn compile<'a>(ws: &Workspace<'a>, options: &CompileOptions<'a>)
-> CargoResult<ops::Compilation<'a>> {
- for key in try!(ws.current()).manifest().warnings().iter() {
- try!(options.config.shell().warn(key))
+ for key in ws.current()?.manifest().warnings().iter() {
+ options.config.shell().warn(key)?
}
compile_ws(ws, None, options)
}
s.split_whitespace()
}).map(|s| s.to_string()).collect::<Vec<String>>();
- let mut registry = try!(PackageRegistry::new(ws.config()));
+ let mut registry = PackageRegistry::new(ws.config())?;
if let Some(source) = source {
- registry.add_preloaded(try!(ws.current()).package_id().source_id(),
+ registry.add_preloaded(ws.current()?.package_id().source_id(),
source);
}
// First, resolve the root_package's *listed* dependencies, as well as
// downloading and updating all remotes and such.
- let resolve = try!(ops::resolve_ws(&mut registry, ws));
+ let resolve = ops::resolve_ws(&mut registry, ws)?;
// Second, resolve with precisely what we're doing. Filter out
// transitive dependencies if necessary, specify features, handle
// overrides, etc.
let _p = profile::start("resolving w/ overrides...");
- try!(add_overrides(&mut registry, ws));
+ add_overrides(&mut registry, ws)?;
let method = if all_features {
Method::Everything
};
let resolved_with_overrides =
- try!(ops::resolve_with_previous(&mut registry, ws,
+ ops::resolve_with_previous(&mut registry, ws,
method, Some(&resolve), None,
- specs));
+ specs)?;
let packages = ops::get_resolved_packages(&resolved_with_overrides,
registry);
source: Option<Box<Source + 'a>>,
options: &CompileOptions<'a>)
-> CargoResult<ops::Compilation<'a>> {
- let root_package = try!(ws.current());
+ let root_package = ws.current()?;
let CompileOptions { config, jobs, target, spec, features,
all_features, no_default_features,
release, mode, message_format,
let profiles = ws.profiles();
if spec.len() == 0 {
- try!(generate_targets(root_package, profiles, mode, filter, release));
+ generate_targets(root_package, profiles, mode, filter, release)?;
}
- let specs = try!(spec.iter().map(|p| PackageIdSpec::parse(p))
- .collect::<CargoResult<Vec<_>>>());
+ let specs = spec.iter().map(|p| PackageIdSpec::parse(p))
+ .collect::<CargoResult<Vec<_>>>()?;
- let pair = try!(resolve_dependencies(ws,
+ let pair = resolve_dependencies(ws,
source,
features,
all_features,
no_default_features,
- &specs));
+ &specs)?;
let (packages, resolve_with_overrides) = pair;
let mut pkgids = Vec::new();
if spec.len() > 0 {
for p in spec {
- pkgids.push(try!(resolve_with_overrides.query(&p)));
+ pkgids.push(resolve_with_overrides.query(&p)?);
}
} else {
pkgids.push(root_package.package_id());
};
- let to_builds = try!(pkgids.iter().map(|id| {
+ let to_builds = pkgids.iter().map(|id| {
packages.get(id)
- }).collect::<CargoResult<Vec<_>>>());
+ }).collect::<CargoResult<Vec<_>>>()?;
let mut general_targets = Vec::new();
let mut package_targets = Vec::new();
panic!("`rustc` and `rustdoc` should not accept multiple `-p` flags")
}
(Some(args), _) => {
- let targets = try!(generate_targets(to_builds[0], profiles,
- mode, filter, release));
+ let targets = generate_targets(to_builds[0], profiles,
+ mode, filter, release)?;
if targets.len() == 1 {
let (target, profile) = targets[0];
let mut profile = profile.clone();
}
}
(None, Some(args)) => {
- let targets = try!(generate_targets(to_builds[0], profiles,
- mode, filter, release));
+ let targets = generate_targets(to_builds[0], profiles,
+ mode, filter, release)?;
if targets.len() == 1 {
let (target, profile) = targets[0];
let mut profile = profile.clone();
}
(None, None) => {
for &to_build in to_builds.iter() {
- let targets = try!(generate_targets(to_build, profiles, mode,
- filter, release));
+ let targets = generate_targets(to_build, profiles, mode,
+ filter, release)?;
package_targets.push((to_build, targets));
}
}
let mut ret = {
let _p = profile::start("compiling");
- let mut build_config = try!(scrape_build_config(config, jobs, target));
+ let mut build_config = scrape_build_config(config, jobs, target)?;
build_config.release = release;
build_config.test = mode == CompileMode::Test || mode == CompileMode::Bench;
build_config.json_errors = message_format == MessageFormat::Json;
build_config.doc_all = deps;
}
- try!(ops::compile_targets(ws,
+ ops::compile_targets(ws,
&package_targets,
&packages,
&resolve_with_overrides,
config,
build_config,
- profiles))
+ profiles)?
};
ret.to_doc_test = to_builds.iter().map(|&p| p.clone()).collect();
}
Ok(())
};
- try!(find(bins, "bin", TargetKind::Bin, profile));
- try!(find(examples, "example", TargetKind::Example, build));
- try!(find(tests, "test", TargetKind::Test, test));
- try!(find(benches, "bench", TargetKind::Bench, &profiles.bench));
+ find(bins, "bin", TargetKind::Bin, profile)?;
+ find(examples, "example", TargetKind::Example, build)?;
+ find(tests, "test", TargetKind::Test, test)?;
+ find(benches, "bench", TargetKind::Bench, &profiles.bench)?;
}
Ok(targets)
}
/// have been configured.
fn add_overrides<'a>(registry: &mut PackageRegistry<'a>,
ws: &Workspace<'a>) -> CargoResult<()> {
- let paths = match try!(ws.config().get_list("paths")) {
+ let paths = match ws.config().get_list("paths")? {
Some(list) => list,
None => return Ok(())
};
});
for (path, definition) in paths {
- let id = try!(SourceId::for_path(&path));
+ let id = SourceId::for_path(&path)?;
let mut source = PathSource::new_recursive(&path, &id, ws.config());
- try!(source.update().chain_error(|| {
+ source.update().chain_error(|| {
human(format!("failed to update path override `{}` \
(defined in `{}`)", path.display(),
definition.display()))
- }));
+ })?;
registry.add_override(&id, Box::new(source));
}
Ok(())
jobs: Option<u32>,
target: Option<String>)
-> CargoResult<ops::BuildConfig> {
- let cfg_jobs = match try!(config.get_i64("build.jobs")) {
+ let cfg_jobs = match config.get_i64("build.jobs")? {
Some(v) => {
if v.val <= 0 {
bail!("build.jobs must be positive, but found {} in {}",
None => None,
};
let jobs = jobs.or(cfg_jobs).unwrap_or(::num_cpus::get() as u32);
- let cfg_target = try!(config.get_string("build.target")).map(|s| s.val);
+ let cfg_target = config.get_string("build.target")?.map(|s| s.val);
let target = target.or(cfg_target);
let mut base = ops::BuildConfig {
- host_triple: try!(config.rustc()).host.clone(),
+ host_triple: config.rustc()?.host.clone(),
requested_target: target.clone(),
jobs: jobs,
..Default::default()
};
- base.host = try!(scrape_target_config(config, &base.host_triple));
+ base.host = scrape_target_config(config, &base.host_triple)?;
base.target = match target.as_ref() {
- Some(triple) => try!(scrape_target_config(config, &triple)),
+ Some(triple) => scrape_target_config(config, &triple)?,
None => base.host.clone(),
};
Ok(base)
let key = format!("target.{}", triple);
let mut ret = ops::TargetConfig {
- ar: try!(config.get_path(&format!("{}.ar", key))).map(|v| v.val),
- linker: try!(config.get_path(&format!("{}.linker", key))).map(|v| v.val),
+ ar: config.get_path(&format!("{}.ar", key))?.map(|v| v.val),
+ linker: config.get_path(&format!("{}.linker", key))?.map(|v| v.val),
overrides: HashMap::new(),
};
- let table = match try!(config.get_table(&key)) {
+ let table = match config.get_table(&key)? {
Some(table) => table.val,
None => return Ok(ret),
};
rerun_if_changed: Vec::new(),
warnings: Vec::new(),
};
- for (k, value) in try!(value.table(&lib_name)).0 {
+ for (k, value) in value.table(&lib_name)?.0 {
let key = format!("{}.{}", key, k);
match &k[..] {
"rustc-flags" => {
- let (flags, definition) = try!(value.string(&k));
+ let (flags, definition) = value.string(&k)?;
let whence = format!("in `{}` (in {})", key,
definition.display());
- let (paths, links) = try!(
+ let (paths, links) =
BuildOutput::parse_rustc_flags(&flags, &whence)
- );
+ ?;
output.library_paths.extend(paths);
output.library_links.extend(links);
}
"rustc-link-lib" => {
- let list = try!(value.list(&k));
+ let list = value.list(&k)?;
output.library_links.extend(list.iter()
.map(|v| v.0.clone()));
}
"rustc-link-search" => {
- let list = try!(value.list(&k));
+ let list = value.list(&k)?;
output.library_paths.extend(list.iter().map(|v| {
PathBuf::from(&v.0)
}));
}
"rustc-cfg" => {
- let list = try!(value.list(&k));
+ let list = value.list(&k)?;
output.cfgs.extend(list.iter().map(|v| v.0.clone()));
}
_ => {
- let val = try!(value.string(&k)).0;
+ let val = value.string(&k)?.0;
output.metadata.push((k.clone(), val.to_string()));
}
}
}
pub fn doc(ws: &Workspace, options: &DocOptions) -> CargoResult<()> {
- let package = try!(ws.current());
+ let package = ws.current()?;
let mut lib_names = HashSet::new();
let mut bin_names = HashSet::new();
}
}
- try!(ops::compile(ws, &options.compile_opts));
+ ops::compile(ws, &options.compile_opts)?;
if options.open_result {
let name = if options.compile_opts.spec.len() > 1 {
bail!("Passing multiple packages and `open` is not supported")
} else if options.compile_opts.spec.len() == 1 {
- try!(PackageIdSpec::parse(&options.compile_opts.spec[0]))
+ PackageIdSpec::parse(&options.compile_opts.spec[0])?
.name()
.replace("-", "_")
} else {
if fs::metadata(&path).is_ok() {
let mut shell = options.compile_opts.config.shell();
match open_docs(&path) {
- Ok(m) => try!(shell.status("Launching", m)),
+ Ok(m) => shell.status("Launching", m)?,
Err(e) => {
- try!(shell.warn(
- "warning: could not determine a browser to open docs with, tried:"));
+ shell.warn(
+ "warning: could not determine a browser to open docs with, tried:")?;
for method in e {
- try!(shell.warn(format!("\t{}", method)));
+ shell.warn(format!("\t{}", method))?;
}
}
}
/// Executes `cargo fetch`.
pub fn fetch<'a>(ws: &Workspace<'a>) -> CargoResult<(Resolve, PackageSet<'a>)> {
- let mut registry = try!(PackageRegistry::new(ws.config()));
- let resolve = try!(ops::resolve_ws(&mut registry, ws));
+ let mut registry = PackageRegistry::new(ws.config())?;
+ let resolve = ops::resolve_ws(&mut registry, ws)?;
let packages = get_resolved_packages(&resolve, registry);
for id in resolve.iter() {
- try!(packages.get(id));
+ packages.get(id)?;
}
Ok((resolve, packages))
}
}
pub fn generate_lockfile(ws: &Workspace) -> CargoResult<()> {
- let mut registry = try!(PackageRegistry::new(ws.config()));
- let resolve = try!(ops::resolve_with_previous(&mut registry, ws,
+ let mut registry = PackageRegistry::new(ws.config())?;
+ let resolve = ops::resolve_with_previous(&mut registry, ws,
Method::Everything,
- None, None, &[]));
- try!(ops::write_pkg_lockfile(ws, &resolve));
+ None, None, &[])?;
+ ops::write_pkg_lockfile(ws, &resolve)?;
Ok(())
}
bail!("you can't generate a lockfile for an empty workspace.")
}
- let previous_resolve = match try!(ops::load_pkg_lockfile(ws)) {
+ let previous_resolve = match ops::load_pkg_lockfile(ws)? {
Some(resolve) => resolve,
None => return generate_lockfile(ws),
};
- let mut registry = try!(PackageRegistry::new(opts.config));
+ let mut registry = PackageRegistry::new(opts.config)?;
let mut to_avoid = HashSet::new();
if opts.to_update.is_empty() {
} else {
let mut sources = Vec::new();
for name in opts.to_update {
- let dep = try!(previous_resolve.query(name));
+ let dep = previous_resolve.query(name)?;
if opts.aggressive {
fill_with_deps(&previous_resolve, dep, &mut to_avoid,
&mut HashSet::new());
});
}
}
- try!(registry.add_sources(&sources));
+ registry.add_sources(&sources)?;
}
- let resolve = try!(ops::resolve_with_previous(&mut registry,
+ let resolve = ops::resolve_with_previous(&mut registry,
ws,
Method::Everything,
Some(&previous_resolve),
Some(&to_avoid),
- &[]));
+ &[])?;
// Summarize what is changing for the user.
let print_change = |status: &str, msg: String| {
} else {
format!("{} -> v{}", removed[0], added[0].version())
};
- try!(print_change("Updating", msg));
+ print_change("Updating", msg)?;
} else {
for package in removed.iter() {
- try!(print_change("Removing", format!("{}", package)));
+ print_change("Removing", format!("{}", package))?;
}
for package in added.iter() {
- try!(print_change("Adding", format!("{}", package)));
+ print_change("Adding", format!("{}", package))?;
}
}
}
- try!(ops::write_pkg_lockfile(&ws, &resolve));
+ ops::write_pkg_lockfile(&ws, &resolve)?;
return Ok(());
fn fill_with_deps<'a>(resolve: &'a Resolve, dep: &'a PackageId,
opts: &ops::CompileOptions,
force: bool) -> CargoResult<()> {
let config = opts.config;
- let root = try!(resolve_root(root, config));
- let map = try!(SourceConfigMap::new(config));
+ let root = resolve_root(root, config)?;
+ let map = SourceConfigMap::new(config)?;
let (pkg, source) = if source_id.is_git() {
- try!(select_pkg(GitSource::new(source_id, config), source_id,
- krate, vers, &mut |git| git.read_packages()))
+ select_pkg(GitSource::new(source_id, config), source_id,
+ krate, vers, &mut |git| git.read_packages())?
} else if source_id.is_path() {
let path = source_id.url().to_file_path().ok()
.expect("path sources must have a valid path");
let mut src = PathSource::new(&path, source_id, config);
- try!(src.update().chain_error(|| {
+ src.update().chain_error(|| {
human(format!("`{}` is not a crate root; specify a crate to \
install from crates.io, or use --path or --git to \
specify an alternate source", path.display()))
- }));
- try!(select_pkg(PathSource::new(&path, source_id, config),
+ })?;
+ select_pkg(PathSource::new(&path, source_id, config),
source_id, krate, vers,
- &mut |path| path.read_packages()))
+ &mut |path| path.read_packages())?
} else {
- try!(select_pkg(try!(map.load(source_id)),
+ select_pkg(map.load(source_id)?,
source_id, krate, vers,
&mut |_| Err(human("must specify a crate to install from \
crates.io, or use --path or --git to \
- specify alternate source"))))
+ specify alternate source")))?
};
};
let ws = match overidden_target_dir {
- Some(dir) => try!(Workspace::one(pkg, config, Some(dir))),
- None => try!(Workspace::new(pkg.manifest_path(), config)),
+ Some(dir) => Workspace::one(pkg, config, Some(dir))?,
+ None => Workspace::new(pkg.manifest_path(), config)?,
};
- let pkg = try!(ws.current());
+ let pkg = ws.current()?;
// Preflight checks to check up front whether we'll overwrite something.
// We have to check this again afterwards, but may as well avoid building
// anything if we're gonna throw it away anyway.
{
- let metadata = try!(metadata(config, &root));
- let list = try!(read_crate_list(metadata.file()));
+ let metadata = metadata(config, &root)?;
+ let list = read_crate_list(metadata.file())?;
let dst = metadata.parent().join("bin");
- try!(check_overwrites(&dst, pkg, &opts.filter, &list, force));
+ check_overwrites(&dst, pkg, &opts.filter, &list, force)?;
}
- let compile = try!(ops::compile_ws(&ws, Some(source), opts).chain_error(|| {
+ let compile = ops::compile_ws(&ws, Some(source), opts).chain_error(|| {
if let Some(td) = td_opt.take() {
// preserve the temporary directory, so the user can inspect it
td.into_path();
human(format!("failed to compile `{}`, intermediate artifacts can be \
found at `{}`", pkg, ws.target_dir().display()))
- }));
- let binaries: Vec<(&str, &Path)> = try!(compile.binaries.iter().map(|bin| {
+ })?;
+ let binaries: Vec<(&str, &Path)> = compile.binaries.iter().map(|bin| {
let name = bin.file_name().unwrap();
if let Some(s) = name.to_str() {
Ok((s, bin.as_ref()))
} else {
bail!("Binary `{:?}` name can't be serialized into string", name)
}
- }).collect::<CargoResult<_>>());
+ }).collect::<CargoResult<_>>()?;
- let metadata = try!(metadata(config, &root));
- let mut list = try!(read_crate_list(metadata.file()));
+ let metadata = metadata(config, &root)?;
+ let mut list = read_crate_list(metadata.file())?;
let dst = metadata.parent().join("bin");
- let duplicates = try!(check_overwrites(&dst, pkg, &opts.filter,
- &list, force));
+ let duplicates = check_overwrites(&dst, pkg, &opts.filter,
+ &list, force)?;
- try!(fs::create_dir_all(&dst));
+ fs::create_dir_all(&dst)?;
// Copy all binaries to a temporary directory under `dst` first, catching
// some failure modes (e.g. out of space) before touching the existing
// binaries. This directory will get cleaned up via RAII.
- let staging_dir = try!(TempDir::new_in(&dst, "cargo-install"));
+ let staging_dir = TempDir::new_in(&dst, "cargo-install")?;
for &(bin, src) in binaries.iter() {
let dst = staging_dir.path().join(bin);
// Try to move if `target_dir` is transient.
continue
}
}
- try!(fs::copy(src, &dst).chain_error(|| {
+ fs::copy(src, &dst).chain_error(|| {
human(format!("failed to copy `{}` to `{}`", src.display(),
dst.display()))
- }));
+ })?;
}
let (to_replace, to_install): (Vec<&str>, Vec<&str>) =
for bin in to_install.iter() {
let src = staging_dir.path().join(bin);
let dst = dst.join(bin);
- try!(config.shell().status("Installing", dst.display()));
- try!(fs::rename(&src, &dst).chain_error(|| {
+ config.shell().status("Installing", dst.display())?;
+ fs::rename(&src, &dst).chain_error(|| {
human(format!("failed to move `{}` to `{}`", src.display(),
dst.display()))
- }));
+ })?;
installed.bins.push(dst);
}
for &bin in to_replace.iter() {
let src = staging_dir.path().join(bin);
let dst = dst.join(bin);
- try!(config.shell().status("Replacing", dst.display()));
- try!(fs::rename(&src, &dst).chain_error(|| {
+ config.shell().status("Replacing", dst.display())?;
+ fs::rename(&src, &dst).chain_error(|| {
human(format!("failed to move `{}` to `{}`", src.display(),
dst.display()))
- }));
+ })?;
replaced_names.push(bin);
}
Ok(())
match write_result {
// Replacement error (if any) isn't actually caused by write error
// but this seems to be the only way to show both.
- Err(err) => try!(result.chain_error(|| err)),
- Ok(_) => try!(result),
+ Err(err) => result.chain_error(|| err)?,
+ Ok(_) => result?,
}
// Reaching here means all actions have succeeded. Clean up.
// Don't bother grabbing a lock as we're going to blow it all away
// anyway.
let target_dir = ws.target_dir().into_path_unlocked();
- try!(fs::remove_dir_all(&target_dir));
+ fs::remove_dir_all(&target_dir)?;
}
// Print a warning that if this directory isn't in PATH that they won't be
}
}
- try!(config.shell().warn(&format!("be sure to add `{}` to your PATH to be \
+ config.shell().warn(&format!("be sure to add `{}` to your PATH to be \
able to run the installed binaries",
- dst.display())));
+ dst.display()))?;
Ok(())
}
-> CargoResult<(Package, Box<Source + 'a>)>
where T: Source + 'a
{
- try!(source.update());
+ source.update()?;
match name {
Some(name) => {
- let dep = try!(Dependency::parse_no_deprecated(name, vers, source_id));
- let deps = try!(source.query(&dep));
+ let dep = Dependency::parse_no_deprecated(name, vers, source_id)?;
+ let deps = source.query(&dep)?;
match deps.iter().map(|p| p.package_id()).max() {
Some(pkgid) => {
- let pkg = try!(source.download(pkgid));
+ let pkg = source.download(pkgid)?;
Ok((pkg, Box::new(source)))
}
None => {
}
}
None => {
- let candidates = try!(list_all(&mut source));
+ let candidates = list_all(&mut source)?;
let binaries = candidates.iter().filter(|cand| {
cand.targets().iter().filter(|t| t.is_bin()).count() > 0
});
let examples = candidates.iter().filter(|cand| {
cand.targets().iter().filter(|t| t.is_example()).count() > 0
});
- let pkg = match try!(one(binaries, |v| multi_err("binaries", v))) {
+ let pkg = match one(binaries, |v| multi_err("binaries", v))? {
Some(p) => p,
None => {
- match try!(one(examples, |v| multi_err("examples", v))) {
+ match one(examples, |v| multi_err("examples", v))? {
Some(p) => p,
None => bail!("no packages found with binaries or \
examples"),
fn read_crate_list(mut file: &File) -> CargoResult<CrateListingV1> {
(|| -> CargoResult<_> {
let mut contents = String::new();
- try!(file.read_to_string(&mut contents));
- let listing = try!(toml::decode_str(&contents).chain_error(|| {
+ file.read_to_string(&mut contents)?;
+ let listing = toml::decode_str(&contents).chain_error(|| {
internal("invalid TOML found for metadata")
- }));
+ })?;
match listing {
CrateListing::V1(v1) => Ok(v1),
CrateListing::Empty => {
fn write_crate_list(mut file: &File, listing: CrateListingV1) -> CargoResult<()> {
(|| -> CargoResult<_> {
- try!(file.seek(SeekFrom::Start(0)));
- try!(file.set_len(0));
+ file.seek(SeekFrom::Start(0))?;
+ file.set_len(0)?;
let data = toml::encode_str::<CrateListing>(&CrateListing::V1(listing));
- try!(file.write_all(data.as_bytes()));
+ file.write_all(data.as_bytes())?;
Ok(())
}).chain_error(|| {
human("failed to write crate metadata")
}
pub fn install_list(dst: Option<&str>, config: &Config) -> CargoResult<()> {
- let dst = try!(resolve_root(dst, config));
- let dst = try!(metadata(config, &dst));
- let list = try!(read_crate_list(dst.file()));
+ let dst = resolve_root(dst, config)?;
+ let dst = metadata(config, &dst)?;
+ let list = read_crate_list(dst.file())?;
let mut shell = config.shell();
let out = shell.out();
for (k, v) in list.v1.iter() {
- try!(writeln!(out, "{}:", k));
+ writeln!(out, "{}:", k)?;
for bin in v {
- try!(writeln!(out, " {}", bin));
+ writeln!(out, " {}", bin)?;
}
}
Ok(())
spec: &str,
bins: &[String],
config: &Config) -> CargoResult<()> {
- let root = try!(resolve_root(root, config));
- let crate_metadata = try!(metadata(config, &root));
- let mut metadata = try!(read_crate_list(crate_metadata.file()));
+ let root = resolve_root(root, config)?;
+ let crate_metadata = metadata(config, &root)?;
+ let mut metadata = read_crate_list(crate_metadata.file())?;
let mut to_remove = Vec::new();
{
- let result = try!(PackageIdSpec::query_str(spec, metadata.v1.keys()))
+ let result = PackageIdSpec::query_str(spec, metadata.v1.keys())?
.clone();
let mut installed = match metadata.v1.entry(result.clone()) {
Entry::Occupied(e) => e,
installed.remove();
}
}
- try!(write_crate_list(crate_metadata.file(), metadata));
+ write_crate_list(crate_metadata.file(), metadata)?;
for bin in to_remove {
- try!(config.shell().status("Removing", bin.display()));
- try!(fs::remove_file(bin));
+ config.shell().status("Removing", bin.display())?;
+ fs::remove_file(bin)?;
}
Ok(())
fn resolve_root(flag: Option<&str>,
config: &Config) -> CargoResult<Filesystem> {
- let config_root = try!(config.get_path("install.root"));
+ let config_root = config.get_path("install.root")?;
Ok(flag.map(PathBuf::from).or_else(|| {
env::var_os("CARGO_INSTALL_ROOT").map(PathBuf::from)
}).or_else(move || {
impl Decodable for VersionControl {
fn decode<D: Decoder>(d: &mut D) -> Result<VersionControl, D::Error> {
- Ok(match &try!(d.read_str())[..] {
+ Ok(match &d.read_str()?[..] {
"git" => VersionControl::Git,
"hg" => VersionControl::Hg,
"none" => VersionControl::NoVcs,
path.as_os_str());
}
- let dir_name = try!(path.file_name().and_then(|s| s.to_str()).chain_error(|| {
+ let dir_name = path.file_name().and_then(|s| s.to_str()).chain_error(|| {
human(&format!("cannot create a project with a non-unicode name: {:?}",
path.file_name().unwrap()))
- }));
+ })?;
if opts.bin {
Ok(dir_name)
let message = format!(
"note: package will be named `{}`; use --name to override",
new_name);
- try!(config.shell().say(&message, BLACK));
+ config.shell().say(&message, BLACK)?;
}
Ok(new_name)
}
}
}
H::Detect => {
- let content = try!(paths::read(&path.join(pp.clone())));
+ let content = paths::read(&path.join(pp.clone()))?;
let isbin = content.contains("fn main");
SourceFileInformation {
relative_path: pp,
bail!("can't specify both lib and binary outputs");
}
- let name = try!(get_name(&path, &opts, config));
- try!(check_name(name));
+ let name = get_name(&path, &opts, config)?;
+ check_name(name)?;
let mkopts = MkOptions {
version_control: opts.version_control,
bail!("can't specify both lib and binary outputs");
}
- let name = try!(get_name(&path, &opts, config));
- try!(check_name(name));
+ let name = get_name(&path, &opts, config)?;
+ check_name(name)?;
let mut src_paths_types = vec![];
- try!(detect_source_paths_and_types(&path, name, &mut src_paths_types));
+ detect_source_paths_and_types(&path, name, &mut src_paths_types)?;
if src_paths_types.len() == 0 {
src_paths_types.push(plan_new_source_file(opts.bin, name.to_string()));
fn mk(config: &Config, opts: &MkOptions) -> CargoResult<()> {
let path = opts.path;
let name = opts.name;
- let cfg = try!(global_config(config));
+ let cfg = global_config(config)?;
let mut ignore = "target\n".to_string();
let in_existing_vcs_repo = existing_vcs_repo(path.parent().unwrap(), config.cwd());
if !opts.bin {
match vcs {
VersionControl::Git => {
if !fs::metadata(&path.join(".git")).is_ok() {
- try!(GitRepo::init(path, config.cwd()));
+ GitRepo::init(path, config.cwd())?;
}
- try!(paths::append(&path.join(".gitignore"), ignore.as_bytes()));
+ paths::append(&path.join(".gitignore"), ignore.as_bytes())?;
},
VersionControl::Hg => {
if !fs::metadata(&path.join(".hg")).is_ok() {
- try!(HgRepo::init(path, config.cwd()));
+ HgRepo::init(path, config.cwd())?;
}
- try!(paths::append(&path.join(".hgignore"), ignore.as_bytes()));
+ paths::append(&path.join(".hgignore"), ignore.as_bytes())?;
},
VersionControl::NoVcs => {
- try!(fs::create_dir_all(path));
+ fs::create_dir_all(path)?;
},
};
- let (author_name, email) = try!(discover_author());
+ let (author_name, email) = discover_author()?;
// Hoo boy, sure glad we've got exhaustivenes checking behind us.
let author = match (cfg.name, cfg.email, author_name, email) {
(Some(name), Some(email), _, _) |
// Create Cargo.toml file with necessary [lib] and [[bin]] sections, if needed
- try!(paths::write(&path.join("Cargo.toml"), format!(
+ paths::write(&path.join("Cargo.toml"), format!(
r#"[package]
name = "{}"
version = "0.1.0"
authors = [{}]
[dependencies]
-{}"#, name, toml::Value::String(author), cargotoml_path_specifier).as_bytes()));
+{}"#, name, toml::Value::String(author), cargotoml_path_specifier).as_bytes())?;
// Create all specified source files
let path_of_source_file = path.join(i.relative_path.clone());
if let Some(src_dir) = path_of_source_file.parent() {
- try!(fs::create_dir_all(src_dir));
+ fs::create_dir_all(src_dir)?;
}
let default_file_content : &[u8] = if i.bin {
};
if !fs::metadata(&path_of_source_file).map(|x| x.is_file()).unwrap_or(false) {
- try!(paths::write(&path_of_source_file, default_file_content));
+ paths::write(&path_of_source_file, default_file_content)?;
}
}
if let Err(e) = Workspace::new(&path.join("Cargo.toml"), config) {
let msg = format!("compiling this new crate may not work due to invalid \
workspace configuration\n\n{}", e);
- try!(config.shell().warn(msg));
+ config.shell().warn(msg)?;
}
Ok(())
}
fn global_config(config: &Config) -> CargoResult<CargoNewConfig> {
- let name = try!(config.get_string("cargo-new.name")).map(|s| s.val);
- let email = try!(config.get_string("cargo-new.email")).map(|s| s.val);
- let vcs = try!(config.get_string("cargo-new.vcs"));
+ let name = config.get_string("cargo-new.name")?.map(|s| s.val);
+ let email = config.get_string("cargo-new.email")?.map(|s| s.val);
+ let vcs = config.get_string("cargo-new.vcs")?;
let vcs = match vcs.as_ref().map(|p| (&p.val[..], &p.definition)) {
Some(("git", _)) => Some(VersionControl::Git),
let specs = ws.members().map(|pkg| {
PackageIdSpec::from_package_id(pkg.package_id())
}).collect::<Vec<_>>();
- let deps = try!(ops::resolve_dependencies(ws,
+ let deps = ops::resolve_dependencies(ws,
None,
&opt.features,
opt.all_features,
opt.no_default_features,
- &specs));
+ &specs)?;
let (packages, resolve) = deps;
let packages = try!(packages.package_ids()
pub fn package(ws: &Workspace,
opts: &PackageOpts) -> CargoResult<Option<FileLock>> {
- let pkg = try!(ws.current());
+ let pkg = ws.current()?;
let config = ws.config();
let mut src = PathSource::new(pkg.root(),
pkg.package_id().source_id(),
config);
- try!(src.update());
+ src.update()?;
if opts.check_metadata {
- try!(check_metadata(pkg, config));
+ check_metadata(pkg, config)?;
}
- try!(verify_dependencies(&pkg));
+ verify_dependencies(&pkg)?;
if opts.list {
let root = pkg.root();
- let mut list: Vec<_> = try!(src.list_files(&pkg)).iter().map(|file| {
+ let mut list: Vec<_> = src.list_files(&pkg)?.iter().map(|file| {
util::without_prefix(&file, &root).unwrap().to_path_buf()
}).collect();
list.sort();
}
if !opts.allow_dirty {
- try!(check_not_dirty(&pkg, &src));
+ check_not_dirty(&pkg, &src)?;
}
let filename = format!("{}-{}.crate", pkg.name(), pkg.version());
let dir = ws.target_dir().join("package");
let mut dst = {
let tmp = format!(".{}", filename);
- try!(dir.open_rw(&tmp, config, "package scratch space"))
+ dir.open_rw(&tmp, config, "package scratch space")?
};
// Package up and test a temporary tarball and only move it to the final
// location if it actually passes all our tests. Any previously existing
// tarball can be assumed as corrupt or invalid, so we just blow it away if
// it exists.
- try!(config.shell().status("Packaging", pkg.package_id().to_string()));
- try!(dst.file().set_len(0));
- try!(tar(ws, &src, dst.file(), &filename).chain_error(|| {
+ config.shell().status("Packaging", pkg.package_id().to_string())?;
+ dst.file().set_len(0)?;
+ tar(ws, &src, dst.file(), &filename).chain_error(|| {
human("failed to prepare local package for uploading")
- }));
+ })?;
if opts.verify {
- try!(dst.seek(SeekFrom::Start(0)));
- try!(run_verify(ws, dst.file(), opts).chain_error(|| {
+ dst.seek(SeekFrom::Start(0))?;
+ run_verify(ws, dst.file(), opts).chain_error(|| {
human("failed to verify package tarball")
- }))
+ })?
}
- try!(dst.seek(SeekFrom::Start(0)));
+ dst.seek(SeekFrom::Start(0))?;
{
let src_path = dst.path();
let dst_path = dst.parent().join(&filename);
- try!(fs::rename(&src_path, &dst_path).chain_error(|| {
+ fs::rename(&src_path, &dst_path).chain_error(|| {
human("failed to move temporary tarball into final location")
- }));
+ })?;
}
Ok(Some(dst))
}
}
things.push_str(&missing.last().unwrap());
- try!(config.shell().warn(
+ config.shell().warn(
&format!("manifest has no {things}.\n\
See http://doc.crates.io/manifest.html#package-metadata for more info.",
- things = things)))
+ things = things))?
}
Ok(())
}
src: &PathSource,
repo: &git2::Repository) -> CargoResult<()> {
let workdir = repo.workdir().unwrap();
- let dirty = try!(src.list_files(p)).iter().filter(|file| {
+ let dirty = src.list_files(p)?.iter().filter(|file| {
let relative = file.strip_prefix(workdir).unwrap();
if let Ok(status) = repo.status_file(relative) {
status != git2::STATUS_CURRENT
filename: &str) -> CargoResult<()> {
// Prepare the encoder and its header
let filename = Path::new(filename);
- let encoder = GzBuilder::new().filename(try!(util::path2bytes(filename)))
+ let encoder = GzBuilder::new().filename(util::path2bytes(filename)?)
.write(dst, Compression::Best);
// Put all package files into a compressed archive
let mut ar = Builder::new(encoder);
- let pkg = try!(ws.current());
+ let pkg = ws.current()?;
let config = ws.config();
let root = pkg.root();
- for file in try!(src.list_files(pkg)).iter() {
+ for file in src.list_files(pkg)?.iter() {
let relative = util::without_prefix(&file, &root).unwrap();
- try!(check_filename(relative));
- let relative = try!(relative.to_str().chain_error(|| {
+ check_filename(relative)?;
+ let relative = relative.to_str().chain_error(|| {
human(format!("non-utf8 path in source directory: {}",
relative.display()))
- }));
- let mut file = try!(File::open(file).chain_error(|| {
+ })?;
+ let mut file = File::open(file).chain_error(|| {
human(format!("failed to open for archiving: `{}`", file.display()))
- }));
- try!(config.shell().verbose(|shell| {
+ })?;
+ config.shell().verbose(|shell| {
shell.status("Archiving", &relative)
- }));
+ })?;
let path = format!("{}-{}{}{}", pkg.name(), pkg.version(),
path::MAIN_SEPARATOR, relative);
// unpack the selectors 0.4.0 crate on crates.io. Either that or take a
// look at rust-lang/cargo#2326
let mut header = Header::new_ustar();
- let metadata = try!(file.metadata().chain_error(|| {
+ let metadata = file.metadata().chain_error(|| {
human(format!("could not learn metadata for: `{}`", relative))
- }));
- try!(header.set_path(&path).chain_error(|| {
+ })?;
+ header.set_path(&path).chain_error(|| {
human(format!("failed to add to archive: `{}`", relative))
- }));
+ })?;
header.set_metadata(&metadata);
header.set_cksum();
- try!(ar.append(&header, &mut file).chain_error(|| {
+ ar.append(&header, &mut file).chain_error(|| {
internal(format!("could not archive source file `{}`", relative))
- }));
+ })?;
}
- let encoder = try!(ar.into_inner());
- try!(encoder.finish());
+ let encoder = ar.into_inner()?;
+ encoder.finish()?;
Ok(())
}
fn run_verify(ws: &Workspace, tar: &File, opts: &PackageOpts) -> CargoResult<()> {
let config = ws.config();
- let pkg = try!(ws.current());
+ let pkg = ws.current()?;
- try!(config.shell().status("Verifying", pkg));
+ config.shell().status("Verifying", pkg)?;
- let f = try!(GzDecoder::new(tar));
+ let f = GzDecoder::new(tar)?;
let dst = pkg.root().join(&format!("target/package/{}-{}",
pkg.name(), pkg.version()));
if fs::metadata(&dst).is_ok() {
- try!(fs::remove_dir_all(&dst));
+ fs::remove_dir_all(&dst)?;
}
let mut archive = Archive::new(f);
- try!(archive.unpack(dst.parent().unwrap()));
+ archive.unpack(dst.parent().unwrap())?;
let manifest_path = dst.join("Cargo.toml");
// When packages are uploaded to a registry, all path dependencies are
// location that the package was originally read from. In locking the
// `SourceId` we're telling it that the corresponding `PathSource` will be
// considered updated and we won't actually read any packages.
- let cratesio = try!(SourceId::crates_io(config));
+ let cratesio = SourceId::crates_io(config)?;
let precise = Some("locked".to_string());
- let new_src = try!(SourceId::for_path(&dst)).with_precise(precise);
- let new_pkgid = try!(PackageId::new(pkg.name(), pkg.version(), &new_src));
+ let new_src = SourceId::for_path(&dst)?.with_precise(precise);
+ let new_pkgid = PackageId::new(pkg.name(), pkg.version(), &new_src)?;
let new_summary = pkg.summary().clone().map_dependencies(|d| {
if !d.source_id().is_path() { return d }
d.clone_inner().set_source_id(cratesio.clone()).into_dependency()
let new_pkg = Package::new(new_manifest, &manifest_path);
// Now that we've rewritten all our path dependencies, compile it!
- let ws = try!(Workspace::one(new_pkg, config, None));
- try!(ops::compile_ws(&ws, None, &ops::CompileOptions {
+ let ws = Workspace::one(new_pkg, config, None)?;
+ ops::compile_ws(&ws, None, &ops::CompileOptions {
config: config,
jobs: opts.jobs,
target: None,
mode: ops::CompileMode::Build,
target_rustdoc_args: None,
target_rustc_args: None,
- }));
+ })?;
Ok(())
}
use util::CargoResult;
pub fn pkgid(ws: &Workspace, spec: Option<&str>) -> CargoResult<PackageIdSpec> {
- let resolve = match try!(ops::load_pkg_lockfile(ws)) {
+ let resolve = match ops::load_pkg_lockfile(ws)? {
Some(resolve) => resolve,
None => bail!("a Cargo.lock must exist for this command"),
};
let pkgid = match spec {
- Some(spec) => try!(PackageIdSpec::query_str(spec, resolve.iter())),
- None => try!(ws.current()).package_id(),
+ Some(spec) => PackageIdSpec::query_str(spec, resolve.iter())?,
+ None => ws.current()?.package_id(),
};
Ok(PackageIdSpec::from_package_id(pkgid))
}
pub fn read_manifest(path: &Path, source_id: &SourceId, config: &Config)
-> CargoResult<(EitherManifest, Vec<PathBuf>)> {
trace!("read_package; path={}; source-id={}", path.display(), source_id);
- let contents = try!(paths::read(path));
+ let contents = paths::read(path)?;
let layout = Layout::from_project_path(path.parent().unwrap());
let root = layout.root.clone();
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 (manifest, nested) = try!(read_manifest(path, source_id, config));
+ let (manifest, nested) = read_manifest(path, source_id, config)?;
let manifest = match manifest {
EitherManifest::Real(manifest) => manifest,
EitherManifest::Virtual(..) => {
trace!("looking for root package: {}, source_id={}", path.display(), source_id);
- try!(walk(path, &mut |dir| {
+ walk(path, &mut |dir| {
trace!("looking for child package: {}", dir.display());
// Don't recurse into hidden/dot directories unless we're at the toplevel
}
if has_manifest(dir) {
- try!(read_nested_packages(dir, &mut all_packages, source_id, config,
- &mut visited));
+ 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())))
fn walk(path: &Path, callback: &mut FnMut(&Path) -> CargoResult<bool>)
-> CargoResult<()> {
- if !try!(callback(path)) {
+ if !callback(path)? {
trace!("not processing {}", path.display());
return Ok(())
}
}
};
for dir in dirs {
- let dir = try!(dir);
- if try!(dir.file_type()).is_dir() {
- try!(walk(&dir.path(), callback));
+ let dir = dir?;
+ if dir.file_type()?.is_dir() {
+ walk(&dir.path(), callback)?;
}
}
Ok(())
visited: &mut HashSet<PathBuf>) -> CargoResult<()> {
if !visited.insert(path.to_path_buf()) { return Ok(()) }
- let manifest_path = try!(find_project_manifest_exact(path, "Cargo.toml"));
+ let manifest_path = find_project_manifest_exact(path, "Cargo.toml")?;
- let (manifest, nested) = try!(read_manifest(&manifest_path, source_id, config));
+ let (manifest, nested) = read_manifest(&manifest_path, source_id, config)?;
let manifest = match manifest {
EitherManifest::Real(manifest) => manifest,
EitherManifest::Virtual(..) => return Ok(()),
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));
+ read_nested_packages(&path, all_packages, source_id,
+ config, visited)?;
}
}
options: &ops::CompileOptions,
args: &[String]) -> CargoResult<Option<ProcessError>> {
let config = ws.config();
- let root = try!(ws.current());
+ let root = ws.current()?;
let mut bins = root.manifest().targets().iter().filter(|a| {
!a.is_lib() && !a.is_custom_build() && match options.filter {
}
}
- let compile = try!(ops::compile(ws, options));
+ let compile = ops::compile(ws, options)?;
let exe = &compile.binaries[0];
let exe = match util::without_prefix(&exe, config.cwd()) {
Some(path) if path.file_name() == Some(path.as_os_str())
Some(path) => path.to_path_buf(),
None => exe.to_path_buf(),
};
- let mut process = try!(compile.target_process(exe, &root));
+ let mut process = compile.target_process(exe, &root)?;
process.args(args).cwd(config.cwd());
- try!(config.shell().status("Running", process.to_string()));
+ config.shell().status("Running", process.to_string())?;
Ok(process.exec_replace().err())
}
/// See `process`.
pub fn rustc_process(&self, pkg: &Package) -> CargoResult<ProcessBuilder> {
- self.fill_env(try!(self.config.rustc()).process(), pkg, true)
+ self.fill_env(self.config.rustc()?.process(), pkg, true)
}
/// See `process`.
pub fn rustdoc_process(&self, pkg: &Package) -> CargoResult<ProcessBuilder> {
- self.fill_env(process(&*try!(self.config.rustdoc())), pkg, false)
+ self.fill_env(process(&*self.config.rustdoc()?), pkg, false)
}
/// See `process`.
};
search_path.extend(util::dylib_path().into_iter());
- let search_path = try!(join_paths(&search_path, util::dylib_path_envvar()));
+ let search_path = join_paths(&search_path, util::dylib_path_envvar())?;
cmd.env(util::dylib_path_envvar(), &search_path);
if let Some(env) = self.extra_env.get(pkg.package_id()) {
profiles: &'a Profiles) -> CargoResult<Context<'a, 'cfg>> {
let dest = if build_config.release { "release" } else { "debug" };
- let host_layout = try!(Layout::new(ws, None, &dest));
+ let host_layout = Layout::new(ws, None, &dest)?;
let target_layout = match build_config.requested_target.as_ref() {
Some(target) => {
- Some(try!(Layout::new(ws, Some(&target), &dest)))
+ Some(Layout::new(ws, Some(&target), &dest)?)
}
None => None,
};
- let current_package = try!(ws.current()).package_id().clone();
+ let current_package = ws.current()?.package_id().clone();
Ok(Context {
host: host_layout,
target: target_layout,
pub fn prepare(&mut self) -> CargoResult<()> {
let _p = profile::start("preparing layout");
- try!(self.host.prepare().chain_error(|| {
+ self.host.prepare().chain_error(|| {
internal(format!("couldn't prepare build directories"))
- }));
+ })?;
match self.target {
Some(ref mut target) => {
- try!(target.prepare().chain_error(|| {
+ target.prepare().chain_error(|| {
internal(format!("couldn't prepare build directories"))
- }));
+ })?;
}
None => {}
}
crate_types.insert("bin".to_string());
crate_types.insert("rlib".to_string());
for unit in units {
- try!(self.visit_crate_type(unit, &mut crate_types));
+ self.visit_crate_type(unit, &mut crate_types)?;
}
- try!(self.probe_target_info_kind(&crate_types, Kind::Target));
+ self.probe_target_info_kind(&crate_types, Kind::Target)?;
if self.requested_target().is_none() {
self.host_info = self.target_info.clone();
} else {
- try!(self.probe_target_info_kind(&crate_types, Kind::Host));
+ self.probe_target_info_kind(&crate_types, Kind::Host)?;
}
Ok(())
}
}
}));
}
- for dep in try!(self.dep_targets(&unit)) {
- try!(self.visit_crate_type(&dep, crate_types));
+ for dep in self.dep_targets(&unit)? {
+ self.visit_crate_type(&dep, crate_types)?;
}
Ok(())
}
crate_types: &BTreeSet<String>,
kind: Kind)
-> CargoResult<()> {
- let rustflags = try!(env_args(self.config,
+ let rustflags = env_args(self.config,
&self.build_config,
kind,
- "RUSTFLAGS"));
- let mut process = try!(self.config.rustc()).process();
+ "RUSTFLAGS")?;
+ let mut process = self.config.rustc()?.process();
process.arg("-")
.arg("--crate-name").arg("_")
.arg("--print=file-names")
with_cfg.arg("--print=cfg");
let mut has_cfg = true;
- let output = try!(with_cfg.exec_with_output().or_else(|_| {
+ let output = with_cfg.exec_with_output().or_else(|_| {
has_cfg = false;
process.exec_with_output()
}).chain_error(|| {
human(format!("failed to run `rustc` to learn about \
target-specific information"))
- }));
+ })?;
let error = str::from_utf8(&output.stderr).unwrap();
let output = str::from_utf8(&output.stdout).unwrap();
-> CargoResult<()> {
let mut visited = HashSet::new();
for unit in units {
- try!(self.walk_used_in_plugin_map(unit,
+ self.walk_used_in_plugin_map(unit,
unit.target.for_host(),
- &mut visited));
+ &mut visited)?;
}
Ok(())
}
if is_plugin {
self.used_in_plugin.insert(*unit);
}
- for unit in try!(self.dep_targets(unit)) {
- try!(self.walk_used_in_plugin_map(&unit,
+ for unit in self.dep_targets(unit)? {
+ self.walk_used_in_plugin_map(&unit,
is_plugin || unit.target.for_host(),
- visited));
+ visited)?;
}
Ok(())
}
TargetKind::CustomBuild |
TargetKind::Bench |
TargetKind::Test => {
- try!(add("bin", false));
+ add("bin", false)?;
}
TargetKind::Lib(..) if unit.profile.test => {
- try!(add("bin", false));
+ add("bin", false)?;
}
TargetKind::Lib(ref libs) => {
for lib in libs {
- try!(add(lib.crate_type(), lib.linkable()));
+ add(lib.crate_type(), lib.linkable())?;
}
}
}
let id = unit.pkg.package_id();
let deps = self.resolve.deps(id);
- let mut ret = try!(deps.filter(|dep| {
+ let mut ret = deps.filter(|dep| {
unit.pkg.dependencies().iter().filter(|d| {
d.name() == dep.name() && d.version_req().matches(dep.version())
}).any(|d| {
}
Err(e) => Some(Err(e))
}
- }).collect::<CargoResult<Vec<_>>>());
+ }).collect::<CargoResult<Vec<_>>>()?;
// If this target is a build script, then what we've collected so far is
// all we need. If this isn't a build script, then it depends on the
profile: &self.profiles.dev,
..*unit
};
- let deps = try!(self.dep_targets(&tmp));
+ let deps = self.dep_targets(&tmp)?;
Ok(deps.iter().filter_map(|unit| {
if !unit.target.linkable() || unit.pkg.manifest().links().is_none() {
return None
// the documentation of the library being built.
let mut ret = Vec::new();
for dep in deps {
- let dep = try!(dep);
+ let dep = dep?;
let lib = match dep.targets().iter().find(|t| t.is_lib()) {
Some(lib) => lib,
None => continue,
// Then the target.*.rustflags value
let target = build_config.requested_target.as_ref().unwrap_or(&build_config.host_triple);
let key = format!("target.{}.{}", target, name);
- if let Some(args) = try!(config.get_list(&key)) {
+ if let Some(args) = config.get_list(&key)? {
let args = args.val.into_iter().map(|a| a.0);
return Ok(args.collect());
}
// Then the build.rustflags value
let key = format!("build.{}", name);
- if let Some(args) = try!(config.get_list(&key)) {
+ if let Some(args) = config.get_list(&key)? {
let args = args.val.into_iter().map(|a| a.0);
return Ok(args.collect());
}
let (work_dirty, work_fresh) = if overridden {
(Work::new(|_| Ok(())), Work::new(|_| Ok(())))
} else {
- try!(build_work(cx, unit))
+ build_work(cx, unit)?
};
// Now that we've prep'd our work, build the work needed to manage the
// fingerprint and then start returning that upwards.
let (freshness, dirty, fresh) =
- try!(fingerprint::prepare_build_cmd(cx, unit));
+ fingerprint::prepare_build_cmd(cx, unit)?;
Ok((work_dirty.then(dirty), work_fresh.then(fresh), freshness))
}
// package's library profile.
let profile = cx.lib_profile(unit.pkg.package_id());
let to_exec = to_exec.into_os_string();
- let mut cmd = try!(cx.compilation.host_process(to_exec, unit.pkg));
+ let mut cmd = cx.compilation.host_process(to_exec, unit.pkg)?;
cmd.env("OUT_DIR", &build_output)
.env("CARGO_MANIFEST_DIR", unit.pkg.root())
.env("NUM_JOBS", &cx.jobs().to_string())
.env("OPT_LEVEL", &profile.opt_level)
.env("PROFILE", if cx.build_config.release { "release" } else { "debug" })
.env("HOST", cx.host_triple())
- .env("RUSTC", &try!(cx.config.rustc()).path)
- .env("RUSTDOC", &*try!(cx.config.rustdoc()));
+ .env("RUSTC", &cx.config.rustc()?.path)
+ .env("RUSTDOC", &*cx.config.rustdoc()?);
if let Some(links) = unit.pkg.manifest().links() {
cmd.env("CARGO_MANIFEST_LINKS", links);
// This information will be used at build-time later on to figure out which
// sorts of variables need to be discovered at that time.
let lib_deps = {
- try!(cx.dep_run_custom_build(unit)).iter().filter_map(|unit| {
+ cx.dep_run_custom_build(unit)?.iter().filter_map(|unit| {
if unit.profile.run_custom_build {
Some((unit.pkg.manifest().links().unwrap().to_string(),
unit.pkg.package_id().clone()))
};
cx.build_explicit_deps.insert(*unit, (output_file.clone(), rerun_if_changed));
- try!(fs::create_dir_all(&cx.layout(&host_unit).build(unit.pkg)));
- try!(fs::create_dir_all(&cx.layout(unit).build(unit.pkg)));
+ fs::create_dir_all(&cx.layout(&host_unit).build(unit.pkg))?;
+ fs::create_dir_all(&cx.layout(unit).build(unit.pkg))?;
// Prepare the unit of "dirty work" which will actually run the custom build
// command.
// If we have an old build directory, then just move it into place,
// otherwise create it!
if fs::metadata(&build_output).is_err() {
- try!(fs::create_dir(&build_output).chain_error(|| {
+ fs::create_dir(&build_output).chain_error(|| {
internal("failed to create script output directory for \
build command")
- }));
+ })?;
}
// For all our native lib dependencies, pick up their metadata to pass
let build_state = build_state.outputs.lock().unwrap();
for (name, id) in lib_deps {
let key = (id.clone(), kind);
- let state = try!(build_state.get(&key).chain_error(|| {
+ let state = build_state.get(&key).chain_error(|| {
internal(format!("failed to locate build state for env \
vars: {}/{:?}", id, kind))
- }));
+ })?;
let data = &state.metadata;
for &(ref key, ref value) in data.iter() {
cmd.env(&format!("DEP_{}_{}", super::envify(&name),
}
}
if let Some(build_scripts) = build_scripts {
- try!(super::add_plugin_deps(&mut cmd, &build_state,
- &build_scripts));
+ super::add_plugin_deps(&mut cmd, &build_state,
+ &build_scripts)?;
}
}
// And now finally, run the build command itself!
state.running(&cmd);
- let output = try!(cmd.exec_with_streaming(
+ let output = cmd.exec_with_streaming(
&mut |out_line| { state.stdout(out_line); Ok(()) },
&mut |err_line| { state.stderr(err_line); Ok(()) },
).map_err(|mut e| {
e.desc = format!("failed to run custom build command for `{}`\n{}",
pkg_name, e.desc);
Human(e)
- }));
- try!(paths::write(&output_file, &output.stdout));
+ })?;
+ paths::write(&output_file, &output.stdout)?;
// After the build command has finished running, we need to be sure to
// remember all of its output so we can later discover precisely what it
// This is also the location where we provide feedback into the build
// state informing what variables were discovered via our script as
// well.
- let parsed_output = try!(BuildOutput::parse(&output.stdout, &pkg_name));
+ let parsed_output = BuildOutput::parse(&output.stdout, &pkg_name)?;
build_state.insert(id, kind, parsed_output);
Ok(())
});
let (id, pkg_name, build_state, output_file) = all;
let output = match prev_output {
Some(output) => output,
- None => try!(BuildOutput::parse_file(&output_file, &pkg_name)),
+ None => BuildOutput::parse_file(&output_file, &pkg_name)?,
};
build_state.insert(id, kind, output);
Ok(())
impl BuildOutput {
pub fn parse_file(path: &Path, pkg_name: &str) -> CargoResult<BuildOutput> {
- let contents = try!(paths::read_bytes(path));
+ let contents = paths::read_bytes(path)?;
BuildOutput::parse(&contents, pkg_name)
}
match key {
"rustc-flags" => {
- let (libs, links) = try!(
+ let (libs, links) =
BuildOutput::parse_rustc_flags(value, &whence)
- );
+ ?;
library_links.extend(links.into_iter());
library_paths.extend(libs.into_iter());
}
-> CargoResult<()> {
let mut ret = HashMap::new();
for unit in units {
- try!(build(&mut ret, cx, unit));
+ build(&mut ret, cx, unit)?;
}
cx.build_scripts.extend(ret.into_iter().map(|(k, v)| {
(k, Arc::new(v))
if !unit.target.is_custom_build() && unit.pkg.has_custom_build() {
add_to_link(&mut ret, unit.pkg.package_id(), unit.kind);
}
- for unit in try!(cx.dep_targets(unit)).iter() {
- let dep_scripts = try!(build(out, cx, unit));
+ for unit in cx.dep_targets(unit)?.iter() {
+ let dep_scripts = build(out, cx, unit)?;
if unit.target.for_host() {
ret.plugins.extend(dep_scripts.to_link.iter()
debug!("fingerprint at: {}", loc.display());
- let fingerprint = try!(calculate(cx, unit));
+ let fingerprint = calculate(cx, unit)?;
let compare = compare_old_fingerprint(&loc, &*fingerprint);
log_compare(unit, &compare);
if compare.is_err() {
let source_id = unit.pkg.package_id().source_id();
let sources = cx.packages.sources();
- let source = try!(sources.get(source_id).chain_error(|| {
+ let source = sources.get(source_id).chain_error(|| {
internal("missing package source")
- }));
- try!(source.verify(unit.pkg.package_id()));
+ })?;
+ source.verify(unit.pkg.package_id())?;
}
let root = cx.out_dir(unit);
missing_outputs = !root.join(unit.target.crate_name())
.join("index.html").exists();
} else {
- for (filename, _) in try!(cx.target_filenames(unit)) {
+ for (filename, _) in cx.target_filenames(unit)? {
missing_outputs |= fs::metadata(root.join(filename)).is_err();
}
}
fn update_local(&self) -> CargoResult<()> {
match self.local {
LocalFingerprint::MtimeBased(ref slot, ref path) => {
- let meta = try!(fs::metadata(path).chain_error(|| {
+ let meta = fs::metadata(path).chain_error(|| {
internal(format!("failed to stat `{}`", path.display()))
- }));
+ })?;
let mtime = FileTime::from_last_modification_time(&meta);
*slot.0.lock().unwrap() = Some(mtime);
}
impl Encodable for Fingerprint {
fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
e.emit_struct("Fingerprint", 6, |e| {
- try!(e.emit_struct_field("rustc", 0, |e| self.rustc.encode(e)));
- try!(e.emit_struct_field("target", 1, |e| self.target.encode(e)));
- try!(e.emit_struct_field("profile", 2, |e| self.profile.encode(e)));
- try!(e.emit_struct_field("local", 3, |e| self.local.encode(e)));
- try!(e.emit_struct_field("features", 4, |e| {
+ e.emit_struct_field("rustc", 0, |e| self.rustc.encode(e))?;
+ e.emit_struct_field("target", 1, |e| self.target.encode(e))?;
+ e.emit_struct_field("profile", 2, |e| self.profile.encode(e))?;
+ e.emit_struct_field("local", 3, |e| self.local.encode(e))?;
+ e.emit_struct_field("features", 4, |e| {
self.features.encode(e)
- }));
- try!(e.emit_struct_field("deps", 5, |e| {
+ })?;
+ e.emit_struct_field("deps", 5, |e| {
self.deps.iter().map(|&(ref a, ref b)| {
(a, b.hash())
}).collect::<Vec<_>>().encode(e)
- }));
- try!(e.emit_struct_field("rustflags", 6, |e| self.rustflags.encode(e)));
+ })?;
+ e.emit_struct_field("rustflags", 6, |e| self.rustflags.encode(e))?;
Ok(())
})
}
}
d.read_struct("Fingerprint", 6, |d| {
Ok(Fingerprint {
- rustc: try!(d.read_struct_field("rustc", 0, decode)),
- target: try!(d.read_struct_field("target", 1, decode)),
- profile: try!(d.read_struct_field("profile", 2, decode)),
- local: try!(d.read_struct_field("local", 3, decode)),
- features: try!(d.read_struct_field("features", 4, decode)),
+ rustc: d.read_struct_field("rustc", 0, decode)?,
+ target: d.read_struct_field("target", 1, decode)?,
+ profile: d.read_struct_field("profile", 2, decode)?,
+ local: d.read_struct_field("local", 3, decode)?,
+ features: d.read_struct_field("features", 4, decode)?,
memoized_hash: Mutex::new(None),
deps: {
let decode = decode::<Vec<(String, u64)>, D>;
- let v = try!(d.read_struct_field("deps", 5, decode));
+ let v = d.read_struct_field("deps", 5, decode)?;
v.into_iter().map(|(name, hash)| {
(name, Arc::new(Fingerprint {
rustc: 0,
}))
}).collect()
},
- rustflags: try!(d.read_struct_field("rustflags", 6, decode)),
+ rustflags: d.read_struct_field("rustflags", 6, decode)?,
})
})
}
impl Decodable for MtimeSlot {
fn decode<D: Decoder>(e: &mut D) -> Result<MtimeSlot, D::Error> {
- let kind: Option<(u64, u32)> = try!(Decodable::decode(e));
+ let kind: Option<(u64, u32)> = Decodable::decode(e)?;
Ok(MtimeSlot(Mutex::new(kind.map(|(s, n)| {
FileTime::from_seconds_since_1970(s, n)
}))))
// elsewhere. Also skip fingerprints of binaries because they don't actually
// induce a recompile, they're just dependencies in the sense that they need
// to be built.
- let deps = try!(cx.dep_targets(unit));
- let deps = try!(deps.iter().filter(|u| {
+ let deps = cx.dep_targets(unit)?;
+ let deps = deps.iter().filter(|u| {
!u.target.is_custom_build() && !u.target.is_bin()
}).map(|unit| {
calculate(cx, unit).map(|fingerprint| {
(unit.pkg.package_id().to_string(), fingerprint)
})
- }).collect::<CargoResult<Vec<_>>>());
+ }).collect::<CargoResult<Vec<_>>>()?;
// And finally, calculate what our own local fingerprint is
let local = if use_dep_info(unit) {
let dep_info = dep_info_loc(cx, unit);
- let mtime = try!(dep_info_mtime_if_fresh(&dep_info));
+ let mtime = dep_info_mtime_if_fresh(&dep_info)?;
LocalFingerprint::MtimeBased(MtimeSlot(Mutex::new(mtime)), dep_info)
} else {
- let fingerprint = try!(pkg_fingerprint(cx, unit.pkg));
+ let fingerprint = pkg_fingerprint(cx, unit.pkg)?;
LocalFingerprint::Precalculated(fingerprint)
};
let mut deps = deps;
deps.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
let extra_flags = if unit.profile.doc {
- try!(cx.rustdocflags_args(unit))
+ cx.rustdocflags_args(unit)?
} else {
- try!(cx.rustflags_args(unit))
+ cx.rustflags_args(unit)?
};
let fingerprint = Arc::new(Fingerprint {
- rustc: util::hash_u64(&try!(cx.config.rustc()).verbose_version),
+ rustc: util::hash_u64(&cx.config.rustc()?.verbose_version),
target: util::hash_u64(&unit.target),
profile: util::hash_u64(&unit.profile),
features: format!("{:?}", features),
let &(ref output, ref deps) = &cx.build_explicit_deps[unit];
let local = if deps.is_empty() {
- let s = try!(pkg_fingerprint(cx, unit.pkg));
+ let s = pkg_fingerprint(cx, unit.pkg)?;
LocalFingerprint::Precalculated(s)
} else {
let deps = deps.iter().map(|p| unit.pkg.root().join(p));
let slot = MtimeSlot(Mutex::new(None));
fingerprint.local = LocalFingerprint::MtimeBased(slot,
output_path);
- try!(fingerprint.update_local());
+ fingerprint.update_local()?;
}
}
write_fingerprint(&loc, &fingerprint)
fn write_fingerprint(loc: &Path, fingerprint: &Fingerprint) -> CargoResult<()> {
let hash = fingerprint.hash();
debug!("write fingerprint: {}", loc.display());
- try!(paths::write(&loc, util::to_hex(hash).as_bytes()));
- try!(paths::write(&loc.with_extension("json"),
- json::encode(&fingerprint).unwrap().as_bytes()));
+ paths::write(&loc, util::to_hex(hash).as_bytes())?;
+ paths::write(&loc.with_extension("json"),
+ json::encode(&fingerprint).unwrap().as_bytes())?;
Ok(())
}
let new2 = new1.clone();
if fs::metadata(&new1).is_err() {
- try!(fs::create_dir(&new1));
+ fs::create_dir(&new1)?;
}
if fs::metadata(&new2).is_err() {
- try!(fs::create_dir(&new2));
+ fs::create_dir(&new2)?;
}
Ok(())
}
fn compare_old_fingerprint(loc: &Path, new_fingerprint: &Fingerprint)
-> CargoResult<()> {
- let old_fingerprint_short = try!(paths::read(loc));
+ let old_fingerprint_short = paths::read(loc)?;
let new_hash = new_fingerprint.hash();
if util::to_hex(new_hash) == old_fingerprint_short {
return Ok(())
}
- let old_fingerprint_json = try!(paths::read(&loc.with_extension("json")));
- let old_fingerprint = try!(json::decode(&old_fingerprint_json).chain_error(|| {
+ let old_fingerprint_json = paths::read(&loc.with_extension("json"))?;
+ let old_fingerprint = json::decode(&old_fingerprint_json).chain_error(|| {
internal(format!("failed to deserialize json"))
- }));
+ })?;
new_fingerprint.compare(&old_fingerprint)
}
if fs_try!(f.read_until(0, &mut cwd)) == 0 {
return Ok(None)
}
- let cwd = try!(util::bytes2path(&cwd[..cwd.len()-1]));
+ let cwd = util::bytes2path(&cwd[..cwd.len()-1])?;
let line = match f.lines().next() {
Some(Ok(line)) => line,
_ => return Ok(None),
};
- let pos = try!(line.find(": ").chain_error(|| {
+ let pos = line.find(": ").chain_error(|| {
internal(format!("dep-info not in an understood format: {}",
dep_info.display()))
- }));
+ })?;
let deps = &line[pos + 2..];
let mut paths = Vec::new();
while file.ends_with("\\") {
file.pop();
file.push(' ');
- file.push_str(try!(deps.next().chain_error(|| {
+ file.push_str(deps.next().chain_error(|| {
internal(format!("malformed dep-info format, trailing \\"))
- })));
+ })?);
}
paths.push(cwd.join(&file));
}
fn pkg_fingerprint(cx: &Context, pkg: &Package) -> CargoResult<String> {
let source_id = pkg.package_id().source_id();
let sources = cx.packages.sources();
- let source = try!(sources.get(source_id).chain_error(|| {
+ let source = sources.get(source_id).chain_error(|| {
internal("missing package source")
- }));
+ })?;
source.fingerprint(pkg)
}
// next time.
pub fn append_current_dir(path: &Path, cwd: &Path) -> CargoResult<()> {
debug!("appending {} <- {}", path.display(), cwd.display());
- let mut f = try!(OpenOptions::new().read(true).write(true).open(path));
+ let mut f = OpenOptions::new().read(true).write(true).open(path)?;
let mut contents = Vec::new();
- try!(f.read_to_end(&mut contents));
- try!(f.seek(SeekFrom::Start(0)));
- try!(f.write_all(try!(util::path2bytes(cwd))));
- try!(f.write_all(&[0]));
- try!(f.write_all(&contents));
+ f.read_to_end(&mut contents)?;
+ f.seek(SeekFrom::Start(0))?;
+ f.write_all(util::path2bytes(cwd)?)?;
+ f.write_all(&[0])?;
+ f.write_all(&contents)?;
Ok(())
}
pub fn then(self, next: Work) -> Work {
Work::new(move |state| {
- try!(self.call(state));
+ self.call(state)?;
next.call(state)
})
}
job: Job,
fresh: Freshness) -> CargoResult<()> {
let key = Key::new(unit);
- let deps = try!(key.dependencies(cx));
+ let deps = key.dependencies(cx)?;
self.queue.queue(Fresh, key, Vec::new(), &deps).push((job, fresh));
*self.counts.entry(key.pkg).or_insert(0) += 1;
Ok(())
while error.is_none() && self.active < self.jobs {
if !queue.is_empty() {
let (key, job, fresh) = queue.remove(0);
- try!(self.run(key, fresh, job, cx.config, scope));
+ self.run(key, fresh, job, cx.config, scope)?;
} else if let Some((fresh, key, jobs)) = self.queue.dequeue() {
let total_fresh = jobs.iter().fold(fresh, |fresh, &(_, f)| {
f.combine(fresh)
match msg {
Message::Run(cmd) => {
- try!(cx.config.shell().verbose(|c| c.status("Running", &cmd)));
+ cx.config.shell().verbose(|c| c.status("Running", &cmd))?;
}
Message::Stdout(out) => {
if cx.config.extra_verbose() {
- try!(writeln!(cx.config.shell().out(), "{}", out));
+ writeln!(cx.config.shell().out(), "{}", out)?;
}
}
Message::Stderr(err) => {
if cx.config.extra_verbose() {
- try!(writeln!(cx.config.shell().err(), "{}", err));
+ writeln!(cx.config.shell().err(), "{}", err)?;
}
}
Message::Finish(result) => {
info!("end: {:?}", key);
self.active -= 1;
match result {
- Ok(()) => try!(self.finish(key, cx)),
+ Ok(()) => self.finish(key, cx)?,
Err(e) => {
if self.active > 0 {
- try!(cx.config.shell().say(
+ cx.config.shell().say(
"Build failed, waiting for other \
- jobs to finish...", YELLOW));
+ jobs to finish...", YELLOW)?;
}
if error.is_none() {
error = Some(e);
duration.subsec_nanos() / 10000000);
if self.queue.is_empty() {
if !self.is_doc_all {
- try!(cx.config.shell().status("Finished", format!("{} [{}] target(s) in {}",
+ cx.config.shell().status("Finished", format!("{} [{}] target(s) in {}",
build_type,
opt_type,
- time_elapsed)));
+ time_elapsed))?;
}
Ok(())
} else if let Some(e) = error {
});
// Print out some nice progress information
- try!(self.note_working_on(config, &key, fresh));
+ self.note_working_on(config, &key, fresh)?;
Ok(())
}
let output = cx.build_state.outputs.lock().unwrap();
if let Some(output) = output.get(&(key.pkg.clone(), key.kind)) {
for warning in output.warnings.iter() {
- try!(cx.config.shell().warn(warning));
+ cx.config.shell().warn(warning)?;
}
}
}
Dirty => {
if key.profile.doc {
self.documented.insert(key.pkg);
- try!(config.shell().status("Documenting", key.pkg));
+ config.shell().status("Documenting", key.pkg)?;
} else {
self.compiled.insert(key.pkg);
- try!(config.shell().status("Compiling", key.pkg));
+ config.shell().status("Compiling", key.pkg)?;
}
}
Fresh if self.counts[key.pkg] == 0 => {
self.compiled.insert(key.pkg);
- try!(config.shell().verbose(|c| c.status("Fresh", key.pkg)));
+ config.shell().verbose(|c| c.status("Fresh", key.pkg))?;
}
Fresh => {}
}
fn dependencies<'cfg>(&self, cx: &Context<'a, 'cfg>)
-> CargoResult<Vec<Key<'a>>> {
let unit = Unit {
- pkg: try!(cx.get_package(self.pkg)),
+ pkg: cx.get_package(self.pkg)?,
target: self.target,
profile: self.profile,
kind: self.kind,
};
- let targets = try!(cx.dep_targets(&unit));
+ let targets = cx.dep_targets(&unit)?;
Ok(targets.iter().filter_map(|unit| {
// Binaries aren't actually needed to *compile* tests, just to run
// them, so we don't include this dependency edge in the job graph.
// the target triple as a Path and then just use the file stem as the
// component for the directory name.
if let Some(triple) = triple {
- path.push(try!(Path::new(triple).file_stem()
- .ok_or(human(format!("target was empty")))));
+ path.push(Path::new(triple).file_stem()
+ .ok_or(human(format!("target was empty")))?);
}
path.push(dest);
Layout::at(ws.config(), path)
// For now we don't do any more finer-grained locking on the artifact
// directory, so just lock the entire thing for the duration of this
// compile.
- let lock = try!(root.open_rw(".cargo-lock", config, "build directory"));
+ let lock = root.open_rw(".cargo-lock", config, "build directory")?;
let root = root.into_path_unlocked();
Ok(Layout {
pub fn prepare(&mut self) -> io::Result<()> {
if fs::metadata(&self.root).is_err() {
- try!(fs::create_dir_all(&self.root));
+ fs::create_dir_all(&self.root)?;
}
- try!(mkdir(&self.deps));
- try!(mkdir(&self.native));
- try!(mkdir(&self.fingerprint));
- try!(mkdir(&self.examples));
- try!(mkdir(&self.build));
+ mkdir(&self.deps)?;
+ mkdir(&self.native)?;
+ mkdir(&self.fingerprint)?;
+ mkdir(&self.examples)?;
+ mkdir(&self.build)?;
return Ok(());
fn mkdir(dir: &Path) -> io::Result<()> {
if fs::metadata(&dir).is_err() {
- try!(fs::create_dir(dir));
+ fs::create_dir(dir)?;
}
Ok(())
}
})
}).collect::<Vec<_>>();
- let mut cx = try!(Context::new(ws, resolve, packages, config,
- build_config, profiles));
+ let mut cx = Context::new(ws, resolve, packages, config,
+ build_config, profiles)?;
let mut queue = JobQueue::new(&cx);
- try!(cx.prepare());
- try!(cx.probe_target_info(&units));
- try!(cx.build_used_in_plugin_map(&units));
- try!(custom_build::build_map(&mut cx, &units));
+ cx.prepare()?;
+ cx.probe_target_info(&units)?;
+ cx.build_used_in_plugin_map(&units)?;
+ custom_build::build_map(&mut cx, &units)?;
for unit in units.iter() {
// Build up a list of pending jobs, each of which represent
// part of this, that's all done next as part of the `execute`
// function which will run everything in order with proper
// parallelism.
- try!(compile(&mut cx, &mut queue, unit));
+ compile(&mut cx, &mut queue, unit)?;
}
// Now that we've figured out everything that we're going to do, do it!
- try!(queue.execute(&mut cx));
+ queue.execute(&mut cx)?;
for unit in units.iter() {
let out_dir = cx.layout(unit).build_out(unit.pkg)
.or_insert(Vec::new())
.push(("OUT_DIR".to_string(), out_dir));
- for (filename, _linkable) in try!(cx.target_filenames(unit)) {
+ for (filename, _linkable) in cx.target_filenames(unit)? {
let dst = cx.out_dir(unit).join(filename);
if unit.profile.test {
cx.compilation.tests.push((unit.pkg.clone(),
if !unit.target.is_lib() { continue }
// Include immediate lib deps as well
- for unit in try!(cx.dep_targets(unit)).iter() {
+ for unit in cx.dep_targets(unit)?.iter() {
let pkgid = unit.pkg.package_id();
if !unit.target.is_lib() { continue }
if unit.profile.doc { continue }
continue
}
- let v = try!(cx.target_filenames(unit));
+ let v = cx.target_filenames(unit)?;
let v = v.into_iter().map(|(f, _)| {
(unit.target.clone(), cx.out_dir(unit).join(f))
}).collect::<Vec<_>>();
// we've got everything constructed.
let p = profile::start(format!("preparing: {}/{}", unit.pkg,
unit.target.name()));
- try!(fingerprint::prepare_init(cx, unit));
- try!(cx.links.validate(unit));
+ fingerprint::prepare_init(cx, unit)?;
+ cx.links.validate(unit)?;
let (dirty, fresh, freshness) = if unit.profile.run_custom_build {
- try!(custom_build::prepare(cx, unit))
+ custom_build::prepare(cx, unit)?
} else {
- let (freshness, dirty, fresh) = try!(fingerprint::prepare_target(cx,
- unit));
+ let (freshness, dirty, fresh) = fingerprint::prepare_target(cx,
+ unit)?;
let work = if unit.profile.doc {
- try!(rustdoc(cx, unit))
+ rustdoc(cx, unit)?
} else {
- try!(rustc(cx, unit))
+ rustc(cx, unit)?
};
let dirty = work.then(dirty);
(dirty, fresh, freshness)
};
- try!(jobs.enqueue(cx, unit, Job::new(dirty, fresh), freshness));
+ jobs.enqueue(cx, unit, Job::new(dirty, fresh), freshness)?;
drop(p);
// Be sure to compile all dependencies of this target as well.
- for unit in try!(cx.dep_targets(unit)).iter() {
- try!(compile(cx, jobs, unit));
+ for unit in cx.dep_targets(unit)?.iter() {
+ compile(cx, jobs, unit)?;
}
Ok(())
}
fn rustc(cx: &mut Context, unit: &Unit) -> CargoResult<Work> {
let crate_types = unit.target.rustc_crate_types();
- let mut rustc = try!(prepare_rustc(cx, crate_types, unit));
+ let mut rustc = prepare_rustc(cx, crate_types, unit)?;
let name = unit.pkg.name().to_string();
if !cx.show_warnings(unit.pkg.package_id()) {
- if try!(cx.config.rustc()).cap_lints {
+ if cx.config.rustc()?.cap_lints {
rustc.arg("--cap-lints").arg("allow");
} else {
rustc.arg("-Awarnings");
}
let has_custom_args = unit.profile.rustc_args.is_some();
- let filenames = try!(cx.target_filenames(unit));
+ let filenames = cx.target_filenames(unit)?;
let root = cx.out_dir(unit);
// Prepare the native lib state (extra -L and -l flags)
let dep_info_loc = fingerprint::dep_info_loc(cx, unit);
let cwd = cx.config.cwd().to_path_buf();
- rustc.args(&try!(cx.rustflags_args(unit)));
+ rustc.args(&cx.rustflags_args(unit)?);
let json_errors = cx.build_config.json_errors;
let package_id = unit.pkg.package_id().clone();
let target = unit.target.clone();
// located somewhere in there.
if let Some(build_deps) = build_deps {
let build_state = build_state.outputs.lock().unwrap();
- try!(add_native_deps(&mut rustc, &build_state, &build_deps,
- pass_l_flag, ¤t_id));
- try!(add_plugin_deps(&mut rustc, &build_state, &build_deps));
+ add_native_deps(&mut rustc, &build_state, &build_deps,
+ pass_l_flag, ¤t_id)?;
+ add_plugin_deps(&mut rustc, &build_state, &build_deps)?;
}
// FIXME(rust-lang/rust#18913): we probably shouldn't have to do
for &(ref filename, _linkable) in filenames.iter() {
let dst = root.join(filename);
if fs::metadata(&dst).is_ok() {
- try!(fs::remove_file(&dst).chain_error(|| {
+ fs::remove_file(&dst).chain_error(|| {
human(format!("Could not remove file: {}.", dst.display()))
- }));
+ })?;
}
}
state.running(&rustc);
- try!(if json_errors {
+ if json_errors {
rustc.exec_with_streaming(
&mut |line| if !line.is_empty() {
Err(internal(&format!("compiler stdout is not empty: `{}`", line)))
Ok(())
},
&mut |line| {
- let compiler_message = try!(json::Json::from_str(line).map_err(|_| {
+ let compiler_message = json::Json::from_str(line).map_err(|_| {
internal(&format!("compiler produced invalid json: `{}`", line))
- }));
+ })?;
machine_message::FromCompiler::new(
&package_id,
rustc.exec()
}.chain_error(|| {
human(format!("Could not compile `{}`.", name))
- }));
+ })?;
if do_rename && real_name != crate_name {
let dst = root.join(&filenames[0].0);
.to_str().unwrap()
.replace(&real_name, &crate_name));
if !has_custom_args || src.exists() {
- try!(fs::rename(&src, &dst).chain_error(|| {
+ fs::rename(&src, &dst).chain_error(|| {
internal(format!("could not rename crate {:?}", src))
- }));
+ })?;
}
}
if !has_custom_args || fs::metadata(&rustc_dep_info_loc).is_ok() {
- try!(fs::rename(&rustc_dep_info_loc, &dep_info_loc).chain_error(|| {
+ fs::rename(&rustc_dep_info_loc, &dep_info_loc).chain_error(|| {
internal(format!("could not rename dep info: {:?}",
rustc_dep_info_loc))
- }));
- try!(fingerprint::append_current_dir(&dep_info_loc, &cwd));
+ })?;
+ fingerprint::append_current_dir(&dep_info_loc, &cwd)?;
}
// If we're a "root crate", e.g. the target of this compilation, then we
let dst = src_dir.parent().unwrap()
.join(src.file_name().unwrap());
if dst.exists() {
- try!(fs::remove_file(&dst).chain_error(|| {
+ fs::remove_file(&dst).chain_error(|| {
human(format!("failed to remove: {}", dst.display()))
- }));
+ })?;
}
- try!(fs::hard_link(&src, &dst)
+ fs::hard_link(&src, &dst)
.or_else(|_| fs::copy(&src, &dst).map(|_| ()))
.chain_error(|| {
human(format!("failed to link or copy `{}` to `{}`",
src.display(), dst.display()))
- }));
+ })?;
}
}
pass_l_flag: bool,
current_id: &PackageId) -> CargoResult<()> {
for key in build_scripts.to_link.iter() {
- let output = try!(build_state.get(key).chain_error(|| {
+ let output = build_state.get(key).chain_error(|| {
internal(format!("couldn't find build state for {}/{:?}",
key.0, key.1))
- }));
+ })?;
for path in output.library_paths.iter() {
rustc.arg("-L").arg(path);
}
let mut search_path = env::split_paths(&search_path).collect::<Vec<_>>();
for id in build_scripts.plugins.iter() {
let key = (id.clone(), Kind::Host);
- let output = try!(build_state.get(&key).chain_error(|| {
+ let output = build_state.get(&key).chain_error(|| {
internal(format!("couldn't find libs for plugin dep {}", id))
- }));
+ })?;
for path in output.library_paths.iter() {
search_path.push(path.clone());
}
}
- let search_path = try!(join_paths(&search_path, var));
+ let search_path = join_paths(&search_path, var)?;
rustc.env(var, &search_path);
Ok(())
}
fn prepare_rustc(cx: &Context,
crate_types: Vec<&str>,
unit: &Unit) -> CargoResult<ProcessBuilder> {
- let mut base = try!(cx.compilation.rustc_process(unit.pkg));
+ let mut base = cx.compilation.rustc_process(unit.pkg)?;
build_base_args(cx, &mut base, unit, &crate_types);
build_plugin_args(&mut base, cx, unit);
- try!(build_deps_args(&mut base, cx, unit));
+ build_deps_args(&mut base, cx, unit)?;
Ok(base)
}
fn rustdoc(cx: &mut Context, unit: &Unit) -> CargoResult<Work> {
- let mut rustdoc = try!(cx.compilation.rustdoc_process(unit.pkg));
+ let mut rustdoc = cx.compilation.rustdoc_process(unit.pkg)?;
rustdoc.arg(&root_path(cx, unit))
.cwd(cx.config.cwd())
.arg("--crate-name").arg(&unit.target.crate_name());
// Create the documentation directory ahead of time as rustdoc currently has
// a bug where concurrent invocations will race to create this directory if
// it doesn't already exist.
- try!(fs::create_dir_all(&doc_dir));
+ fs::create_dir_all(&doc_dir)?;
rustdoc.arg("-o").arg(doc_dir);
rustdoc.args(args);
}
- try!(build_deps_args(&mut rustdoc, cx, unit));
+ build_deps_args(&mut rustdoc, cx, unit)?;
if unit.pkg.has_custom_build() {
rustdoc.env("OUT_DIR", &cx.layout(unit).build_out(unit.pkg));
}
- rustdoc.args(&try!(cx.rustdocflags_args(unit)));
+ rustdoc.args(&cx.rustdocflags_args(unit)?);
let name = unit.pkg.name().to_string();
let build_state = cx.build_state.clone();
cmd.env("OUT_DIR", &layout.build_out(unit.pkg));
}
- for unit in try!(cx.dep_targets(unit)).iter() {
+ for unit in cx.dep_targets(unit)?.iter() {
if unit.target.linkable() && !unit.profile.doc {
- try!(link_to(cmd, cx, unit));
+ link_to(cmd, cx, unit)?;
}
}
fn link_to(cmd: &mut ProcessBuilder, cx: &Context, unit: &Unit)
-> CargoResult<()> {
- for (filename, linkable) in try!(cx.target_filenames(unit)) {
+ for (filename, linkable) in cx.target_filenames(unit)? {
if !linkable {
continue
}
pub fn run_tests(ws: &Workspace,
options: &TestOptions,
test_args: &[String]) -> CargoResult<Option<CargoTestError>> {
- let compilation = try!(compile_tests(ws, options));
+ let compilation = compile_tests(ws, options)?;
if options.no_run {
return Ok(None)
}
let mut errors = if options.only_doc {
- try!(run_doc_tests(options, test_args, &compilation))
+ run_doc_tests(options, test_args, &compilation)?
} else {
- try!(run_unit_tests(options, test_args, &compilation))
+ run_unit_tests(options, test_args, &compilation)?
};
// If we have an error and want to fail fast, return
}
}
- errors.extend(try!(run_doc_tests(options, test_args, &compilation)));
+ errors.extend(run_doc_tests(options, test_args, &compilation)?);
if errors.is_empty() {
Ok(None)
} else {
args: &[String]) -> CargoResult<Option<CargoTestError>> {
let mut args = args.to_vec();
args.push("--bench".to_string());
- let compilation = try!(compile_tests(ws, options));
+ let compilation = compile_tests(ws, options)?;
if options.no_run {
return Ok(None)
}
- let errors = try!(run_unit_tests(options, &args, &compilation));
+ let errors = run_unit_tests(options, &args, &compilation)?;
match errors.len() {
0 => Ok(None),
_ => Ok(Some(CargoTestError::new(errors))),
fn compile_tests<'a>(ws: &Workspace<'a>,
options: &TestOptions<'a>)
-> CargoResult<Compilation<'a>> {
- let mut compilation = try!(ops::compile(ws, &options.compile_opts));
+ let mut compilation = ops::compile(ws, &options.compile_opts)?;
compilation.tests.sort_by(|a, b| {
(a.0.package_id(), &a.1).cmp(&(b.0.package_id(), &b.1))
});
Some(path) => path,
None => &**exe,
};
- let mut cmd = try!(compilation.target_process(exe, pkg));
+ let mut cmd = compilation.target_process(exe, pkg)?;
cmd.args(test_args);
- try!(config.shell().concise(|shell| {
+ config.shell().concise(|shell| {
shell.status("Running", to_display.display().to_string())
- }));
- try!(config.shell().verbose(|shell| {
+ })?;
+ config.shell().verbose(|shell| {
shell.status("Running", cmd.to_string())
- }));
+ })?;
if let Err(e) = cmd.exec() {
errors.push(e);
let config = options.compile_opts.config;
// We don't build/rust doctests if target != host
- if try!(config.rustc()).host != compilation.target {
+ if config.rustc()?.host != compilation.target {
return Ok(errors);
}
for (package, tests) in libs {
for (lib, name, crate_name) in tests {
- try!(config.shell().status("Doc-tests", name));
- let mut p = try!(compilation.rustdoc_process(package));
+ config.shell().status("Doc-tests", name)?;
+ let mut p = compilation.rustdoc_process(package)?;
p.arg("--test").arg(lib)
.arg("--crate-name").arg(&crate_name);
}
}
- try!(config.shell().verbose(|shell| {
+ config.shell().verbose(|shell| {
shell.status("Running", p.to_string())
- }));
+ })?;
if let Err(e) = p.exec() {
errors.push(e);
if !options.no_fail_fast {
}
let root = Filesystem::new(ws.root().to_path_buf());
- let mut f = try!(root.open_ro("Cargo.lock", ws.config(), "Cargo.lock file"));
+ let mut f = root.open_ro("Cargo.lock", ws.config(), "Cargo.lock file")?;
let mut s = String::new();
- try!(f.read_to_string(&mut s).chain_error(|| {
+ f.read_to_string(&mut s).chain_error(|| {
human(format!("failed to read file: {}", f.path().display()))
- }));
+ })?;
(|| {
- let table = try!(cargo_toml::parse(&s, f.path(), ws.config()));
+ let table = cargo_toml::parse(&s, f.path(), ws.config())?;
let table = toml::Value::Table(table);
let mut d = toml::Decoder::new(table);
- let v: resolver::EncodableResolve = try!(Decodable::decode(&mut d));
- Ok(Some(try!(v.into_resolve(ws))))
+ let v: resolver::EncodableResolve = Decodable::decode(&mut d)?;
+ Ok(Some(v.into_resolve(ws)?))
}).chain_error(|| {
human(format!("failed to parse lock file at: {}", f.path().display()))
})
let orig = ws_root.open_ro("Cargo.lock", ws.config(), "Cargo.lock file");
let orig = orig.and_then(|mut f| {
let mut s = String::new();
- try!(f.read_to_string(&mut s));
+ f.read_to_string(&mut s)?;
Ok(s)
});
// Ok, if that didn't work just write it out
ws_root.open_rw("Cargo.lock", ws.config(), "Cargo.lock file").and_then(|mut f| {
- try!(f.file().set_len(0));
- try!(f.write_all(out.as_bytes()));
+ f.file().set_len(0)?;
+ f.write_all(out.as_bytes())?;
Ok(())
}).chain_error(|| {
human(format!("failed to write {}",
}
pub fn publish(ws: &Workspace, opts: &PublishOpts) -> CargoResult<()> {
- let pkg = try!(ws.current());
+ let pkg = ws.current()?;
if !pkg.publish() {
bail!("some crates cannot be published.\n\
`{}` is marked as unpublishable", pkg.name());
}
- let (mut registry, reg_id) = try!(registry(opts.config,
+ let (mut registry, reg_id) = registry(opts.config,
opts.token.clone(),
- opts.index.clone()));
- try!(verify_dependencies(&pkg, ®_id));
+ opts.index.clone())?;
+ verify_dependencies(&pkg, ®_id)?;
// Prepare a tarball, with a non-surpressable warning if metadata
// is missing since this is being put online.
- let tarball = try!(ops::package(ws, &ops::PackageOpts {
+ let tarball = ops::package(ws, &ops::PackageOpts {
config: opts.config,
verify: opts.verify,
list: false,
check_metadata: true,
allow_dirty: opts.allow_dirty,
jobs: opts.jobs,
- })).unwrap();
+ })?.unwrap();
// Upload said tarball to the specified destination
- try!(opts.config.shell().status("Uploading", pkg.package_id().to_string()));
- try!(transmit(opts.config, &pkg, tarball.file(), &mut registry, opts.dry_run));
+ opts.config.shell().status("Uploading", pkg.package_id().to_string())?;
+ transmit(opts.config, &pkg, tarball.file(), &mut registry, opts.dry_run)?;
Ok(())
}
ref keywords, ref readme, ref repository, ref license, ref license_file,
} = *manifest.metadata();
let readme = match *readme {
- Some(ref readme) => Some(try!(paths::read(&pkg.root().join(readme)))),
+ Some(ref readme) => Some(paths::read(&pkg.root().join(readme))?),
None => None,
};
match *license_file {
// Do not upload if performing a dry run
if dry_run {
- try!(config.shell().warn("aborting upload due to dry run"));
+ config.shell().warn("aborting upload due to dry run")?;
return Ok(());
}
}
pub fn registry_configuration(config: &Config) -> CargoResult<RegistryConfig> {
- let index = try!(config.get_string("registry.index")).map(|p| p.val);
- let token = try!(config.get_string("registry.token")).map(|p| p.val);
+ let index = config.get_string("registry.index")?.map(|p| p.val);
+ let token = config.get_string("registry.token")?.map(|p| p.val);
Ok(RegistryConfig { index: index, token: token })
}
let RegistryConfig {
token: token_config,
index: _index_config,
- } = try!(registry_configuration(config));
+ } = registry_configuration(config)?;
let token = token.or(token_config);
let sid = match index {
- Some(index) => SourceId::for_registry(&try!(index.to_url())),
- None => try!(SourceId::crates_io(config)),
+ Some(index) => SourceId::for_registry(&index.to_url()?),
+ None => SourceId::crates_io(config)?,
};
let api_host = {
let mut src = RegistrySource::remote(&sid, config);
- try!(src.update().chain_error(|| {
+ src.update().chain_error(|| {
human(format!("failed to update {}", sid))
- }));
- (try!(src.config())).unwrap().api
+ })?;
+ (src.config()?).unwrap().api
};
- let handle = try!(http_handle(config));
+ let handle = http_handle(config)?;
Ok((Registry::new_handle(api_host, token, handle), sid))
}
// connect phase as well as a "low speed" timeout so if we don't receive
// many bytes in a large-ish period of time then we time out.
let mut handle = Easy::new();
- try!(handle.connect_timeout(Duration::new(30, 0)));
- try!(handle.low_speed_limit(10 /* bytes per second */));
- try!(handle.low_speed_time(Duration::new(30, 0)));
- if let Some(proxy) = try!(http_proxy(config)) {
- try!(handle.proxy(&proxy));
+ handle.connect_timeout(Duration::new(30, 0))?;
+ handle.low_speed_limit(10 /* bytes per second */)?;
+ handle.low_speed_time(Duration::new(30, 0))?;
+ if let Some(proxy) = http_proxy(config)? {
+ handle.proxy(&proxy)?;
}
- if let Some(cainfo) = try!(config.get_path("http.cainfo")) {
- try!(handle.cainfo(&cainfo.val));
+ if let Some(cainfo) = config.get_path("http.cainfo")? {
+ handle.cainfo(&cainfo.val)?;
}
- if let Some(timeout) = try!(http_timeout(config)) {
- try!(handle.connect_timeout(Duration::new(timeout as u64, 0)));
- try!(handle.low_speed_time(Duration::new(timeout as u64, 0)));
+ if let Some(timeout) = http_timeout(config)? {
+ handle.connect_timeout(Duration::new(timeout as u64, 0))?;
+ handle.low_speed_time(Duration::new(timeout as u64, 0))?;
}
Ok(handle)
}
/// Favor cargo's `http.proxy`, then git's `http.proxy`. Proxies specified
/// via environment variables are picked up by libcurl.
fn http_proxy(config: &Config) -> CargoResult<Option<String>> {
- match try!(config.get_string("http.proxy")) {
+ match config.get_string("http.proxy")? {
Some(s) => return Ok(Some(s.val)),
None => {}
}
/// * https_proxy env var
/// * HTTPS_PROXY env var
pub fn http_proxy_exists(config: &Config) -> CargoResult<bool> {
- if try!(http_proxy(config)).is_some() {
+ if http_proxy(config)?.is_some() {
Ok(true)
} else {
Ok(["http_proxy", "HTTP_PROXY",
}
pub fn http_timeout(config: &Config) -> CargoResult<Option<i64>> {
- match try!(config.get_i64("http.timeout")) {
+ match config.get_i64("http.timeout")? {
Some(s) => return Ok(Some(s.val)),
None => {}
}
}
pub fn registry_login(config: &Config, token: String) -> CargoResult<()> {
- let RegistryConfig { index, token: _ } = try!(registry_configuration(config));
+ let RegistryConfig { index, token: _ } = registry_configuration(config)?;
let mut map = HashMap::new();
let p = config.cwd().to_path_buf();
match index {
let name = match opts.krate {
Some(ref name) => name.clone(),
None => {
- let manifest_path = try!(find_root_manifest_for_wd(None, config.cwd()));
- let pkg = try!(Package::for_path(&manifest_path, config));
+ let manifest_path = find_root_manifest_for_wd(None, config.cwd())?;
+ let pkg = Package::for_path(&manifest_path, config)?;
pkg.name().to_string()
}
};
- let (mut registry, _) = try!(registry(config, opts.token.clone(),
- opts.index.clone()));
+ let (mut registry, _) = registry(config, opts.token.clone(),
+ opts.index.clone())?;
match opts.to_add {
Some(ref v) => {
let v = v.iter().map(|s| &s[..]).collect::<Vec<_>>();
- try!(config.shell().status("Owner", format!("adding {:?} to crate {}",
- v, name)));
- try!(registry.add_owners(&name, &v).map_err(|e| {
+ config.shell().status("Owner", format!("adding {:?} to crate {}",
+ v, name))?;
+ registry.add_owners(&name, &v).map_err(|e| {
human(format!("failed to add owners to crate {}: {}", name, e))
- }));
+ })?;
}
None => {}
}
match opts.to_remove {
Some(ref v) => {
let v = v.iter().map(|s| &s[..]).collect::<Vec<_>>();
- try!(config.shell().status("Owner", format!("removing {:?} from crate {}",
- v, name)));
- try!(registry.remove_owners(&name, &v).map_err(|e| {
+ config.shell().status("Owner", format!("removing {:?} from crate {}",
+ v, name))?;
+ registry.remove_owners(&name, &v).map_err(|e| {
human(format!("failed to remove owners from crate {}: {}", name, e))
- }));
+ })?;
}
None => {}
}
if opts.list {
- let owners = try!(registry.list_owners(&name).map_err(|e| {
+ let owners = registry.list_owners(&name).map_err(|e| {
human(format!("failed to list owners of crate {}: {}", name, e))
- }));
+ })?;
for owner in owners.iter() {
print!("{}", owner.login);
match (owner.name.as_ref(), owner.email.as_ref()) {
let name = match krate {
Some(name) => name,
None => {
- let manifest_path = try!(find_root_manifest_for_wd(None, config.cwd()));
- let pkg = try!(Package::for_path(&manifest_path, config));
+ let manifest_path = find_root_manifest_for_wd(None, config.cwd())?;
+ let pkg = Package::for_path(&manifest_path, config)?;
pkg.name().to_string()
}
};
None => bail!("a version must be specified to yank")
};
- let (mut registry, _) = try!(registry(config, token, index));
+ let (mut registry, _) = registry(config, token, index)?;
if undo {
- try!(config.shell().status("Unyank", format!("{}:{}", name, version)));
- try!(registry.unyank(&name, &version).map_err(|e| {
+ config.shell().status("Unyank", format!("{}:{}", name, version))?;
+ registry.unyank(&name, &version).map_err(|e| {
human(format!("failed to undo a yank: {}", e))
- }));
+ })?;
} else {
- try!(config.shell().status("Yank", format!("{}:{}", name, version)));
- try!(registry.yank(&name, &version).map_err(|e| {
+ config.shell().status("Yank", format!("{}:{}", name, version))?;
+ registry.yank(&name, &version).map_err(|e| {
human(format!("failed to yank: {}", e))
- }));
+ })?;
}
Ok(())
}
}
- let (mut registry, _) = try!(registry(config, None, index));
- let (crates, total_crates) = try!(registry.search(query, limit).map_err(|e| {
+ let (mut registry, _) = registry(config, None, index)?;
+ let (crates, total_crates) = registry.search(query, limit).map_err(|e| {
human(format!("failed to retrieve search results from the registry: {}", e))
- }));
+ })?;
let list_items = crates.iter()
.map(|krate| (
}
None => name
};
- try!(config.shell().say(line, BLACK));
+ config.shell().say(line, BLACK)?;
}
let search_max_limit = 100;
if total_crates > limit as u32 && limit < search_max_limit {
- try!(config.shell().say(
+ config.shell().say(
format!("... and {} crates more (use --limit N to see more)",
total_crates - limit as u32),
BLACK)
- );
+ ?;
} else if total_crates > limit as u32 && limit >= search_max_limit {
- try!(config.shell().say(
+ config.shell().say(
format!(
"... and {} crates more (go to http://crates.io/search?q={} to see more)",
total_crates - limit as u32,
percent_encode(query.as_bytes(), QUERY_ENCODE_SET)
),
BLACK)
- );
+ ?;
}
Ok(())
/// lockfile.
pub fn resolve_ws(registry: &mut PackageRegistry, ws: &Workspace)
-> CargoResult<Resolve> {
- let prev = try!(ops::load_pkg_lockfile(ws));
- let resolve = try!(resolve_with_previous(registry, ws,
+ let prev = ops::load_pkg_lockfile(ws)?;
+ let resolve = resolve_with_previous(registry, ws,
Method::Everything,
- prev.as_ref(), None, &[]));
+ prev.as_ref(), None, &[])?;
// Avoid writing a lockfile if we are `cargo install`ing a non local package.
if ws.current_opt().map(|pkg| pkg.package_id().source_id().is_path()).unwrap_or(true) {
- try!(ops::write_pkg_lockfile(ws, &resolve));
+ ops::write_pkg_lockfile(ws, &resolve)?;
}
Ok(resolve)
}
let mut summaries = Vec::new();
for member in ws.members() {
- try!(registry.add_sources(&[member.package_id().source_id()
- .clone()]));
+ registry.add_sources(&[member.package_id().source_id()
+ .clone()])?;
let method_to_resolve = match method {
// When everything for a workspace we want to be sure to resolve all
// members in the workspace, so propagate the `Method::Everything`.
None => root_replace.to_vec(),
};
- let mut resolved = try!(resolver::resolve(&summaries, &replace, registry));
+ let mut resolved = resolver::resolve(&summaries, &replace, registry)?;
if let Some(previous) = previous {
- try!(resolved.merge_from(previous));
+ resolved.merge_from(previous)?;
}
return Ok(resolved);
impl<'cfg> SourceConfigMap<'cfg> {
pub fn new(config: &'cfg Config) -> CargoResult<SourceConfigMap<'cfg>> {
- let mut base = try!(SourceConfigMap::empty(config));
- if let Some(table) = try!(config.get_table("source")) {
+ let mut base = SourceConfigMap::empty(config)?;
+ if let Some(table) = config.get_table("source")? {
for (key, value) in table.val.iter() {
- try!(base.add_config(key, value));
+ base.add_config(key, value)?;
}
}
Ok(base)
config: config,
};
base.add("crates-io", SourceConfig {
- id: try!(SourceId::crates_io(config)),
+ id: SourceId::crates_io(config)?,
replace_with: None,
});
Ok(base)
}
fn add_config(&mut self, name: &str, cfg: &ConfigValue) -> CargoResult<()> {
- let (table, _path) = try!(cfg.table(&format!("source.{}", name)));
+ let (table, _path) = cfg.table(&format!("source.{}", name))?;
let mut srcs = Vec::new();
if let Some(val) = table.get("registry") {
- let url = try!(url(val, &format!("source.{}.registry", name)));
+ let url = url(val, &format!("source.{}.registry", name))?;
srcs.push(SourceId::for_registry(&url));
}
if let Some(val) = table.get("local-registry") {
- let (s, path) = try!(val.string(&format!("source.{}.local-registry",
- name)));
+ let (s, path) = val.string(&format!("source.{}.local-registry",
+ name))?;
let mut path = path.to_path_buf();
path.pop();
path.pop();
path.push(s);
- srcs.push(try!(SourceId::for_local_registry(&path)));
+ srcs.push(SourceId::for_local_registry(&path)?);
}
if let Some(val) = table.get("directory") {
- let (s, path) = try!(val.string(&format!("source.{}.directory",
- name)));
+ let (s, path) = val.string(&format!("source.{}.directory",
+ name))?;
let mut path = path.to_path_buf();
path.pop();
path.pop();
path.push(s);
- srcs.push(try!(SourceId::for_directory(&path)));
+ srcs.push(SourceId::for_directory(&path)?);
}
if name == "crates-io" && srcs.is_empty() {
- srcs.push(try!(SourceId::crates_io(self.config)));
+ srcs.push(SourceId::crates_io(self.config)?);
}
let mut srcs = srcs.into_iter();
- let src = try!(srcs.next().chain_error(|| {
+ let src = srcs.next().chain_error(|| {
human(format!("no source URL specified for `source.{}`, need \
either `registry` or `local-registry` defined",
name))
- }));
+ })?;
if srcs.next().is_some() {
return Err(human(format!("more than one source URL specified for \
`source.{}`", name)))
let mut replace_with = None;
if let Some(val) = table.get("replace-with") {
- let (s, path) = try!(val.string(&format!("source.{}.replace-with",
- name)));
+ let (s, path) = val.string(&format!("source.{}.replace-with",
+ name))?;
replace_with = Some((s.to_string(), path.to_path_buf()));
}
return Ok(());
fn url(cfg: &ConfigValue, key: &str) -> CargoResult<Url> {
- let (url, path) = try!(cfg.string(key));
+ let (url, path) = cfg.string(key)?;
url.to_url().chain_error(|| {
human(format!("configuration key `{}` specified an invalid \
URL (in {})", key, path.display()))
impl<'cfg> Source for DirectorySource<'cfg> {
fn update(&mut self) -> CargoResult<()> {
self.packages.clear();
- let entries = try!(self.root.read_dir().chain_error(|| {
+ let entries = self.root.read_dir().chain_error(|| {
human(format!("failed to read root of directory source: {}",
self.root.display()))
- }));
+ })?;
for entry in entries {
- let entry = try!(entry);
+ let entry = entry?;
let path = entry.path();
let mut src = PathSource::new(&path,
&self.id,
self.config);
- try!(src.update());
- let pkg = try!(src.root_package());
+ src.update()?;
+ let pkg = src.root_package()?;
let cksum_file = path.join(".cargo-checksum.json");
- let cksum = try!(paths::read(&path.join(cksum_file)).chain_error(|| {
+ let cksum = paths::read(&path.join(cksum_file)).chain_error(|| {
human(format!("failed to load checksum `.cargo-checksum.json` \
of {} v{}",
pkg.package_id().name(),
pkg.package_id().version()))
- }));
- let cksum: Checksum = try!(json::decode(&cksum).chain_error(|| {
+ })?;
+ let cksum: Checksum = json::decode(&cksum).chain_error(|| {
human(format!("failed to decode `.cargo-checksum.json` of \
{} v{}",
pkg.package_id().name(),
pkg.package_id().version()))
- }));
+ })?;
let mut manifest = pkg.manifest().clone();
let summary = manifest.summary().clone();
let mut h = Sha256::new();
let file = pkg.root().join(file);
- try!((|| -> CargoResult<()> {
- let mut f = try!(File::open(&file));
+ (|| -> CargoResult<()> {
+ let mut f = File::open(&file)?;
loop {
- match try!(f.read(&mut buf)) {
+ match f.read(&mut buf)? {
0 => return Ok(()),
n => h.update(&buf[..n]),
}
}).chain_error(|| {
human(format!("failed to calculate checksum of: {}",
file.display()))
- }));
+ })?;
let actual = h.finish().to_hex();
if &*actual != cksum {
pub fn read_packages(&mut self) -> CargoResult<Vec<Package>> {
if self.path_source.is_none() {
- try!(self.update());
+ self.update()?;
}
self.path_source.as_mut().unwrap().read_packages()
}
impl<'cfg> Debug for GitSource<'cfg> {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
- try!(write!(f, "git repo at {}", self.remote.url()));
+ write!(f, "git repo at {}", self.remote.url())?;
match self.reference.to_ref_string() {
Some(s) => write!(f, " ({})", s),
impl<'cfg> Source for GitSource<'cfg> {
fn update(&mut self) -> CargoResult<()> {
- let lock = try!(self.config.git_path()
- .open_rw(".cargo-lock-git", self.config, "the git checkouts"));
+ let lock = self.config.git_path()
+ .open_rw(".cargo-lock-git", self.config, "the git checkouts")?;
let db_path = lock.parent().join("db").join(&self.ident);
self.source_id.precise().is_none();
let (repo, actual_rev) = if should_update {
- try!(self.config.shell().status("Updating",
- format!("git repository `{}`", self.remote.url())));
+ self.config.shell().status("Updating",
+ format!("git repository `{}`", self.remote.url()))?;
trace!("updating git source `{:?}`", self.remote);
- let repo = try!(self.remote.checkout(&db_path, &self.config));
- let rev = try!(repo.rev_for(&self.reference));
+ let repo = self.remote.checkout(&db_path, &self.config)?;
+ let rev = repo.rev_for(&self.reference)?;
(repo, rev)
} else {
- (try!(self.remote.db_at(&db_path)), actual_rev.unwrap())
+ (self.remote.db_at(&db_path)?, actual_rev.unwrap())
};
let checkout_path = lock.parent().join("checkouts")
// in scope so the destructors here won't tamper with too much.
// Checkout is immutable, so we don't need to protect it with a lock once
// it is created.
- try!(repo.copy_to(actual_rev.clone(), &checkout_path, &self.config));
+ repo.copy_to(actual_rev.clone(), &checkout_path, &self.config)?;
let source_id = self.source_id.with_precise(Some(actual_rev.to_string()));
let path_source = PathSource::new_recursive(&checkout_path,
pub fn rev_for(&self, path: &Path, reference: &GitReference)
-> CargoResult<GitRevision> {
- let db = try!(self.db_at(path));
+ let db = self.db_at(path)?;
db.rev_for(reference)
}
pub fn checkout(&self, into: &Path, cargo_config: &Config) -> CargoResult<GitDatabase> {
let repo = match git2::Repository::open(into) {
Ok(repo) => {
- try!(self.fetch_into(&repo, &cargo_config).chain_error(|| {
+ self.fetch_into(&repo, &cargo_config).chain_error(|| {
human(format!("failed to fetch into {}", into.display()))
- }));
+ })?;
repo
}
Err(..) => {
- try!(self.clone_into(into, &cargo_config).chain_error(|| {
+ self.clone_into(into, &cargo_config).chain_error(|| {
human(format!("failed to clone into: {}", into.display()))
- }))
+ })?
}
};
}
pub fn db_at(&self, db_path: &Path) -> CargoResult<GitDatabase> {
- let repo = try!(git2::Repository::open(db_path));
+ let repo = git2::Repository::open(db_path)?;
Ok(GitDatabase {
remote: self.clone(),
path: db_path.to_path_buf(),
fn clone_into(&self, dst: &Path, cargo_config: &Config) -> CargoResult<git2::Repository> {
let url = self.url.to_string();
if fs::metadata(&dst).is_ok() {
- try!(fs::remove_dir_all(dst));
+ fs::remove_dir_all(dst)?;
}
- try!(fs::create_dir_all(dst));
- let repo = try!(git2::Repository::init_bare(dst));
- try!(fetch(&repo, &url, "refs/heads/*:refs/heads/*", &cargo_config));
+ fs::create_dir_all(dst)?;
+ let repo = git2::Repository::init_bare(dst)?;
+ fetch(&repo, &url, "refs/heads/*:refs/heads/*", &cargo_config)?;
Ok(repo)
}
}
Ok(repo) => {
let checkout = GitCheckout::new(dest, self, rev, repo);
if !checkout.is_fresh() {
- try!(checkout.fetch(&cargo_config));
- try!(checkout.reset());
+ checkout.fetch(&cargo_config)?;
+ checkout.reset()?;
assert!(checkout.is_fresh());
}
checkout
}
- Err(..) => try!(GitCheckout::clone_into(dest, self, rev)),
+ Err(..) => GitCheckout::clone_into(dest, self, rev)?,
};
- try!(checkout.update_submodules(&cargo_config).chain_error(|| {
+ checkout.update_submodules(&cargo_config).chain_error(|| {
internal("failed to update submodules")
- }));
+ })?;
Ok(checkout)
}
pub fn rev_for(&self, reference: &GitReference) -> CargoResult<GitRevision> {
let id = match *reference {
GitReference::Tag(ref s) => {
- try!((|| {
+ (|| {
let refname = format!("refs/tags/{}", s);
- let id = try!(self.repo.refname_to_id(&refname));
- let obj = try!(self.repo.find_object(id, None));
- let obj = try!(obj.peel(ObjectType::Commit));
+ let id = self.repo.refname_to_id(&refname)?;
+ let obj = self.repo.find_object(id, None)?;
+ let obj = obj.peel(ObjectType::Commit)?;
Ok(obj.id())
}).chain_error(|| {
human(format!("failed to find tag `{}`", s))
- }))
+ })?
}
GitReference::Branch(ref s) => {
- try!((|| {
- let b = try!(self.repo.find_branch(s, git2::BranchType::Local));
+ (|| {
+ let b = self.repo.find_branch(s, git2::BranchType::Local)?;
b.get().target().chain_error(|| {
human(format!("branch `{}` did not have a target", s))
})
}).chain_error(|| {
human(format!("failed to find branch `{}`", s))
- }))
+ })?
}
GitReference::Rev(ref s) => {
- let obj = try!(self.repo.revparse_single(s));
+ let obj = self.repo.revparse_single(s)?;
obj.id()
}
};
}
pub fn has_ref(&self, reference: &str) -> CargoResult<()> {
- try!(self.repo.revparse_single(reference));
+ self.repo.revparse_single(reference)?;
Ok(())
}
}
revision: GitRevision)
-> CargoResult<GitCheckout<'a>>
{
- let repo = try!(GitCheckout::clone_repo(database.path(), into));
+ let repo = GitCheckout::clone_repo(database.path(), into)?;
let checkout = GitCheckout::new(into, database, revision, repo);
- try!(checkout.reset());
+ checkout.reset()?;
Ok(checkout)
}
fn clone_repo(source: &Path, into: &Path) -> CargoResult<git2::Repository> {
let dirname = into.parent().unwrap();
- try!(fs::create_dir_all(&dirname).chain_error(|| {
+ fs::create_dir_all(&dirname).chain_error(|| {
human(format!("Couldn't mkdir {}", dirname.display()))
- }));
+ })?;
if fs::metadata(&into).is_ok() {
- try!(fs::remove_dir_all(into).chain_error(|| {
+ fs::remove_dir_all(into).chain_error(|| {
human(format!("Couldn't rmdir {}", into.display()))
- }));
+ })?;
}
- let url = try!(source.to_url());
+ let url = source.to_url()?;
let url = url.to_string();
- let repo = try!(git2::Repository::clone(&url, into).chain_error(|| {
+ let repo = git2::Repository::clone(&url, into).chain_error(|| {
internal(format!("failed to clone {} into {}", source.display(),
into.display()))
- }));
+ })?;
Ok(repo)
}
fn fetch(&self, cargo_config: &Config) -> CargoResult<()> {
info!("fetch {}", self.repo.path().display());
- let url = try!(self.database.path.to_url());
+ let url = self.database.path.to_url()?;
let url = url.to_string();
let refspec = "refs/heads/*:refs/heads/*";
- try!(fetch(&self.repo, &url, refspec, &cargo_config));
+ fetch(&self.repo, &url, refspec, &cargo_config)?;
Ok(())
}
let ok_file = self.location.join(".cargo-ok");
let _ = fs::remove_file(&ok_file);
info!("reset {} to {}", self.repo.path().display(), self.revision);
- let object = try!(self.repo.find_object(self.revision.0, None));
- try!(self.repo.reset(&object, git2::ResetType::Hard, None));
- try!(File::create(ok_file));
+ let object = self.repo.find_object(self.revision.0, None)?;
+ self.repo.reset(&object, git2::ResetType::Hard, None)?;
+ File::create(ok_file)?;
Ok(())
}
fn update_submodules(repo: &git2::Repository, cargo_config: &Config) -> CargoResult<()> {
info!("update submodules for: {:?}", repo.workdir().unwrap());
- for mut child in try!(repo.submodules()).into_iter() {
- try!(child.init(false));
- let url = try!(child.url().chain_error(|| {
+ for mut child in repo.submodules()?.into_iter() {
+ child.init(false)?;
+ let url = child.url().chain_error(|| {
internal("non-utf8 url for submodule")
- }));
+ })?;
// A submodule which is listed in .gitmodules but not actually
// checked out will not have a head id, so we should ignore it.
// as the submodule's head, then we can bail out and go to the
// next submodule.
let head_and_repo = child.open().and_then(|repo| {
- let target = try!(repo.head()).target();
+ let target = repo.head()?.target();
Ok((target, repo))
});
let repo = match head_and_repo {
Err(..) => {
let path = repo.workdir().unwrap().join(child.path());
let _ = fs::remove_dir_all(&path);
- try!(git2::Repository::clone(url, &path))
+ git2::Repository::clone(url, &path)?
}
};
// Fetch data from origin and reset to the head commit
let refspec = "refs/heads/*:refs/heads/*";
- try!(fetch(&repo, url, refspec, &cargo_config).chain_error(|| {
+ fetch(&repo, url, refspec, &cargo_config).chain_error(|| {
internal(format!("failed to fetch submodule `{}` from {}",
child.name().unwrap_or(""), url))
- }));
+ })?;
- let obj = try!(repo.find_object(head, None));
- try!(repo.reset(&obj, git2::ResetType::Hard, None));
- try!(update_submodules(&repo, &cargo_config));
+ let obj = repo.find_object(head, None)?;
+ repo.reset(&obj, git2::ResetType::Hard, None)?;
+ update_submodules(&repo, &cargo_config)?;
}
Ok(())
}
was specified")
}
- with_authentication(url, &try!(repo.config()), |f| {
+ with_authentication(url, &repo.config()?, |f| {
let mut cb = git2::RemoteCallbacks::new();
cb.credentials(f);
// Create a local anonymous remote in the repository to fetch the url
- let mut remote = try!(repo.remote_anonymous(&url));
+ let mut remote = repo.remote_anonymous(&url)?;
let mut opts = git2::FetchOptions::new();
opts.remote_callbacks(cb)
.download_tags(git2::AutotagOption::All);
- try!(network::with_retry(config, ||{
+ network::with_retry(config, ||{
remote.fetch(&[refspec], Some(&mut opts), None)
- }));
+ })?;
Ok(())
})
}
pub fn root_package(&mut self) -> CargoResult<Package> {
trace!("root_package; source={:?}", self);
- try!(self.update());
+ self.update()?;
match self.packages.iter().find(|p| p.root() == &*self.path) {
Some(pkg) => Ok(pkg.clone()),
ops::read_packages(&self.path, &self.id, self.config)
} else {
let path = self.path.join("Cargo.toml");
- let (pkg, _) = try!(ops::read_package(&path, &self.id,
- self.config));
+ let (pkg, _) = ops::read_package(&path, &self.id,
+ self.config)?;
Ok(vec![pkg])
}
}
human(format!("could not parse pattern `{}`: {}", p, e))
})
};
- let exclude = try!(pkg.manifest().exclude().iter()
- .map(|p| parse(p)).collect::<Result<Vec<_>, _>>());
- let include = try!(pkg.manifest().include().iter()
- .map(|p| parse(p)).collect::<Result<Vec<_>, _>>());
+ let exclude = pkg.manifest().exclude().iter()
+ .map(|p| parse(p)).collect::<Result<Vec<_>, _>>()?;
+ let include = pkg.manifest().include().iter()
+ .map(|p| parse(p)).collect::<Result<Vec<_>, _>>()?;
let mut filter = |p: &Path| {
let relative_path = util::without_prefix(p, &root).unwrap();
// check to see if we are indeed part of the index. If not, then
// this is likely an unrelated git repo, so keep going.
if let Ok(repo) = git2::Repository::open(cur) {
- let index = try!(repo.index());
+ let index = repo.index()?;
let path = util::without_prefix(root, cur)
.unwrap().join("Cargo.toml");
if index.get_path(&path, 0).is_some() {
filter: &mut FnMut(&Path) -> bool)
-> CargoResult<Vec<PathBuf>> {
warn!("list_files_git {}", pkg.package_id());
- let index = try!(repo.index());
- let root = try!(repo.workdir().chain_error(|| {
+ let index = repo.index()?;
+ let root = repo.workdir().chain_error(|| {
internal_error("Can't list files on a bare repository.", "")
- }));
+ })?;
let pkg_path = pkg.root();
let mut ret = Vec::<PathBuf>::new();
if let Some(suffix) = util::without_prefix(pkg_path, &root) {
opts.pathspec(suffix);
}
- let statuses = try!(repo.statuses(Some(&mut opts)));
+ let statuses = repo.statuses(Some(&mut opts))?;
let untracked = statuses.iter().filter_map(|entry| {
match entry.status() {
git2::STATUS_WT_NEW => Some((join(&root, entry.path_bytes()), None)),
let mut subpackages_found = Vec::new();
'outer: for (file_path, is_dir) in index_files.chain(untracked) {
- let file_path = try!(file_path);
+ let file_path = file_path?;
// Filter out files blatantly outside this package. This is helped a
// bit obove via the `pathspec` function call, but we need to filter
if is_dir.unwrap_or_else(|| file_path.is_dir()) {
warn!(" found submodule {}", file_path.display());
let rel = util::without_prefix(&file_path, &root).unwrap();
- let rel = try!(rel.to_str().chain_error(|| {
+ let rel = rel.to_str().chain_error(|| {
human(format!("invalid utf-8 filename: {}", rel.display()))
- }));
+ })?;
// Git submodules are currently only named through `/` path
// separators, explicitly not `\` which windows uses. Who knew?
let rel = rel.replace(r"\", "/");
match repo.find_submodule(&rel).and_then(|s| s.open()) {
Ok(repo) => {
- let files = try!(self.list_files_git(pkg, repo, filter));
+ let files = self.list_files_git(pkg, repo, filter)?;
ret.extend(files.into_iter());
}
Err(..) => {
- try!(PathSource::walk(&file_path, &mut ret, false,
- filter));
+ PathSource::walk(&file_path, &mut ret, false,
+ filter)?;
}
}
} else if (*filter)(&file_path) {
fn list_files_walk(&self, pkg: &Package, filter: &mut FnMut(&Path) -> bool)
-> CargoResult<Vec<PathBuf>> {
let mut ret = Vec::new();
- try!(PathSource::walk(pkg.root(), &mut ret, true, filter));
+ PathSource::walk(pkg.root(), &mut ret, true, filter)?;
Ok(ret)
}
if !is_root && fs::metadata(&path.join("Cargo.toml")).is_ok() {
return Ok(())
}
- for dir in try!(fs::read_dir(path)) {
- let dir = try!(dir).path();
+ for dir in fs::read_dir(path)? {
+ let dir = dir?.path();
let name = dir.file_name().and_then(|s| s.to_str());
// Skip dotfile directories
if name.map(|s| s.starts_with('.')) == Some(true) {
_ => {}
}
}
- try!(PathSource::walk(&dir, ret, false, filter));
+ PathSource::walk(&dir, ret, false, filter)?;
}
Ok(())
}
impl<'cfg> Source for PathSource<'cfg> {
fn update(&mut self) -> CargoResult<()> {
if !self.updated {
- let packages = try!(self.read_packages());
+ let packages = self.read_packages()?;
self.packages.extend(packages.into_iter());
self.updated = true;
}
let mut max = FileTime::zero();
let mut max_path = PathBuf::from("");
- for file in try!(self.list_files(pkg)) {
+ for file in self.list_files(pkg)? {
// An fs::stat error here is either because path is a
// broken symlink, a permissions error, or a race
// condition where this path was rm'ed - either way,
return Ok(s.clone())
}
// Ok, we're missing the key, so parse the index file to load it.
- try!(self.summaries(pkg.name()));
+ self.summaries(pkg.name())?;
self.hashes.get(&key).chain_error(|| {
internal(format!("no hash listed for {}", pkg))
}).map(|s| s.clone())
if self.cache.contains_key(name) {
return Ok(self.cache.get(name).unwrap());
}
- let summaries = try!(self.load_summaries(name));
+ let summaries = self.load_summaries(name)?;
let summaries = summaries.into_iter().filter(|summary| {
summary.0.package_id().name() == name
}).collect();
match File::open(&path) {
Ok(mut f) => {
let mut contents = String::new();
- try!(f.read_to_string(&mut contents));
+ f.read_to_string(&mut contents)?;
let ret: CargoResult<Vec<(Summary, bool)>>;
ret = contents.lines().filter(|l| l.trim().len() > 0)
.map(|l| self.parse_registry_package(l))
-> CargoResult<(Summary, bool)> {
let RegistryPackage {
name, vers, cksum, deps, features, yanked
- } = try!(json::decode::<RegistryPackage>(line));
- let pkgid = try!(PackageId::new(&name, &vers, &self.source_id));
+ } = json::decode::<RegistryPackage>(line)?;
+ let pkgid = PackageId::new(&name, &vers, &self.source_id)?;
let deps: CargoResult<Vec<Dependency>> = deps.into_iter().map(|dep| {
self.parse_registry_dependency(dep)
}).collect();
- let deps = try!(deps);
- let summary = try!(Summary::new(pkgid, deps, features));
+ let deps = deps?;
+ let summary = Summary::new(pkgid, deps, features)?;
let summary = summary.set_checksum(cksum.clone());
self.hashes.insert((name, vers), cksum);
Ok((summary, yanked.unwrap_or(false)))
name, req, features, optional, default_features, target, kind
} = dep;
- let dep = try!(DependencyInner::parse(&name, Some(&req), &self.source_id, None));
+ let dep = DependencyInner::parse(&name, Some(&req), &self.source_id, None)?;
let kind = match kind.as_ref().map(|s| &s[..]).unwrap_or("") {
"dev" => Kind::Development,
"build" => Kind::Build,
};
let platform = match target {
- Some(target) => Some(try!(target.parse())),
+ Some(target) => Some(target.parse()?),
None => None,
};
impl<'cfg> Registry for RegistryIndex<'cfg> {
fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
let mut summaries = {
- let summaries = try!(self.summaries(dep.name()));
+ let summaries = self.summaries(dep.name())?;
summaries.iter().filter(|&&(_, yanked)| {
dep.source_id().precise().is_some() || !yanked
}).map(|s| s.0.clone()).collect::<Vec<_>>()
fn download(&mut self, pkg: &PackageId, checksum: &str)
-> CargoResult<FileLock> {
let crate_file = format!("{}-{}.crate", pkg.name(), pkg.version());
- let mut crate_file = try!(self.root.open_ro(&crate_file,
+ let mut crate_file = self.root.open_ro(&crate_file,
self.config,
- "crate file"));
+ "crate file")?;
// If we've already got an unpacked version of this crate, then skip the
// checksum below as it is in theory already verified.
return Ok(crate_file)
}
- try!(self.config.shell().status("Unpacking", pkg));
+ self.config.shell().status("Unpacking", pkg)?;
// We don't actually need to download anything per-se, we just need to
// verify the checksum matches the .crate file itself.
let mut state = Sha256::new();
let mut buf = [0; 64 * 1024];
loop {
- let n = try!(crate_file.read(&mut buf).chain_error(|| {
+ let n = crate_file.read(&mut buf).chain_error(|| {
human(format!("failed to read `{}`", crate_file.path().display()))
- }));
+ })?;
if n == 0 {
break
}
bail!("failed to verify the checksum of `{}`", pkg)
}
- try!(crate_file.seek(SeekFrom::Start(0)));
+ crate_file.seek(SeekFrom::Start(0))?;
Ok(crate_file)
}
-> CargoResult<PathBuf> {
let dst = self.src_path.join(&format!("{}-{}", pkg.name(),
pkg.version()));
- try!(dst.create_dir());
+ dst.create_dir()?;
// Note that we've already got the `tarball` locked above, and that
// implies a lock on the unpacked destination as well, so this access
// via `into_path_unlocked` should be ok.
return Ok(dst)
}
- let gz = try!(GzDecoder::new(tarball.file()));
+ let gz = GzDecoder::new(tarball.file())?;
let mut tar = Archive::new(gz);
- try!(tar.unpack(dst.parent().unwrap()));
- try!(File::create(&ok));
+ tar.unpack(dst.parent().unwrap())?;
+ File::create(&ok)?;
Ok(dst)
}
fn do_update(&mut self) -> CargoResult<()> {
- try!(self.ops.update_index());
+ self.ops.update_index()?;
let path = self.ops.index_path();
self.index = index::RegistryIndex::new(&self.source_id,
path,
// come back with no summaries, then our registry may need to be
// updated, so we fall back to performing a lazy update.
if dep.source_id().precise().is_some() && !self.updated {
- if try!(self.index.query(dep)).is_empty() {
- try!(self.do_update());
+ if self.index.query(dep)?.is_empty() {
+ self.do_update()?;
}
}
// `Some("locked")` as other `Some` values indicate a `cargo update
// --precise` request
if self.source_id.precise() != Some("locked") {
- try!(self.do_update());
+ self.do_update()?;
}
Ok(())
}
fn download(&mut self, package: &PackageId) -> CargoResult<Package> {
- let hash = try!(self.index.hash(package));
- let path = try!(self.ops.download(package, &hash));
- let path = try!(self.unpack_package(package, &path).chain_error(|| {
+ let hash = self.index.hash(package)?;
+ let path = self.ops.download(package, &hash)?;
+ let path = self.unpack_package(package, &path).chain_error(|| {
internal(format!("failed to unpack package `{}`", package))
- }));
+ })?;
let mut src = PathSource::new(&path, &self.source_id, self.config);
- try!(src.update());
- let pkg = try!(src.download(package));
+ src.update()?;
+ let pkg = src.download(package)?;
// Unfortunately the index and the actual Cargo.toml in the index can
// differ due to historical Cargo bugs. To paper over these we trash the
// *summary* loaded from the Cargo.toml we just downloaded with the one
// we loaded from the index.
- let summaries = try!(self.index.summaries(package.name()));
+ let summaries = self.index.summaries(package.name())?;
let summary = summaries.iter().map(|s| &s.0).find(|s| {
s.package_id() == package
}).expect("summary not found");
}
fn config(&self) -> CargoResult<Option<RegistryConfig>> {
- let lock = try!(self.index_path.open_ro(Path::new(INDEX_LOCK),
+ let lock = self.index_path.open_ro(Path::new(INDEX_LOCK),
self.config,
- "the registry index"));
+ "the registry index")?;
let path = lock.path().parent().unwrap();
- let contents = try!(paths::read(&path.join("config.json")));
- let config = try!(json::decode(&contents));
+ let contents = paths::read(&path.join("config.json"))?;
+ let config = json::decode(&contents)?;
Ok(Some(config))
}
//
// This way if there's a problem the error gets printed before we even
// hit the index, which may not actually read this configuration.
- try!(ops::http_handle(self.config));
+ ops::http_handle(self.config)?;
// Then we actually update the index
- try!(self.index_path.create_dir());
- let lock = try!(self.index_path.open_rw(Path::new(INDEX_LOCK),
+ self.index_path.create_dir()?;
+ let lock = self.index_path.open_rw(Path::new(INDEX_LOCK),
self.config,
- "the registry index"));
+ "the registry index")?;
let path = lock.path().parent().unwrap();
- try!(self.config.shell().status("Updating",
- format!("registry `{}`", self.source_id.url())));
+ self.config.shell().status("Updating",
+ format!("registry `{}`", self.source_id.url()))?;
- let repo = try!(git2::Repository::open(path).or_else(|_| {
+ let repo = git2::Repository::open(path).or_else(|_| {
let _ = lock.remove_siblings();
git2::Repository::init(path)
- }));
+ })?;
if self.source_id.url().host_str() == Some("github.com") {
if let Ok(oid) = repo.refname_to_id("refs/heads/master") {
let handle = match self.handle {
Some(ref mut handle) => handle,
None => {
- self.handle = Some(try!(ops::http_handle(self.config)));
+ self.handle = Some(ops::http_handle(self.config)?);
self.handle.as_mut().unwrap()
}
};
let url = self.source_id.url().to_string();
let refspec = "refs/heads/*:refs/remotes/origin/*";
- try!(git::fetch(&repo, &url, refspec, &self.config).chain_error(|| {
+ git::fetch(&repo, &url, refspec, &self.config).chain_error(|| {
human(format!("failed to fetch `{}`", url))
- }));
+ })?;
// git reset --hard origin/master
let reference = "refs/remotes/origin/master";
- let oid = try!(repo.refname_to_id(reference));
+ let oid = repo.refname_to_id(reference)?;
trace!("[{}] updating to rev {}", self.source_id, oid);
- let object = try!(repo.find_object(oid, None));
- try!(repo.reset(&object, git2::ResetType::Hard, None));
+ let object = repo.find_object(oid, None)?;
+ repo.reset(&object, git2::ResetType::Hard, None)?;
Ok(())
}
// If this fails then we fall through to the exclusive path where we may
// have to redownload the file.
if let Ok(dst) = self.cache_path.open_ro(path, self.config, &filename) {
- let meta = try!(dst.file().metadata());
+ let meta = dst.file().metadata()?;
if meta.len() > 0 {
return Ok(dst)
}
}
- let mut dst = try!(self.cache_path.open_rw(path, self.config, &filename));
- let meta = try!(dst.file().metadata());
+ let mut dst = self.cache_path.open_rw(path, self.config, &filename)?;
+ let meta = dst.file().metadata()?;
if meta.len() > 0 {
return Ok(dst)
}
- try!(self.config.shell().status("Downloading", pkg));
+ self.config.shell().status("Downloading", pkg)?;
- let config = try!(self.config()).unwrap();
- let mut url = try!(config.dl.to_url());
+ let config = self.config()?.unwrap();
+ let mut url = config.dl.to_url()?;
url.path_segments_mut().unwrap()
.push(pkg.name())
.push(&pkg.version().to_string())
let handle = match self.handle {
Some(ref mut handle) => handle,
None => {
- self.handle = Some(try!(ops::http_handle(self.config)));
+ self.handle = Some(ops::http_handle(self.config)?);
self.handle.as_mut().unwrap()
}
};
// TODO: don't download into memory, but ensure that if we ctrl-c a
// download we should resume either from the start or the middle
// on the next time
- try!(handle.get(true));
- try!(handle.url(&url.to_string()));
- try!(handle.follow_location(true));
+ handle.get(true)?;
+ handle.url(&url.to_string())?;
+ handle.follow_location(true)?;
let mut state = Sha256::new();
let mut body = Vec::new();
{
let mut handle = handle.transfer();
- try!(handle.write_function(|buf| {
+ handle.write_function(|buf| {
state.update(buf);
body.extend_from_slice(buf);
Ok(buf.len())
- }));
- try!(network::with_retry(self.config, || {
+ })?;
+ network::with_retry(self.config, || {
handle.perform()
- }))
+ })?
}
- let code = try!(handle.response_code());
+ let code = handle.response_code()?;
if code != 200 && code != 0 {
bail!("failed to get 200 response from `{}`, got {}", url, code)
}
bail!("failed to verify the checksum of `{}`", pkg)
}
- try!(dst.write_all(&body));
- try!(dst.seek(SeekFrom::Start(0)));
+ dst.write_all(&body)?;
+ dst.seek(SeekFrom::Start(0))?;
Ok(dst)
}
}
impl<'cfg> Registry for ReplacedSource<'cfg> {
fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
let dep = dep.clone().map_source(&self.to_replace, &self.replace_with);
- let ret = try!(self.inner.query(&dep).chain_error(|| {
+ let ret = self.inner.query(&dep).chain_error(|| {
human(format!("failed to query replaced source `{}`",
self.to_replace))
- }));
+ })?;
Ok(ret.into_iter().map(|summary| {
summary.map_source(&self.replace_with, &self.to_replace)
}).collect())
fn download(&mut self, id: &PackageId) -> CargoResult<Package> {
let id = id.with_source_id(&self.replace_with);
- let pkg = try!(self.inner.download(&id).chain_error(|| {
+ let pkg = self.inner.download(&id).chain_error(|| {
human(format!("failed to download replaced source `{}`",
self.to_replace))
- }));
+ })?;
Ok(pkg.map_source(&self.replace_with, &self.to_replace))
}
fn from_str(s: &str) -> CargoResult<Cfg> {
let mut p = Parser::new(s);
- let e = try!(p.cfg());
+ let e = p.cfg()?;
if p.t.next().is_some() {
bail!("malformed cfg value or key/value pair")
}
fn from_str(s: &str) -> CargoResult<CfgExpr> {
let mut p = Parser::new(s);
- let e = try!(p.expr());
+ let e = p.expr()?;
if p.t.next().is_some() {
bail!("can only have one cfg-expression, consider using all() or \
any() explicitly")
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (i, v) in self.0.iter().enumerate() {
if i > 0 {
- try!(write!(f, ", "));
+ write!(f, ", ")?;
}
- try!(write!(f, "{}", v));
+ write!(f, "{}", v)?;
}
Ok(())
}
Some(&Ok(Token::Ident(op @ "any"))) => {
self.t.next();
let mut e = Vec::new();
- try!(self.eat(Token::LeftParen));
+ self.eat(Token::LeftParen)?;
while !self.try(Token::RightParen) {
- e.push(try!(self.expr()));
+ e.push(self.expr()?);
if !self.try(Token::Comma) {
- try!(self.eat(Token::RightParen));
+ self.eat(Token::RightParen)?;
break
}
}
}
Some(&Ok(Token::Ident("not"))) => {
self.t.next();
- try!(self.eat(Token::LeftParen));
- let e = try!(self.expr());
- try!(self.eat(Token::RightParen));
+ self.eat(Token::LeftParen)?;
+ let e = self.expr()?;
+ self.eat(Token::RightParen)?;
Ok(CfgExpr::Not(Box::new(e)))
}
Some(&Ok(..)) => self.cfg().map(CfgExpr::Value),
pub fn default() -> CargoResult<Config> {
let shell = ::shell(Verbosity::Verbose, ColorConfig::Auto);
- let cwd = try!(env::current_dir().chain_error(|| {
+ let cwd = env::current_dir().chain_error(|| {
human("couldn't get the current directory of the process")
- }));
- let homedir = try!(homedir(&cwd).chain_error(|| {
+ })?;
+ let homedir = homedir(&cwd).chain_error(|| {
human("Cargo couldn't find your home directory. \
This probably means that $HOME was not set.")
- }));
+ })?;
Ok(Config::new(shell, cwd, homedir))
}
}
pub fn rustc(&self) -> CargoResult<&Rustc> {
- self.rustc.get_or_try_init(|| Rustc::new(try!(self.get_tool("rustc"))))
+ self.rustc.get_or_try_init(|| Rustc::new(self.get_tool("rustc")?))
}
pub fn values(&self) -> CargoResult<&HashMap<String, ConfigValue>> {
pub fn target_dir(&self) -> CargoResult<Option<Filesystem>> {
if let Some(dir) = env::var_os("CARGO_TARGET_DIR") {
Ok(Some(Filesystem::new(self.cwd.join(dir))))
- } else if let Some(val) = try!(self.get_path("build.target-dir")) {
+ } else if let Some(val) = self.get_path("build.target-dir")? {
let val = self.cwd.join(val.val);
Ok(Some(Filesystem::new(val)))
} else {
}
fn get(&self, key: &str) -> CargoResult<Option<ConfigValue>> {
- let vals = try!(self.values());
+ let vals = self.values()?;
let mut parts = key.split('.').enumerate();
let mut val = match vals.get(parts.next().unwrap().1) {
Some(val) => val,
match env::var(&format!("CARGO_{}", key)) {
Ok(value) => {
Ok(Some(Value {
- val: try!(value.parse()),
+ val: value.parse()?,
definition: Definition::Environment,
}))
}
}
pub fn get_string(&self, key: &str) -> CargoResult<Option<Value<String>>> {
- if let Some(v) = try!(self.get_env(key)) {
+ if let Some(v) = self.get_env(key)? {
return Ok(Some(v))
}
- match try!(self.get(key)) {
+ match self.get(key)? {
Some(CV::String(i, path)) => {
Ok(Some(Value {
val: i,
}
pub fn get_bool(&self, key: &str) -> CargoResult<Option<Value<bool>>> {
- if let Some(v) = try!(self.get_env(key)) {
+ if let Some(v) = self.get_env(key)? {
return Ok(Some(v))
}
- match try!(self.get(key)) {
+ match self.get(key)? {
Some(CV::Boolean(b, path)) => {
Ok(Some(Value {
val: b,
}
pub fn get_path(&self, key: &str) -> CargoResult<Option<Value<PathBuf>>> {
- if let Some(val) = try!(self.get_string(&key)) {
+ if let Some(val) = self.get_string(&key)? {
let is_path = val.val.contains('/') ||
(cfg!(windows) && val.val.contains('\\'));
let path = if is_path {
pub fn get_list(&self, key: &str)
-> CargoResult<Option<Value<Vec<(String, PathBuf)>>>> {
- match try!(self.get(key)) {
+ match self.get(key)? {
Some(CV::List(i, path)) => {
Ok(Some(Value {
val: i,
pub fn get_table(&self, key: &str)
-> CargoResult<Option<Value<HashMap<String, CV>>>> {
- match try!(self.get(key)) {
+ match self.get(key)? {
Some(CV::Table(i, path)) => {
Ok(Some(Value {
val: i,
}
pub fn get_i64(&self, key: &str) -> CargoResult<Option<Value<i64>>> {
- if let Some(v) = try!(self.get_env(key)) {
+ if let Some(v) = self.get_env(key)? {
return Ok(Some(v))
}
- match try!(self.get(key)) {
+ match self.get(key)? {
Some(CV::Integer(i, path)) => {
Ok(Some(Value {
val: i,
}
pub fn net_retry(&self) -> CargoResult<i64> {
- match try!(self.get_i64("net.retry")) {
+ match self.get_i64("net.retry")? {
Some(v) => {
let value = v.val;
if value < 0 {
};
self.shell().set_verbosity(verbosity);
- try!(self.shell().set_color_config(color.map(|s| &s[..])));
+ self.shell().set_color_config(color.map(|s| &s[..]))?;
self.extra_verbose.set(extra_verbose);
self.frozen.set(frozen);
self.locked.set(locked);
fn load_values(&self) -> CargoResult<HashMap<String, ConfigValue>> {
let mut cfg = CV::Table(HashMap::new(), PathBuf::from("."));
- try!(walk_tree(&self.cwd, |mut file, path| {
+ walk_tree(&self.cwd, |mut file, path| {
let mut contents = String::new();
- try!(file.read_to_string(&mut contents));
- let table = try!(cargo_toml::parse(&contents,
+ file.read_to_string(&mut contents)?;
+ let table = cargo_toml::parse(&contents,
&path,
self).chain_error(|| {
human(format!("could not parse TOML configuration in `{}`",
path.display()))
- }));
+ })?;
let toml = toml::Value::Table(table);
- let value = try!(CV::from_toml(&path, toml).chain_error(|| {
+ let value = CV::from_toml(&path, toml).chain_error(|| {
human(format!("failed to load TOML configuration from `{}`",
path.display()))
- }));
- try!(cfg.merge(value));
+ })?;
+ cfg.merge(value)?;
Ok(())
- }).chain_error(|| human("Couldn't load Cargo configuration")));
+ }).chain_error(|| human("Couldn't load Cargo configuration"))?;
match cfg {
}
let var = format!("build.{}", tool);
- if let Some(tool_path) = try!(self.get_path(&var)) {
+ if let Some(tool_path) = self.get_path(&var)? {
return Ok(tool_path.val);
}
CV::String(ref s, ref path) => write!(f, "{} (from {})", s,
path.display()),
CV::List(ref list, ref path) => {
- try!(write!(f, "["));
+ write!(f, "[")?;
for (i, &(ref s, ref path)) in list.iter().enumerate() {
- if i > 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{} (from {})", s, path.display()));
+ if i > 0 { write!(f, ", ")?; }
+ write!(f, "{} (from {})", s, path.display())?;
}
write!(f, "] (from {})", path.display())
}
toml::Value::Boolean(b) => Ok(CV::Boolean(b, path.to_path_buf())),
toml::Value::Integer(i) => Ok(CV::Integer(i, path.to_path_buf())),
toml::Value::Array(val) => {
- Ok(CV::List(try!(val.into_iter().map(|toml| {
+ Ok(CV::List(val.into_iter().map(|toml| {
match toml {
toml::Value::String(val) => Ok((val, path.to_path_buf())),
v => Err(human(format!("expected string but found {} \
in list", v.type_str()))),
}
- }).collect::<CargoResult<_>>()), path.to_path_buf()))
+ }).collect::<CargoResult<_>>()?, path.to_path_buf()))
}
toml::Value::Table(val) => {
- Ok(CV::Table(try!(val.into_iter().map(|(key, value)| {
- let value = try!(CV::from_toml(path, value).chain_error(|| {
+ Ok(CV::Table(val.into_iter().map(|(key, value)| {
+ let value = CV::from_toml(path, value).chain_error(|| {
human(format!("failed to parse key `{}`", key))
- }));
+ })?;
Ok((key, value))
- }).collect::<CargoResult<_>>()), path.to_path_buf()))
+ }).collect::<CargoResult<_>>()?, path.to_path_buf()))
}
v => bail!("found TOML configuration value of unknown type `{}`",
v.type_str()),
Occupied(mut entry) => {
let path = value.definition_path().to_path_buf();
let entry = entry.get_mut();
- try!(entry.merge(value).chain_error(|| {
+ entry.merge(value).chain_error(|| {
human(format!("failed to merge key `{}` between \
files:\n \
file 1: {}\n \
entry.definition_path().display(),
path.display()))
- }));
+ })?;
}
Vacant(entry) => { entry.insert(value); }
};
loop {
let possible = current.join(".cargo").join("config");
if fs::metadata(&possible).is_ok() {
- let file = try!(File::open(&possible));
+ let file = File::open(&possible)?;
- try!(walk(file, &possible));
+ walk(file, &possible)?;
stash.insert(possible);
}
// Once we're done, also be sure to walk the home directory even if it's not
// in our history to be sure we pick up that standard location for
// information.
- let home = try!(homedir(pwd).chain_error(|| {
+ let home = homedir(pwd).chain_error(|| {
human("Cargo couldn't find your home directory. \
This probably means that $HOME was not set.")
- }));
+ })?;
let config = home.join("config");
if !stash.contains(&config) && fs::metadata(&config).is_ok() {
- let file = try!(File::open(&config));
- try!(walk(file, &config));
+ let file = File::open(&config)?;
+ walk(file, &config)?;
}
Ok(())
// 3. This blows away the previous ordering of a file.
let mut file = match loc {
Location::Global => {
- try!(cfg.home_path.create_dir());
- try!(cfg.home_path.open_rw(Path::new("config"), cfg,
- "the global config file"))
+ cfg.home_path.create_dir()?;
+ cfg.home_path.open_rw(Path::new("config"), cfg,
+ "the global config file")?
}
Location::Project => unimplemented!(),
};
let mut contents = String::new();
let _ = file.read_to_string(&mut contents);
- let mut toml = try!(cargo_toml::parse(&contents, file.path(), cfg));
+ let mut toml = cargo_toml::parse(&contents, file.path(), cfg)?;
toml.insert(key.to_string(), value.into_toml());
let contents = toml::Value::Table(toml).to_string();
- try!(file.seek(SeekFrom::Start(0)));
- try!(file.write_all(contents.as_bytes()));
- try!(file.file().set_len(contents.len() as u64));
+ file.seek(SeekFrom::Start(0))?;
+ file.write_all(contents.as_bytes())?;
+ file.file().set_len(contents.len() as u64)?;
Ok(())
}
impl fmt::Display for ConcreteCargoError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{}", self.description));
+ write!(f, "{}", self.description)?;
if let Some(ref s) = self.detail {
- try!(write!(f, " ({})", s));
+ write!(f, " ({})", s)?;
}
Ok(())
}
/// needs to be cleared out as it may be corrupt.
pub fn remove_siblings(&self) -> io::Result<()> {
let path = self.path();
- for entry in try!(path.parent().unwrap().read_dir()) {
- let entry = try!(entry);
+ for entry in path.parent().unwrap().read_dir()? {
+ let entry = entry?;
if Some(&entry.file_name()[..]) == path.file_name() {
continue
}
- let kind = try!(entry.file_type());
+ let kind = entry.file_type()?;
if kind.is_dir() {
- try!(fs::remove_dir_all(entry.path()));
+ fs::remove_dir_all(entry.path())?;
} else {
- try!(fs::remove_file(entry.path()));
+ fs::remove_file(entry.path())?;
}
}
Ok(())
// If we want an exclusive lock then if we fail because of NotFound it's
// likely because an intermediate directory didn't exist, so try to
// create the directory and then continue.
- let f = try!(opts.open(&path).or_else(|e| {
+ let f = opts.open(&path).or_else(|e| {
if e.kind() == io::ErrorKind::NotFound && state == State::Exclusive {
- try!(create_dir_all(path.parent().unwrap()));
+ create_dir_all(path.parent().unwrap())?;
opts.open(&path)
} else {
Err(e)
}
}).chain_error(|| {
human(format!("failed to open: {}", path.display()))
- }));
+ })?;
match state {
State::Exclusive => {
- try!(acquire(config, msg, &path,
+ acquire(config, msg, &path,
&|| f.try_lock_exclusive(),
- &|| f.lock_exclusive()));
+ &|| f.lock_exclusive())?;
}
State::Shared => {
- try!(acquire(config, msg, &path,
+ acquire(config, msg, &path,
&|| f.try_lock_shared(),
- &|| f.lock_shared()));
+ &|| f.lock_shared())?;
}
State::Unlocked => {}
}
}
let msg = format!("waiting for file lock on {}", msg);
- try!(config.shell().err().say_status("Blocking", &msg, CYAN, true));
+ config.shell().err().say_status("Blocking", &msg, CYAN, true)?;
return block().chain_error(|| {
human(format!("failed to lock file: {}", path.display()))
impl<N: fmt::Display + Eq + Hash> fmt::Debug for Graph<N> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- try!(writeln!(fmt, "Graph {{"));
+ writeln!(fmt, "Graph {{")?;
for (n, e) in self.nodes.iter() {
- try!(writeln!(fmt, " - {}", n));
+ writeln!(fmt, " - {}", n)?;
for n in e.iter() {
- try!(writeln!(fmt, " - {}", n));
+ writeln!(fmt, " - {}", n)?;
}
}
- try!(write!(fmt, "}}"));
+ write!(fmt, "}}")?;
Ok(())
}
where F: FnOnce() -> Result<T, Error>
{
if self.borrow().is_none() {
- if let Err(_) = self.fill(try!(init())) {
+ if let Err(_) = self.fill(init()?) {
unreachable!();
}
}
where F: FnMut() -> Result<T, E>,
E: errors::NetworkError
{
- let mut remaining = try!(config.net_retry());
+ let mut remaining = config.net_retry()?;
loop {
match callback() {
Ok(ret) => return Ok(ret),
Err(ref e) if e.maybe_spurious() && remaining > 0 => {
let msg = format!("spurious network error ({} tries \
remaining): {}", remaining, e);
- try!(config.shell().warn(msg));
+ config.shell().warn(msg)?;
remaining -= 1;
}
Err(e) => return Err(Box::new(e)),
pub fn read(path: &Path) -> CargoResult<String> {
(|| -> CargoResult<_> {
let mut ret = String::new();
- let mut f = try!(File::open(path));
- try!(f.read_to_string(&mut ret));
+ let mut f = File::open(path)?;
+ f.read_to_string(&mut ret)?;
Ok(ret)
})().map_err(human).chain_error(|| {
human(format!("failed to read `{}`", path.display()))
pub fn read_bytes(path: &Path) -> CargoResult<Vec<u8>> {
(|| -> CargoResult<_> {
let mut ret = Vec::new();
- let mut f = try!(File::open(path));
- try!(f.read_to_end(&mut ret));
+ let mut f = File::open(path)?;
+ f.read_to_end(&mut ret)?;
Ok(ret)
})().map_err(human).chain_error(|| {
human(format!("failed to read `{}`", path.display()))
pub fn write(path: &Path, contents: &[u8]) -> CargoResult<()> {
(|| -> CargoResult<()> {
- let mut f = try!(File::create(path));
- try!(f.write_all(contents));
+ let mut f = File::create(path)?;
+ f.write_all(contents)?;
Ok(())
})().map_err(human).chain_error(|| {
human(format!("failed to write `{}`", path.display()))
pub fn append(path: &Path, contents: &[u8]) -> CargoResult<()> {
(|| -> CargoResult<()> {
- let mut f = try!(OpenOptions::new()
+ let mut f = OpenOptions::new()
.write(true)
.append(true)
.create(true)
- .open(path));
+ .open(path)?;
- try!(f.write_all(contents));
+ f.write_all(contents)?;
Ok(())
}).chain_error(|| {
internal(format!("failed to write `{}`", path.display()))
impl fmt::Display for ProcessBuilder {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "`{}", self.program.to_string_lossy()));
+ write!(f, "`{}", self.program.to_string_lossy())?;
for arg in self.args.iter() {
- try!(write!(f, " {}", escape(arg.to_string_lossy())));
+ write!(f, " {}", escape(arg.to_string_lossy()))?;
}
write!(f, "`")
pub fn exec(&self) -> Result<(), ProcessError> {
let mut command = self.build_command();
- let exit = try!(command.status().map_err(|e| {
+ let exit = command.status().map_err(|e| {
process_error(&format!("could not execute process `{}`",
self.debug_string()),
Some(Box::new(e)), None, None)
- }));
+ })?;
if exit.success() {
Ok(())
pub fn exec_with_output(&self) -> Result<Output, ProcessError> {
let mut command = self.build_command();
- let output = try!(command.output().map_err(|e| {
+ let output = command.output().map_err(|e| {
process_error(&format!("could not execute process `{}`",
self.debug_string()),
Some(Box::new(e)), None, None)
- }));
+ })?;
if output.status.success() {
Ok(output)
.stdin(Stdio::null());
let mut callback_error = None;
- let status = try!((|| {
- let mut child = try!(cmd.spawn());
+ let status = (|| {
+ let mut child = cmd.spawn()?;
let out = child.stdout.take().unwrap();
let err = child.stderr.take().unwrap();
- try!(read2(out, err, &mut |is_out, data, eof| {
+ read2(out, err, &mut |is_out, data, eof| {
let idx = if eof {
data.len()
} else {
callback_error = Some(e);
}
}
- }));
+ })?;
child.wait()
})().map_err(|e| {
process_error(&format!("could not execute process `{}`",
self.debug_string()),
Some(Box::new(e)), None, None)
- }));
+ })?;
let output = Output {
stdout: stdout,
stderr: stderr,
}
}
};
- if !out_done && try!(handle(out_pipe.read_to_end(&mut out))) {
+ if !out_done && handle(out_pipe.read_to_end(&mut out))? {
out_done = true;
}
data(true, &mut out, out_done);
- if !err_done && try!(handle(err_pipe.read_to_end(&mut err))) {
+ if !err_done && handle(err_pipe.read_to_end(&mut err))? {
err_done = true;
}
data(false, &mut err, err_done);
let mut out = Vec::new();
let mut err = Vec::new();
- let port = try!(CompletionPort::new(1));
- try!(port.add_handle(0, &out_pipe));
- try!(port.add_handle(1, &err_pipe));
+ let port = CompletionPort::new(1)?;
+ port.add_handle(0, &out_pipe)?;
+ port.add_handle(1, &err_pipe)?;
unsafe {
let mut out_pipe = Pipe::new(out_pipe, &mut out);
let mut err_pipe = Pipe::new(err_pipe, &mut err);
- try!(out_pipe.read());
- try!(err_pipe.read());
+ out_pipe.read()?;
+ err_pipe.read()?;
let mut status = [CompletionStatus::zero(), CompletionStatus::zero()];
while !out_pipe.done || !err_pipe.done {
- for status in try!(port.get_many(&mut status, None)) {
+ for status in port.get_many(&mut status, None)? {
if status.token() == 0 {
out_pipe.complete(status);
data(true, out_pipe.dst, out_pipe.done);
- try!(out_pipe.read());
+ out_pipe.read()?;
} else {
err_pipe.complete(status);
data(false, err_pipe.dst, err_pipe.done);
- try!(err_pipe.read());
+ err_pipe.read()?;
}
}
}
let (cap_lints, output) = match first.exec_with_output() {
Ok(output) => (true, output),
- Err(..) => (false, try!(cmd.exec_with_output())),
+ Err(..) => (false, cmd.exec_with_output()?),
};
- let verbose_version = try!(String::from_utf8(output.stdout).map_err(|_| {
+ let verbose_version = String::from_utf8(output.stdout).map_err(|_| {
internal("rustc -v didn't return utf8 output")
- }));
+ })?;
let host = {
let triple = verbose_version.lines().find(|l| {
l.starts_with("host: ")
}).map(|l| &l[6..]);
- let triple = try!(triple.chain_error(|| {
+ let triple = triple.chain_error(|| {
internal("rustc -v didn't have a line for `host:`")
- }));
+ })?;
triple.to_string()
};
Some(path) => path.to_path_buf(),
None => manifest.clone(),
};
- let root = try!(parse(contents, &manifest, config));
+ let root = parse(contents, &manifest, config)?;
let mut d = toml::Decoder::new(toml::Value::Table(root));
- let manifest: TomlManifest = try!(Decodable::decode(&mut d).map_err(|e| {
+ let manifest: TomlManifest = Decodable::decode(&mut d).map_err(|e| {
human(e.to_string())
- }));
+ })?;
return match manifest.to_real_manifest(source_id, &layout, config) {
Ok((mut manifest, paths)) => {
invalid), but this file has a table header which does not have a newline after
it. A newline needs to be added and this warning will soon become a hard error
in the future.", file.display());
- try!(config.shell().warn(&msg));
+ config.shell().warn(&msg)?;
return Ok(toml)
}
impl Decodable for TomlVersion {
fn decode<D: Decoder>(d: &mut D) -> Result<TomlVersion, D::Error> {
- let s = try!(d.read_str());
+ let s = d.read_str()?;
match s.to_semver() {
Ok(s) => Ok(TomlVersion { version: s }),
Err(e) => Err(d.error(&e)),
let mut warnings = vec![];
let project = self.project.as_ref().or_else(|| self.package.as_ref());
- let project = try!(project.chain_error(|| {
+ let project = project.chain_error(|| {
human("no `package` or `project` section found.")
- }));
+ })?;
if project.name.trim().is_empty() {
bail!("package name cannot be an empty string.")
}
- let pkgid = try!(project.to_package_id(source_id));
+ let pkgid = project.to_package_id(source_id)?;
let metadata = pkgid.generate_metadata();
// If we have no lib at all, use the inferred lib if available
let lib = match self.lib {
Some(ref lib) => {
- try!(lib.validate_library_name());
- try!(lib.validate_crate_type());
+ lib.validate_library_name()?;
+ lib.validate_crate_type()?;
Some(
TomlTarget {
name: lib.name.clone().or(Some(project.name.clone())),
let bin = layout.main();
for target in bins {
- try!(target.validate_binary_name());
+ target.validate_binary_name()?;
}
bins.iter().map(|t| {
let examples = match self.example {
Some(ref examples) => {
for target in examples {
- try!(target.validate_example_name());
+ target.validate_example_name()?;
}
examples.clone()
}
let tests = match self.test {
Some(ref tests) => {
for target in tests {
- try!(target.validate_test_name());
+ target.validate_test_name()?;
}
tests.clone()
}
let benches = match self.bench {
Some(ref benches) => {
for target in benches {
- try!(target.validate_bench_name());
+ target.validate_bench_name()?;
}
benches.clone()
}
None => return Ok(())
};
for (n, v) in dependencies.iter() {
- let dep = try!(v.to_dependency(n, cx, kind));
+ let dep = v.to_dependency(n, cx, kind)?;
cx.deps.push(dep);
}
}
// Collect the deps
- try!(process_dependencies(&mut cx, self.dependencies.as_ref(),
- None));
- try!(process_dependencies(&mut cx, self.dev_dependencies.as_ref(),
- Some(Kind::Development)));
- try!(process_dependencies(&mut cx, self.build_dependencies.as_ref(),
- Some(Kind::Build)));
+ process_dependencies(&mut cx, self.dependencies.as_ref(),
+ None)?;
+ process_dependencies(&mut cx, self.dev_dependencies.as_ref(),
+ Some(Kind::Development))?;
+ process_dependencies(&mut cx, self.build_dependencies.as_ref(),
+ Some(Kind::Build))?;
for (name, platform) in self.target.iter().flat_map(|t| t) {
- cx.platform = Some(try!(name.parse()));
- try!(process_dependencies(&mut cx,
+ cx.platform = Some(name.parse()?);
+ process_dependencies(&mut cx,
platform.dependencies.as_ref(),
- None));
- try!(process_dependencies(&mut cx,
+ None)?;
+ process_dependencies(&mut cx,
platform.build_dependencies.as_ref(),
- Some(Kind::Build)));
- try!(process_dependencies(&mut cx,
+ Some(Kind::Build))?;
+ process_dependencies(&mut cx,
platform.dev_dependencies.as_ref(),
- Some(Kind::Development)));
+ Some(Kind::Development))?;
}
- replace = try!(self.replace(&mut cx));
+ replace = self.replace(&mut cx)?;
}
{
let exclude = project.exclude.clone().unwrap_or(Vec::new());
let include = project.include.clone().unwrap_or(Vec::new());
- let summary = try!(Summary::new(pkgid, deps,
+ let summary = Summary::new(pkgid, deps,
self.features.clone()
- .unwrap_or(HashMap::new())));
+ .unwrap_or(HashMap::new()))?;
let metadata = ManifestMetadata {
description: project.description.clone(),
homepage: project.homepage.clone(),
let mut nested_paths = Vec::new();
let mut warnings = Vec::new();
let mut deps = Vec::new();
- let replace = try!(self.replace(&mut Context {
+ let replace = self.replace(&mut Context {
pkgid: None,
deps: &mut deps,
source_id: source_id,
warnings: &mut warnings,
platform: None,
layout: layout,
- }));
+ })?;
let profiles = build_profiles(&self.profile);
let workspace_config = match self.workspace {
Some(ref config) => {
-> CargoResult<Vec<(PackageIdSpec, Dependency)>> {
let mut replace = Vec::new();
for (spec, replacement) in self.replace.iter().flat_map(|x| x) {
- let mut spec = try!(PackageIdSpec::parse(spec).chain_error(|| {
+ let mut spec = PackageIdSpec::parse(spec).chain_error(|| {
human(format!("replacements must specify a valid semver \
version to replace, but `{}` does not",
spec))
- }));
+ })?;
if spec.url().is_none() {
spec.set_url(CRATES_IO.parse().unwrap());
}
requirement, but found one for `{}`", spec);
}
- let dep = try!(replacement.to_dependency(spec.name(), cx, None));
+ let dep = replacement.to_dependency(spec.name(), cx, None)?;
let dep = {
- let version = try!(spec.version().chain_error(|| {
+ let version = spec.version().chain_error(|| {
human(format!("replacements must specify a version \
to replace, but `{}` does not",
spec))
- }));
+ })?;
let req = VersionReq::exact(version);
dep.clone_inner().set_version_req(req)
.into_dependency()
.or_else(|| details.tag.clone().map(GitReference::Tag))
.or_else(|| details.rev.clone().map(GitReference::Rev))
.unwrap_or_else(|| GitReference::Branch("master".to_string()));
- let loc = try!(git.to_url());
+ let loc = git.to_url()?;
SourceId::for_git(&loc, reference)
},
(None, Some(path)) => {
if cx.source_id.is_path() {
let path = cx.layout.root.join(path);
let path = util::normalize_path(&path);
- try!(SourceId::for_path(&path))
+ SourceId::for_path(&path)?
} else {
cx.source_id.clone()
}
},
- (None, None) => try!(SourceId::crates_io(cx.config)),
+ (None, None) => SourceId::crates_io(cx.config)?,
};
let version = details.version.as_ref().map(|v| &v[..]);
let mut dep = match cx.pkgid {
Some(id) => {
- try!(DependencyInner::parse(name, version, &new_source_id,
- Some((id, cx.config))))
+ DependencyInner::parse(name, version, &new_source_id,
+ Some((id, cx.config)))?
}
- None => try!(DependencyInner::parse(name, version, &new_source_id, None)),
+ None => DependencyInner::parse(name, version, &new_source_id, None)?,
};
dep = dep.set_features(details.features.unwrap_or(Vec::new()))
.set_default_features(details.default_features.unwrap_or(true))
impl GitRepo {
pub fn init(path: &Path, _: &Path) -> CargoResult<GitRepo> {
- try!(git2::Repository::init(path));
+ git2::Repository::init(path)?;
Ok(GitRepo)
}
pub fn discover(path: &Path, _: &Path) -> Result<git2::Repository,git2::Error> {
impl HgRepo {
pub fn init(path: &Path, cwd: &Path) -> CargoResult<HgRepo> {
- try!(process("hg").cwd(cwd).arg("init").arg(path).exec());
+ process("hg").cwd(cwd).arg("init").arg(path).exec()?;
Ok(HgRepo)
}
pub fn discover(path: &Path, cwd: &Path) -> CargoResult<HgRepo> {
- try!(process("hg").cwd(cwd).arg("root").cwd(path).exec_with_output());
+ process("hg").cwd(cwd).arg("root").cwd(path).exec_with_output()?;
Ok(HgRepo)
}
}
}
pub fn add_owners(&mut self, krate: &str, owners: &[&str]) -> Result<()> {
- let body = try!(json::encode(&OwnersReq { users: owners }));
- let body = try!(self.put(format!("/crates/{}/owners", krate),
- body.as_bytes()));
- assert!(try!(json::decode::<R>(&body)).ok);
+ let body = json::encode(&OwnersReq { users: owners })?;
+ let body = self.put(format!("/crates/{}/owners", krate),
+ body.as_bytes())?;
+ assert!(json::decode::<R>(&body)?.ok);
Ok(())
}
pub fn remove_owners(&mut self, krate: &str, owners: &[&str]) -> Result<()> {
- let body = try!(json::encode(&OwnersReq { users: owners }));
- let body = try!(self.delete(format!("/crates/{}/owners", krate),
- Some(body.as_bytes())));
- assert!(try!(json::decode::<R>(&body)).ok);
+ let body = json::encode(&OwnersReq { users: owners })?;
+ let body = self.delete(format!("/crates/{}/owners", krate),
+ Some(body.as_bytes()))?;
+ assert!(json::decode::<R>(&body)?.ok);
Ok(())
}
pub fn list_owners(&mut self, krate: &str) -> Result<Vec<User>> {
- let body = try!(self.get(format!("/crates/{}/owners", krate)));
- Ok(try!(json::decode::<Users>(&body)).users)
+ let body = self.get(format!("/crates/{}/owners", krate))?;
+ Ok(json::decode::<Users>(&body)?.users)
}
pub fn publish(&mut self, krate: &NewCrate, tarball: &File) -> Result<()> {
- let json = try!(json::encode(krate));
+ let json = json::encode(krate)?;
// Prepare the body. The format of the upload request is:
//
// <le u32 of json>
// <json request> (metadata for the package)
// <le u32 of tarball>
// <source tarball>
- let stat = try!(tarball.metadata().map_err(Error::Io));
+ let stat = tarball.metadata().map_err(Error::Io)?;
let header = {
let mut w = Vec::new();
w.extend([
Some(s) => s,
None => return Err(Error::TokenMissing),
};
- try!(self.handle.put(true));
- try!(self.handle.url(&url));
- try!(self.handle.in_filesize(size as u64));
+ self.handle.put(true)?;
+ self.handle.url(&url)?;
+ self.handle.in_filesize(size as u64)?;
let mut headers = List::new();
- try!(headers.append("Accept: application/json"));
- try!(headers.append(&format!("Authorization: {}", token)));
- try!(self.handle.http_headers(headers));
+ headers.append("Accept: application/json")?;
+ headers.append(&format!("Authorization: {}", token))?;
+ self.handle.http_headers(headers)?;
- let _body = try!(handle(&mut self.handle, &mut |buf| {
+ let _body = handle(&mut self.handle, &mut |buf| {
body.read(buf).unwrap_or(0)
- }));
+ })?;
Ok(())
}
pub fn search(&mut self, query: &str, limit: u8) -> Result<(Vec<Crate>, u32)> {
let formated_query = percent_encode(query.as_bytes(), QUERY_ENCODE_SET);
- let body = try!(self.req(
+ let body = self.req(
format!("/crates?q={}&per_page={}", formated_query, limit),
None, Auth::Unauthorized
- ));
+ )?;
- let crates = try!(json::decode::<Crates>(&body));
+ let crates = json::decode::<Crates>(&body)?;
Ok((crates.crates, crates.meta.total))
}
pub fn yank(&mut self, krate: &str, version: &str) -> Result<()> {
- let body = try!(self.delete(format!("/crates/{}/{}/yank", krate, version),
- None));
- assert!(try!(json::decode::<R>(&body)).ok);
+ let body = self.delete(format!("/crates/{}/{}/yank", krate, version),
+ None)?;
+ assert!(json::decode::<R>(&body)?.ok);
Ok(())
}
pub fn unyank(&mut self, krate: &str, version: &str) -> Result<()> {
- let body = try!(self.put(format!("/crates/{}/{}/unyank", krate, version),
- &[]));
- assert!(try!(json::decode::<R>(&body)).ok);
+ let body = self.put(format!("/crates/{}/{}/unyank", krate, version),
+ &[])?;
+ assert!(json::decode::<R>(&body)?.ok);
Ok(())
}
fn put(&mut self, path: String, b: &[u8]) -> Result<String> {
- try!(self.handle.put(true));
+ self.handle.put(true)?;
self.req(path, Some(b), Auth::Authorized)
}
fn get(&mut self, path: String) -> Result<String> {
- try!(self.handle.get(true));
+ self.handle.get(true)?;
self.req(path, None, Auth::Authorized)
}
fn delete(&mut self, path: String, b: Option<&[u8]>) -> Result<String> {
- try!(self.handle.custom_request("DELETE"));
+ self.handle.custom_request("DELETE")?;
self.req(path, b, Auth::Authorized)
}
path: String,
body: Option<&[u8]>,
authorized: Auth) -> Result<String> {
- try!(self.handle.url(&format!("{}/api/v1{}", self.host, path)));
+ self.handle.url(&format!("{}/api/v1{}", self.host, path))?;
let mut headers = List::new();
- try!(headers.append("Accept: application/json"));
- try!(headers.append("Content-Type: application/json"));
+ headers.append("Accept: application/json")?;
+ headers.append("Content-Type: application/json")?;
if authorized == Auth::Authorized {
let token = match self.token.as_ref() {
Some(s) => s,
None => return Err(Error::TokenMissing),
};
- try!(headers.append(&format!("Authorization: {}", token)));
+ headers.append(&format!("Authorization: {}", token))?;
}
- try!(self.handle.http_headers(headers));
+ self.handle.http_headers(headers)?;
match body {
Some(mut body) => {
- try!(self.handle.upload(true));
- try!(self.handle.in_filesize(body.len() as u64));
+ self.handle.upload(true)?;
+ self.handle.in_filesize(body.len() as u64)?;
handle(&mut self.handle, &mut |buf| body.read(buf).unwrap_or(0))
}
None => handle(&mut self.handle, &mut |_| 0),
let mut body = Vec::new();
{
let mut handle = handle.transfer();
- try!(handle.read_function(|buf| Ok(read(buf))));
- try!(handle.write_function(|data| {
+ handle.read_function(|buf| Ok(read(buf)))?;
+ handle.write_function(|data| {
body.extend_from_slice(data);
Ok(data.len())
- }));
- try!(handle.header_function(|data| {
+ })?;
+ handle.header_function(|data| {
headers.push(String::from_utf8_lossy(data).into_owned());
true
- }));
- try!(handle.perform());
+ })?;
+ handle.perform()?;
}
- match try!(handle.response_code()) {
+ match handle.response_code()? {
0 => {} // file upload url sometimes
200 => {}
403 => return Err(Error::Unauthorized),
Error::NonUtf8Body => write!(f, "response body was not utf-8"),
Error::Curl(ref err) => write!(f, "http error: {}", err),
Error::NotOkResponse(code, ref headers, ref body) => {
- try!(writeln!(f, "failed to get a 200 OK response, got {}", code));
- try!(writeln!(f, "headers:"));
+ writeln!(f, "failed to get a 200 OK response, got {}", code)?;
+ writeln!(f, "headers:")?;
for header in headers {
- try!(writeln!(f, " {}", header));
+ writeln!(f, " {}", header)?;
}
- try!(writeln!(f, "body:"));
- try!(writeln!(f, "{}", String::from_utf8_lossy(body)));
+ writeln!(f, "body:")?;
+ writeln!(f, "{}", String::from_utf8_lossy(body))?;
Ok(())
}
Error::Api(ref errs) => {
}
fn match_stdout(&self, actual: &Output) -> ham::MatchResult {
- try!(self.match_std(self.expect_stdout.as_ref(), &actual.stdout,
- "stdout", &actual.stderr, false));
+ self.match_std(self.expect_stdout.as_ref(), &actual.stdout,
+ "stdout", &actual.stderr, false)?;
for expect in self.expect_stdout_contains.iter() {
- try!(self.match_std(Some(expect), &actual.stdout, "stdout",
- &actual.stderr, true));
+ self.match_std(Some(expect), &actual.stdout, "stdout",
+ &actual.stderr, true)?;
}
for expect in self.expect_stderr_contains.iter() {
- try!(self.match_std(Some(expect), &actual.stderr, "stderr",
- &actual.stdout, true));
+ self.match_std(Some(expect), &actual.stderr, "stderr",
+ &actual.stdout, true)?;
}
if let Some(ref objects) = self.expect_json {
objects.len(), lines.len()));
}
for (obj, line) in objects.iter().zip(lines) {
- try!(self.match_json(obj, line));
+ self.match_json(obj, line)?;
}
}
Ok(())
-> CargoResult<Vec<PackageId>> {
let summary = Summary::new(pkg.clone(), deps, HashMap::new()).unwrap();
let method = Method::Everything;
- Ok(try!(resolver::resolve(&[(summary, method)],
+ Ok(resolver::resolve(&[(summary, method)],
&[],
- registry)).iter().map(|p| {
+ registry)?.iter().map(|p| {
p.clone()
}).collect())
}
fn colored_output(string: &str, color: color::Color) -> CargoResult<String> {
let mut term = TerminfoTerminal::new(Vec::new()).unwrap();
- try!(term.reset());
- try!(term.fg(color));
- try!(write!(&mut term, "{}", string));
- try!(term.reset());
- try!(term.flush());
+ term.reset()?;
+ term.fg(color)?;
+ write!(&mut term, "{}", string)?;
+ term.reset()?;
+ term.flush()?;
Ok(String::from_utf8_lossy(term.get_ref()).to_string())
}
projects / cargo.git / commitdiff