Get cargo-read-manifest working again

diff --git a/src/bin/cargo-read-manifest.rs b/src/bin/cargo-read-manifest.rs
index db3195f5639204bd571c4a31662eb45725c3aac3..2d2a36cdf6d5a574d54e338d50599f1391442c1e 100644 (file)
--- a/src/bin/cargo-read-manifest.rs
+++ b/src/bin/cargo-read-manifest.rs
@@ -5,7 +5,22 @@ extern crate cargo;
 extern crate serialize;
 extern crate hammer;
 
+use hammer::FlagConfig;
+use cargo::{execute_main_without_stdin,CLIResult};
+use cargo::core::Package;
+use cargo::ops::cargo_read_manifest::read_manifest;
+
+#[deriving(Eq,Clone,Decodable)]
+struct Options {
+    manifest_path: ~str
+}
+
+impl FlagConfig for Options {}
+
 fn main() {
-    // Standalone cargo-read-manifest will go here
-    unimplemented!();
+    execute_main_without_stdin(execute);
+}
+
+fn execute(options: Options) -> CLIResult<Option<Package>> {
+    read_manifest(options.manifest_path.as_slice()).map(|m| Some(m))
 }

diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs
index 9b86b170039a3acc8c60bed8aae2f0b55c73e4e1..1ce39784596095f80444e28df2145d0ca6c7f8e9 100644 (file)
--- a/src/cargo/core/manifest.rs
+++ b/src/cargo/core/manifest.rs
@@ -8,6 +8,7 @@ use core::{
     Summary
 };
 use core::errors::{CargoResult,CargoError,ToResult,PathError};
+use serialize::{Encoder,Encodable};
 
 // #[deriving(Decodable,Encodable,Eq,Clone)]
 #[deriving(Eq,Clone)]
@@ -24,7 +25,26 @@ impl Show for Manifest {
     }
 }
 
-#[deriving(Show,Clone,Eq)]
+#[deriving(Eq,Clone,Encodable)]
+pub struct SerializedManifest {
+    summary: Summary,
+    authors: Vec<~str>,
+    targets: Vec<Target>,
+    target_dir: ~str
+}
+
+impl<E, S: Encoder<E>> Encodable<S, E> for Manifest {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        SerializedManifest {
+            summary: self.summary.clone(),
+            authors: self.authors.clone(),
+            targets: self.targets.clone(),
+            target_dir: self.target_dir.as_str().unwrap().to_owned()
+        }.encode(s)
+    }
+}
+
+#[deriving(Show,Clone,Eq,Encodable)]
 pub enum TargetKind {
     LibTarget,
     BinTarget
@@ -37,6 +57,28 @@ pub struct Target {
     path: Path
 }
 
+#[deriving(Encodable)]
+pub struct SerializedTarget {
+    kind: &'static str,
+    name: ~str,
+    path: ~str
+}
+
+impl<E, S: Encoder<E>> Encodable<S, E> for Target {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        let kind = match self.kind {
+            LibTarget => "lib",
+            BinTarget => "bin"
+        };
+
+        SerializedTarget {
+            kind: kind,
+            name: self.name.clone(),
+            path: self.path.as_str().unwrap().to_owned()
+        }.encode(s)
+    }
+}
+
 impl Show for Target {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         write!(f.buf, "{}(name={}, path={})", self.kind, self.name, self.path.display())
@@ -61,6 +103,10 @@ impl Manifest {
         self.get_summary().get_name_ver().get_name()
     }
 
+    pub fn get_authors<'a>(&'a self) -> &'a [~str] {
+        self.authors.as_slice()
+    }
+
     pub fn get_dependencies<'a>(&'a self) -> &'a [Dependency] {
         self.get_summary().get_dependencies()
     }
@@ -109,8 +155,8 @@ impl Target {
  *
  */
 
-type SerializedLibTarget = SerializedTarget;
-type SerializedExecTarget = SerializedTarget;
+type TomlLibTarget = TomlTarget;
+type TomlExecTarget = TomlTarget;
 
 #[deriving(Decodable,Encodable,Eq,Clone,Show)]
 pub struct Project {
@@ -124,14 +170,14 @@ pub struct Project {
  */
 
 #[deriving(Decodable,Encodable,Eq,Clone)]
-pub struct SerializedManifest {
+pub struct TomlManifest {
     project: ~Project,
-    lib: Option<~[SerializedLibTarget]>,
-    bin: Option<~[SerializedExecTarget]>,
+    lib: Option<~[TomlLibTarget]>,
+    bin: Option<~[TomlExecTarget]>,
     dependencies: Option<HashMap<~str, ~str>>
 }
 
-impl SerializedManifest {
+impl TomlManifest {
     pub fn to_package(&self, path: &str) -> CargoResult<Package> {
         // Get targets
         let targets = normalize(&self.lib, &self.bin);
@@ -163,19 +209,19 @@ impl Project {
 }
 
 #[deriving(Decodable,Encodable,Eq,Clone)]
-struct SerializedTarget {
+struct TomlTarget {
     name: ~str,
     path: Option<~str>
 }
 
-fn normalize(lib: &Option<~[SerializedLibTarget]>, bin: &Option<~[SerializedExecTarget]>) -> Vec<Target> {
-    fn lib_targets(dst: &mut Vec<Target>, libs: &[SerializedLibTarget]) {
+fn normalize(lib: &Option<~[TomlLibTarget]>, bin: &Option<~[TomlExecTarget]>) -> Vec<Target> {
+    fn lib_targets(dst: &mut Vec<Target>, libs: &[TomlLibTarget]) {
         let l = &libs[0];
         let path = l.path.clone().unwrap_or_else(|| format!("src/{}.rs", l.name));
         dst.push(Target::lib_target(l.name, &Path::new(path)));
     }
 
-    fn bin_targets(dst: &mut Vec<Target>, bins: &[SerializedExecTarget], default: |&SerializedExecTarget| -> ~str) {
+    fn bin_targets(dst: &mut Vec<Target>, bins: &[TomlExecTarget], default: |&TomlExecTarget| -> ~str) {
         for bin in bins.iter() {
             let path = bin.path.clone().unwrap_or_else(|| default(bin));
             dst.push(Target::bin_target(bin.name.clone(), &Path::new(path)));

diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs
index efd732ae654ad5a761fd5ae6b8e655089fa16cd9..8b73d359e47926d3cf5d8d0fd07d7e5b237b80c5 100644 (file)
--- a/src/cargo/core/package.rs
+++ b/src/cargo/core/package.rs
@@ -10,8 +10,9 @@ use core::{
     Summary
 };
 use util::graph;
+use serialize::{Encoder,Encodable};
 
-#[deriving(Clone)]
+#[deriving(Clone,Eq)]
 pub struct Package {
     // The package's manifest
     manifest: Manifest,
@@ -19,6 +20,33 @@ pub struct Package {
     root: Path,
 }
 
+#[deriving(Encodable)]
+struct SerializedPackage {
+    name: ~str,
+    version: ~str,
+    dependencies: Vec<Dependency>,
+    authors: Vec<~str>,
+    targets: Vec<Target>,
+    root: ~str
+}
+
+impl<E, S: Encoder<E>> Encodable<S, E> for Package {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        let manifest = self.get_manifest();
+        let summary = manifest.get_summary();
+        let name_ver = summary.get_name_ver();
+
+        SerializedPackage {
+            name: name_ver.get_name().to_owned(),
+            version: name_ver.get_version().to_str(),
+            dependencies: Vec::from_slice(summary.get_dependencies()),
+            authors: Vec::from_slice(manifest.get_authors()),
+            targets: Vec::from_slice(manifest.get_targets()),
+            root: self.root.as_str().unwrap().to_owned()
+        }.encode(s)
+    }
+}
+
 impl Package {
     pub fn new(manifest: &Manifest, root: &Path) -> Package {
         Package {

diff --git a/src/cargo/core/summary.rs b/src/cargo/core/summary.rs
index 7f584f45ae37c44b5af581de53a5507d6e22acdf..5834fe34da80337574aceabc0ed72d95adb49204 100644 (file)
--- a/src/cargo/core/summary.rs
+++ b/src/cargo/core/summary.rs
@@ -3,7 +3,7 @@ use core::{
     NameVer
 };
 
-#[deriving(Show,Clone,Eq)]
+#[deriving(Show,Clone,Eq,Encodable)]
 pub struct Summary {
     name_ver: NameVer,
     dependencies: Vec<Dependency>

diff --git a/src/cargo/ops/cargo_read_manifest.rs b/src/cargo/ops/cargo_read_manifest.rs
index 4983992b9424dc1b9c73e3b74183ac4470ff42da..817f6d0faafc3ee3588e26c9daaa6fa10cae62c6 100644 (file)
--- a/src/cargo/ops/cargo_read_manifest.rs
+++ b/src/cargo/ops/cargo_read_manifest.rs
@@ -1,14 +1,14 @@
 use toml;
 use toml::from_toml;
 use core;
-use core::manifest::{SerializedManifest};
+use core::manifest::{TomlManifest};
 use core::errors::{CLIError,CLIResult,ToResult};
 
 pub fn read_manifest(manifest_path: &str) -> CLIResult<core::Package> {
     let root = try!(toml::parse_from_file(manifest_path.clone()).to_result(|err|
         CLIError::new(format!("Cargo.toml was not valid Toml: {}", manifest_path), Some(err.to_str()), 1)));
 
-    let toml_manifest = try!(from_toml::<SerializedManifest>(root.clone()).to_result(|err: toml::Error|
+    let toml_manifest = try!(from_toml::<TomlManifest>(root.clone()).to_result(|err: toml::Error|
         CLIError::new(format!("Cargo.toml was not in the right format: {}", manifest_path), Some(err.to_str()), 1)));
 
     toml_manifest.to_package(manifest_path.as_slice()).to_result(|err|