From 904d8612a9060f73598a1bf85cc9b44f7bfce6da Mon Sep 17 00:00:00 2001 From: Carl Lerche Date: Mon, 10 Mar 2014 17:38:31 -0700 Subject: [PATCH] cargo-read-manifest | cargo-rustc is working At the moment, only the bare bones command is working with some defaults hardcoded. Also, there is a bunch of necessary cleanup and no tests. However, this marks the first end-to-end functionality in Cargo! --- Makefile | 4 +- commands/cargo-read-manifest/main.rs | 52 ++++++++++++++-------- commands/cargo-rustc/main.rs | 64 +++++++++++++++++++++------- 3 files changed, 85 insertions(+), 35 deletions(-) diff --git a/Makefile b/Makefile index eb6444264..68b1517c9 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,7 @@ RUSTC_TARGET = target RUSTC_FLAGS ?= --out-dir $(RUSTC_TARGET) -L $(RUSTC_TARGET)/libs TOML_LIB := $(shell rustc --crate-file-name libs/rust-toml/src/toml/lib.rs) -HAMMER_LIB := $(shell rustc --crate-file-name libs/hammer.rs/src/lib.rs) +HAMMER_LIB := $(shell rustc --crate-file-name libs/hammer.rs/src/hammer.rs) LIBCARGO_LIB := $(shell rustc --crate-file-name libcargo/cargo.rs) default: dependencies commands @@ -27,7 +27,7 @@ target/libs/$(TOML_LIB): target libs/rust-toml/src/toml/lib.rs cd libs/rust-toml && make cp libs/rust-toml/lib/*.rlib target/libs -target/libs/$(HAMMER_LIB): target libs/hammer.rs/src/lib.rs +target/libs/$(HAMMER_LIB): target libs/hammer.rs/src/hammer.rs cd libs/hammer.rs && make cp libs/hammer.rs/target/*.rlib target/libs diff --git a/commands/cargo-read-manifest/main.rs b/commands/cargo-read-manifest/main.rs index 806d76020..c4f12cdae 100644 --- a/commands/cargo-read-manifest/main.rs +++ b/commands/cargo-read-manifest/main.rs @@ -12,14 +12,24 @@ use serialize::json::Encoder; use toml::from_toml; use semver::Version; use cargo::{Manifest,LibTarget,ExecTarget,Project}; +use std::path::Path; #[deriving(Decodable,Encodable,Eq,Clone,Ord)] struct SerializedManifest { project: ~Project, - lib: Option<~[LibTarget]>, - bin: Option<~[ExecTarget]> + lib: Option<~[SerializedLibTarget]>, + bin: Option<~[SerializedExecTarget]> } +#[deriving(Decodable,Encodable,Eq,Clone,Ord)] +pub struct SerializedTarget { + name: ~str, + path: Option<~str> +} + +pub type SerializedLibTarget = SerializedTarget; +pub type SerializedExecTarget = SerializedTarget; + #[deriving(Decodable,Eq,Clone,Ord)] struct ReadManifestFlags { @@ -47,6 +57,7 @@ fn main() { let (lib, bin) = normalize(&toml_manifest.lib, &toml_manifest.bin); let manifest = Manifest{ + root: Path::new(flags.manifest_path).dirname_str().unwrap().to_owned(), project: toml_manifest.project, lib: lib, bin: bin @@ -57,34 +68,41 @@ fn main() { println!("{}", encoded); } -fn normalize(lib: &Option<~[LibTarget]>, bin: &Option<~[ExecTarget]>) -> (~[LibTarget], ~[ExecTarget]) { +fn normalize(lib: &Option<~[SerializedLibTarget]>, bin: &Option<~[SerializedExecTarget]>) -> (~[LibTarget], ~[ExecTarget]) { if lib.is_some() && bin.is_some() { - let mut l = lib.clone().unwrap()[0]; // crashes if lib = [] is provided in the Toml file - if l.path.is_none() { - l.path = Some(format!("src/{}.rs", l.name)); + let l = lib.clone().unwrap()[0]; + let mut path = l.path.clone(); + + if path.is_none() { + path = Some(format!("src/{}.rs", l.name)); } let b = bin.get_ref().map(|b_ref| { let mut b = b_ref.clone(); - if b.path.is_none() { - b.path = Some(format!("src/bin/{}.rs", b.name)); + let mut path = b.path.clone(); + if path.is_none() { + path = Some(format!("src/bin/{}.rs", b.name.clone())); } - b + ExecTarget{ path: path.unwrap(), name: b.name } }); - (~[l.clone()], b) + (~[LibTarget{ path: path.unwrap(), name: l.name }], b) } else if lib.is_some() { - let mut l = lib.clone().unwrap()[0]; // crashes if lib = [] is provided in the Toml file - if l.path.is_none() { - l.path = Some(format!("src/{}.rs", l.name)); + let l = lib.clone().unwrap()[0]; + let mut path = l.path.clone(); + + if path.is_none() { + path = Some(format!("src/{}.rs", l.name)); } - (~[l.clone()], ~[]) + + (~[LibTarget{ path: path.unwrap(), name: l.name }], ~[]) } else if bin.is_some() { let b = bin.get_ref().map(|b_ref| { let mut b = b_ref.clone(); - if b.path.is_none() { - b.path = Some(format!("src/{}.rs", b.name)); + let mut path = b.path.clone(); + if path.is_none() { + path = Some(format!("src/bin/{}.rs", b.name.clone())); } - b + ExecTarget{ path: path.unwrap(), name: b.name } }); (~[], b) } else { diff --git a/commands/cargo-rustc/main.rs b/commands/cargo-rustc/main.rs index 390a57138..5b48a9859 100644 --- a/commands/cargo-rustc/main.rs +++ b/commands/cargo-rustc/main.rs @@ -1,9 +1,16 @@ #[crate_id="cargo-rustc"]; extern crate toml; +extern crate serialize; +extern crate cargo; use std::os::args; +use std::io; use std::io::process::Process; +use serialize::json; +use serialize::{Decoder,Decodable}; +use std::path::Path; +use cargo::{Manifest,LibTarget,ExecTarget,Project}; /** cargo-rustc -- ...args @@ -12,23 +19,48 @@ use std::io::process::Process; */ fn main() { - let mut arguments = args(); - arguments.shift(); + let mut reader = io::stdin(); + let input = reader.read_to_str().unwrap(); - if arguments[0] != ~"--" { - fail!("LOL"); + let json = json::from_str(input).unwrap(); + let mut decoder = json::Decoder::new(json); + let manifest: Manifest = Decodable::decode(&mut decoder); + + //let mut arguments = args(); + //arguments.shift(); + + //if arguments[0] != ~"--" { + //fail!("LOL"); + //} else { + //arguments.shift(); + //} + + let Manifest{ root, lib, .. } = manifest; + + let root = Path::new(root); + let out_dir = lib[0].path; + let target = join(&root, ~"target"); + + let args = ~[ + join(&root, out_dir), + ~"--out-dir", target, + ~"--crate-type", ~"lib" + ]; + + io::fs::mkdir_recursive(&root.join("target"), io::UserRWX); + + println!("Executing {}", args); + + let mut p = Process::new("rustc", args).unwrap(); + let o = p.wait_with_output(); + + if o.status == std::io::process::ExitStatus(0) { + println!("output: {:s}", std::str::from_utf8(o.output).unwrap()); } else { - arguments.shift(); + fail!("Failed to execute") } - - match Process::new("rustc", arguments.as_slice()) { - Ok(mut process) => { - let stdout = process.stdout.get_mut_ref(); - println!("output: {:s}", stdout.read_to_str().unwrap()); - - let stderr = process.stderr.get_mut_ref(); - println!("err: {:s}", stderr.read_to_str().unwrap()); - }, - Err(e) => fail!("Failed to execute: {}", e) - }; +} + +fn join(path: &Path, part: ~str) -> ~str { + path.join(part).as_str().unwrap().to_owned() }