From 76623a01d46e4919b3f8124e44d74faa907882d4 Mon Sep 17 00:00:00 2001 From: Yehuda Katz Date: Mon, 5 May 2014 14:33:28 -0700 Subject: [PATCH] Fix a bunch of warnings --- src/bin/cargo-compile.rs | 2 +- src/bin/cargo-read-manifest.rs | 22 ++++++++++-- src/cargo/core/source.rs | 1 - src/cargo/ops/cargo_compile.rs | 53 ++-------------------------- src/cargo/ops/cargo_read_manifest.rs | 27 ++------------ src/cargo/ops/cargo_rustc.rs | 26 ++++++++------ src/cargo/sources/path.rs | 14 ++------ 7 files changed, 44 insertions(+), 101 deletions(-) diff --git a/src/bin/cargo-compile.rs b/src/bin/cargo-compile.rs index f83993bde..12ab5107e 100644 --- a/src/bin/cargo-compile.rs +++ b/src/bin/cargo-compile.rs @@ -7,7 +7,7 @@ extern crate serialize; use cargo::ops::cargo_compile::compile; use cargo::{CargoResult,ToCargoError}; -use hammer::{FlagDecoder,FlagConfig,FlagConfiguration,HammerError}; +use hammer::{FlagDecoder,FlagConfig,HammerError}; use serialize::Decodable; #[deriving(Eq,Clone,Decodable,Encodable)] diff --git a/src/bin/cargo-read-manifest.rs b/src/bin/cargo-read-manifest.rs index 54ca728fb..5007e42e3 100644 --- a/src/bin/cargo-read-manifest.rs +++ b/src/bin/cargo-read-manifest.rs @@ -2,10 +2,28 @@ #![allow(deprecated_owned_vector)] extern crate cargo; +extern crate serialize; +extern crate hammer; -use cargo::execute_main_without_stdin; -use cargo::ops::cargo_read_manifest::execute; +use cargo::{CargoResult,execute_main_without_stdin}; +use cargo::ops::cargo_read_manifest::read_manifest; +use cargo::core::Manifest; +use hammer::FlagConfig; + +#[deriving(Decodable,Eq,Clone,Ord)] +pub struct ReadManifestFlags { + manifest_path: ~str +} + +impl FlagConfig for ReadManifestFlags {} fn main() { execute_main_without_stdin(execute); } + +fn execute(flags: ReadManifestFlags) -> CargoResult> { + match read_manifest(flags.manifest_path) { + Ok(manifest) => Ok(Some(manifest)), + Err(e) => Err(e) + } +} diff --git a/src/cargo/core/source.rs b/src/cargo/core/source.rs index 243d52dbb..78677f3ae 100644 --- a/src/cargo/core/source.rs +++ b/src/cargo/core/source.rs @@ -1,4 +1,3 @@ -use std::fmt; use core::{NameVer,Package}; use CargoResult; diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs index e90459549..9405acde3 100644 --- a/src/cargo/ops/cargo_compile.rs +++ b/src/cargo/ops/cargo_compile.rs @@ -14,29 +14,19 @@ * b. Compile each dependency in order, passing in the -L's pointing at each previously compiled dependency */ -use std; use std::vec::Vec; -use serialize::{Decodable}; -use std::io; -use std::io::BufReader; -use std::io::process::{Process,ProcessExit,ProcessOutput,InheritFd,ProcessConfig}; use std::os; use util::config; use util::config::{all_configs,ConfigValue}; -use cargo_read_manifest = ops::cargo_read_manifest::read_manifest; use core::resolver::resolve; use core::package::PackageSet; -use core::Package; use core::source::Source; use core::dependency::Dependency; use sources::path::PathSource; use ops::cargo_rustc; -use {CargoError,ToCargoError,CargoResult}; - +use {CargoError,CargoResult}; pub fn compile(manifest_path: &str) -> CargoResult<()> { - let manifest = try!(cargo_read_manifest(manifest_path)); - let configs = try!(all_configs(os::getcwd())); let config_paths = configs.find(&("paths".to_owned())).map(|v| v.clone()).unwrap_or_else(|| ConfigValue::new()); @@ -58,46 +48,7 @@ pub fn compile(manifest_path: &str) -> CargoResult<()> { let resolved = try!(resolve(deps.as_slice(), ®istry)); - cargo_rustc::compile(&resolved); + try!(cargo_rustc::compile(&resolved)); Ok(()) - //call_rustc(~BufReader::new(manifest_bytes.as_slice())) } - - -fn read_manifest(manifest_path: &str) -> CargoResult> { - Ok((try!(exec_with_output("cargo-read-manifest", ["--manifest-path".to_owned(), manifest_path.to_owned()], None))).output) -} - -fn call_rustc(mut manifest_data: ~Reader:) -> CargoResult<()> { - let data: &mut Reader = manifest_data; - try!(exec_tty("cargo-rustc", [], Some(data))); - Ok(()) -} - -fn exec_with_output(program: &str, args: &[~str], input: Option<&mut Reader>) -> CargoResult { - Ok((try!(exec(program, args, input, |_| {}))).wait_with_output()) -} - -fn exec_tty(program: &str, args: &[~str], input: Option<&mut Reader>) -> CargoResult { - Ok((try!(exec(program, args, input, |config| { - config.stdout = InheritFd(1); - config.stderr = InheritFd(2); - }))).wait()) -} - -fn exec(program: &str, args: &[~str], input: Option<&mut Reader>, configurator: |&mut ProcessConfig|) -> CargoResult { - let mut config = ProcessConfig::new(); - config.program = program; - config.args = args; - configurator(&mut config); - - println!("Executing {} {}", program, args); - - let mut process = try!(Process::configure(config).to_cargo_error(|e: io::IoError| format!("Could not configure process: {}", e), 1)); - - input.map(|mut reader| io::util::copy(&mut reader, process.stdin.get_mut_ref())); - - Ok(process) -} - diff --git a/src/cargo/ops/cargo_read_manifest.rs b/src/cargo/ops/cargo_read_manifest.rs index b2c0c60b4..0666c666b 100644 --- a/src/cargo/ops/cargo_read_manifest.rs +++ b/src/cargo/ops/cargo_read_manifest.rs @@ -1,32 +1,11 @@ use toml; -use hammer::FlagConfig; -use serialize::Decoder; use toml::from_toml; -use {CargoResult,ToCargoError,core}; use core::manifest::{SerializedManifest,Manifest}; +use {CargoResult,ToCargoError}; - -#[deriving(Decodable,Eq,Clone,Ord)] -pub struct ReadManifestFlags { - manifest_path: ~str -} - -impl FlagConfig for ReadManifestFlags {} - -pub fn read_manifest(manifest_path: &str) -> CargoResult { - match execute(ReadManifestFlags { manifest_path: manifest_path.to_owned() }) { - Ok(manifest) => Ok(manifest.unwrap()), - Err(e) => Err(e) - } -} - -pub fn execute(flags: ReadManifestFlags) -> CargoResult> { - let manifest_path = flags.manifest_path; +pub fn read_manifest(manifest_path: &str) -> CargoResult { let root = try!(toml::parse_from_file(manifest_path.clone()).to_cargo_error(format!("Couldn't parse Toml file: {}", manifest_path), 1)); - let toml_manifest = try!(from_toml::(root.clone()).to_cargo_error(|e: toml::Error| format!("Couldn't parse Toml file: {:?}", e), 1)); - Manifest::from_serialized(manifest_path.as_slice(), &toml_manifest).map(|manifest| { - Some(manifest) - }) + Manifest::from_serialized(manifest_path.as_slice(), &toml_manifest) } diff --git a/src/cargo/ops/cargo_rustc.rs b/src/cargo/ops/cargo_rustc.rs index c2c51a5e1..8216d6eb6 100644 --- a/src/cargo/ops/cargo_rustc.rs +++ b/src/cargo/ops/cargo_rustc.rs @@ -3,50 +3,56 @@ use std::os::args; use std::io; use std::io::process::{Process,ProcessConfig,InheritFd}; use std::path::Path; -use {CargoResult,CargoError,ToCargoError,NoFlags,core}; +use {CargoResult,CargoError,ToCargoError,NoFlags}; use core; use util; type Args = Vec<~str>; -pub fn compile(pkgs: &core::PackageSet) { +pub fn compile(pkgs: &core::PackageSet) -> CargoResult<()> { let sorted = match pkgs.sort() { Some(pkgs) => pkgs, - None => fail!("Could not perform topsort on PackageSet") + None => return Err(CargoError::new("Circular dependency detected".to_owned(), 1)) }; for pkg in sorted.iter() { - compile_pkg(pkg, pkgs); + try!(compile_pkg(pkg, pkgs)); } + + Ok(()) } -fn compile_pkg(pkg: &core::Package, pkgs: &core::PackageSet) { +fn compile_pkg(pkg: &core::Package, pkgs: &core::PackageSet) -> CargoResult<()> { // Build up the destination let src = pkg.get_root().join(Path::new(pkg.get_source().path.as_slice())); let target = pkg.get_root().join(Path::new(pkg.get_target())); // First ensure that the directory exists - mk_target(&target); + try!(mk_target(&target).to_cargo_error(format!("Could not create the target directory {}", target.display()), 1)); // compile - rustc(pkg.get_root(), &src, &target, deps(pkg, pkgs)); + try!(rustc(pkg.get_root(), &src, &target, deps(pkg, pkgs))); + + Ok(()) } fn mk_target(target: &Path) -> io::IoResult<()> { io::fs::mkdir_recursive(target, io::UserRWX) } -fn rustc(root: &Path, src: &Path, target: &Path, deps: &[core::Package]) { +fn rustc(root: &Path, src: &Path, target: &Path, deps: &[core::Package]) -> CargoResult<()> { let mut args = Vec::new(); build_base_args(&mut args, src, target); build_deps_args(&mut args, deps); - util::process("rustc") + try!(util::process("rustc") .cwd(root.clone()) .args(args.as_slice()) - .exec(); + .exec().to_cargo_error(format!("Couldn't execute rustc {}", args.connect(" ")), 1)); + + Ok(()) } fn build_base_args(dst: &mut Args, src: &Path, target: &Path) { diff --git a/src/cargo/sources/path.rs b/src/cargo/sources/path.rs index da2a03aa9..5f907459d 100644 --- a/src/cargo/sources/path.rs +++ b/src/cargo/sources/path.rs @@ -12,16 +12,6 @@ impl PathSource { pub fn new(paths: Vec) -> PathSource { PathSource { paths: paths } } - - fn map(&self, callback: |&Path| -> CargoResult) -> CargoResult> { - let mut ret = Vec::with_capacity(self.paths.len()); - - for path in self.paths.iter() { - ret.push(try!(callback(path))); - } - - Ok(ret) - } } impl Source for PathSource { @@ -36,11 +26,11 @@ impl Source for PathSource { }).collect()) } - fn download(&self, name_ver: &[NameVer]) -> CargoResult<()>{ + fn download(&self, _: &[NameVer]) -> CargoResult<()>{ Ok(()) } - fn get(&self, packages: &[NameVer]) -> CargoResult> { + fn get(&self, _: &[NameVer]) -> CargoResult> { Ok(self.paths.iter().filter_map(|path| { match read_manifest(path) { Ok(ref manifest) => Some(Package::from_manifest(manifest)),