API for SerializedManifest->Manifest and other org

Also fleshed out the Package struct.

Setting up to convert a vec of project paths into a vec of Packages to
pass to cargo-rustc.

diff --git a/src/cargo/core/dependency.rs b/src/cargo/core/dependency.rs
index 6b1e11da9e868781a538fc800361100cc9e20231..80d2356c505007983698686ca41efcc6453e0bd8 100644 (file)
--- a/src/cargo/core/dependency.rs
+++ b/src/cargo/core/dependency.rs
@@ -1,6 +1,6 @@
 use core;
 
-#[deriving(Eq,Clone,Show)]
+#[deriving(Eq,Clone,Show,Encodable,Decodable)]
 pub struct Dependency {
     name: core::NameVer
 }
@@ -10,6 +10,10 @@ impl Dependency {
         Dependency { name: core::NameVer::new(name.to_owned(), "1.0.0") }
     }
 
+    pub fn with_namever(name: &core::NameVer) -> Dependency {
+        Dependency { name: name.clone() }
+    }
+
     pub fn with_name_and_version(name: &str, version: &str) -> Dependency {
         Dependency { name: core::NameVer::new(name, version) }
     }

diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs
index d4a4c6801394e4006d8107f3ec57813e0fd904a5..c58866e111e08c25cacac4921c270e2c7eb209c9 100644 (file)
--- a/src/cargo/core/manifest.rs
+++ b/src/cargo/core/manifest.rs
@@ -1,19 +1,60 @@
 use core::NameVer;
+use core::dependency::Dependency;
+use collections::HashMap;
+use {CargoResult,ToCargoError};
 
 /*
  * TODO: Make all struct fields private
  */
 
-#[deriving(Decodable,Encodable,Eq,Clone,Ord)]
+#[deriving(Decodable,Encodable,Eq,Clone)]
+pub struct SerializedManifest {
+    project: ~Project,
+    lib: Option<~[SerializedLibTarget]>,
+    bin: Option<~[SerializedExecTarget]>,
+    dependencies: Option<HashMap<~str, ~str>>
+}
+
+#[deriving(Decodable,Encodable,Eq,Clone)]
+struct SerializedTarget {
+    name: ~str,
+    path: Option<~str>
+}
+
+type SerializedLibTarget = SerializedTarget;
+type SerializedExecTarget = SerializedTarget;
+
+#[deriving(Decodable,Encodable,Eq,Clone)]
 pub struct Manifest {
     pub project: ~Project,
     pub root: ~str,
     pub lib: ~[LibTarget],
     pub bin: ~[ExecTarget],
-    pub dependencies: Vec<NameVer>
+    pub target: ~str,
+    pub dependencies: Vec<Dependency>
 }
 
 impl Manifest {
+    pub fn from_serialized(path: &str, serialized: &SerializedManifest) -> CargoResult<Manifest> {
+        let (lib,bin) = normalize(&serialized.lib, &serialized.bin);
+        let &SerializedManifest { ref project, ref dependencies, .. } = serialized;
+
+        let deps = dependencies.clone().map(|deps| {
+            deps.iter().map(|(k,v)| {
+                Dependency::with_namever(&NameVer::new(k.clone(), v.clone()))
+            }).collect()
+        }).unwrap_or_else(|| vec!());
+
+        Ok(Manifest {
+            root: try!(Path::new(path.to_owned()).dirname_str().to_cargo_error(format!("Could not get dirname from {}", path), 1)).to_owned(),
+            project: project.clone(),
+            lib: lib,
+            bin: bin,
+            target: ~"target",
+            dependencies: deps
+        })
+    }
+
     pub fn get_name_ver(&self) -> NameVer {
         NameVer::new(self.project.name.as_slice(), self.project.version.as_slice())
     }
@@ -23,19 +64,49 @@ impl Manifest {
     }
 }
 
-#[deriving(Decodable,Encodable,Eq,Clone,Ord)]
+fn normalize(lib: &Option<~[SerializedLibTarget]>, bin: &Option<~[SerializedExecTarget]>) -> (~[LibTarget], ~[ExecTarget]) {
+    fn lib_targets(libs: &[SerializedLibTarget]) -> ~[LibTarget] {
+        let l = &libs[0];
+        let path = l.path.clone().unwrap_or_else(|| format!("src/{}.rs", l.name));
+        ~[LibTarget { path: path, name: l.name.clone() }]
+    }
+
+    fn bin_targets(bins: &[SerializedExecTarget], default: |&SerializedExecTarget| -> ~str) -> ~[ExecTarget] {
+        bins.iter().map(|bin| {
+            let path = bin.path.clone().unwrap_or_else(|| default(bin));
+            ExecTarget { path: path, name: bin.name.clone() }
+        }).collect()
+    }
+
+    match (lib, bin) {
+        (&Some(ref libs), &Some(ref bins)) => {
+            (lib_targets(libs.as_slice()), bin_targets(bins.as_slice(), |bin| format!("src/bin/{}.rs", bin.name)))
+        },
+        (&Some(ref libs), &None) => {
+            (lib_targets(libs.as_slice()), ~[])
+        },
+        (&None, &Some(ref bins)) => {
+            (~[], bin_targets(bins.as_slice(), |bin| format!("src/{}.rs", bin.name)))
+        },
+        (&None, &None) => {
+            (~[], ~[])
+        }
+    }
+}
+
+#[deriving(Decodable,Encodable,Eq,Clone,Show)]
 pub struct ExecTarget {
     pub name: ~str,
     pub path: ~str
 }
 
-#[deriving(Decodable,Encodable,Eq,Clone,Ord)]
+#[deriving(Decodable,Encodable,Eq,Clone,Show)]
 pub struct LibTarget {
     pub name: ~str,
     pub path: ~str
 }
 
-#[deriving(Decodable,Encodable,Eq,Clone,Ord)]
+#[deriving(Decodable,Encodable,Eq,Clone,Show)]
 pub struct Project {
     pub name: ~str,
     pub version: ~str,

diff --git a/src/cargo/core/mod.rs b/src/cargo/core/mod.rs
index 49ee02f38f83ecb4b73aed540eb05958afbfe737..99beeb8ffbcbb52e89b9481e6169a00d895e0daf 100644 (file)
--- a/src/cargo/core/mod.rs
+++ b/src/cargo/core/mod.rs
@@ -24,6 +24,6 @@ pub mod namever;
 pub mod source;
 pub mod package;
 pub mod dependency;
-mod manifest;
+pub mod manifest;
 mod registry;
 mod resolver;

diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs
index a54663860095d03c6838329d31790543c34d5db6..4ddae1ebd5c536c66386f2b9ca36d326287c898f 100644 (file)
--- a/src/cargo/core/package.rs
+++ b/src/cargo/core/package.rs
@@ -1,6 +1,8 @@
 use std::vec::Vec;
 use semver;
 use core;
+use core::{NameVer,Dependency};
+use core::manifest::{Manifest,LibTarget};
 
 /**
  * Represents a rust library internally to cargo. This will things like where
@@ -14,13 +16,25 @@ pub struct Package {
     name_ver: core::NameVer,
     deps: Vec<core::Dependency>,
     root: ~str,
-    source: ~str,
+    source: LibTarget,
     target: ~str
 }
 
 impl Package {
-    pub fn new(name: &core::NameVer, deps: &Vec<core::Dependency>, root: &str, source: &str, target: &str) -> Package {
-        Package { name_ver: name.clone(), deps: deps.clone(), root: root.to_owned(), source: source.to_owned(), target: target.to_owned()  }
+    pub fn new(name: &core::NameVer, deps: &Vec<core::Dependency>, root: &str, source: &LibTarget, target: &str) -> Package {
+        Package { name_ver: name.clone(), deps: deps.clone(), root: root.to_owned(), source: source.clone(), target: target.to_owned()  }
+    }
+
+    pub fn from_manifest(manifest: &Manifest) -> Package {
+        let project = &manifest.project;
+
+        Package {
+            name_ver: core::NameVer::new(project.name.as_slice(), project.version.as_slice()),
+            deps: manifest.dependencies.clone(),
+            root: manifest.root.clone(),
+            source: manifest.lib.as_slice().get(0).unwrap().clone(),
+            target: manifest.target.clone()
+        }
     }
 
     pub fn get_name<'a>(&'a self) -> &'a str {
@@ -35,8 +49,8 @@ impl Package {
         self.root.as_slice()
     }
 
-    pub fn get_source<'a>(&'a self) -> &'a str {
-        self.source.as_slice()
+    pub fn get_source<'a>(&'a self) -> &'a LibTarget {
+        &self.source
     }
 
     pub fn get_target<'a>(&'a self) -> &'a str {

diff --git a/src/cargo/ops/cargo_read_manifest.rs b/src/cargo/ops/cargo_read_manifest.rs
index 7223e5a8814eccae1599b069121df1ad73e066f3..b2c0c60b4b3d864be62028f1a91a8288adfa7d16 100644 (file)
--- a/src/cargo/ops/cargo_read_manifest.rs
+++ b/src/cargo/ops/cargo_read_manifest.rs
@@ -3,26 +3,7 @@ use hammer::FlagConfig;
 use serialize::Decoder;
 use toml::from_toml;
 use {CargoResult,ToCargoError,core};
-use std::path::Path;
-use collections::HashMap;
-use core::NameVer;
-
-#[deriving(Decodable,Encodable,Eq,Clone)]
-struct SerializedManifest {
-    project: ~core::Project,
-    lib: Option<~[SerializedLibTarget]>,
-    bin: Option<~[SerializedExecTarget]>,
-    dependencies: HashMap<~str, ~str>
-}
-
-#[deriving(Decodable,Encodable,Eq,Clone)]
-pub struct SerializedTarget {
-    name: ~str,
-    path: Option<~str>
-}
-
-pub type SerializedLibTarget = SerializedTarget;
-pub type SerializedExecTarget = SerializedTarget;
+use core::manifest::{SerializedManifest,Manifest};
 
 
 #[deriving(Decodable,Eq,Clone,Ord)]
@@ -45,45 +26,7 @@ pub fn execute(flags: ReadManifestFlags) -> CargoResult<Option<core::Manifest>>
 
     let toml_manifest = try!(from_toml::<SerializedManifest>(root.clone()).to_cargo_error(|e: toml::Error| format!("Couldn't parse Toml file: {:?}", e), 1));
 
-    let (lib, bin) = normalize(&toml_manifest.lib, &toml_manifest.bin);
-
-    let SerializedManifest { project, dependencies, .. } = toml_manifest;
-
-    Ok(Some(core::Manifest {
-        root: try!(Path::new(manifest_path.clone()).dirname_str().to_cargo_error(format!("Could not get dirname from {}", manifest_path), 1)).to_owned(),
-        project: project,
-        lib: lib,
-        bin: bin,
-        dependencies: dependencies.iter().map(|(k,v)| NameVer::new(k.clone(),v.clone())).collect()
-    }))
-}
-
-fn normalize(lib: &Option<~[SerializedLibTarget]>, bin: &Option<~[SerializedExecTarget]>) -> (~[core::LibTarget], ~[core::ExecTarget]) {
-    fn lib_targets(libs: &[SerializedLibTarget]) -> ~[core::LibTarget] {
-        let l = &libs[0];
-        let path = l.path.clone().unwrap_or_else(|| format!("src/{}.rs", l.name));
-        ~[core::LibTarget { path: path, name: l.name.clone() }]
-    }
-
-    fn bin_targets(bins: &[SerializedExecTarget], default: |&SerializedExecTarget| -> ~str) -> ~[core::ExecTarget] {
-        bins.iter().map(|bin| {
-            let path = bin.path.clone().unwrap_or_else(|| default(bin));
-            core::ExecTarget { path: path, name: bin.name.clone() }
-        }).collect()
-    }
-
-    match (lib, bin) {
-        (&Some(ref libs), &Some(ref bins)) => {
-            (lib_targets(libs.as_slice()), bin_targets(bins.as_slice(), |bin| format!("src/bin/{}.rs", bin.name)))
-        },
-        (&Some(ref libs), &None) => {
-            (lib_targets(libs.as_slice()), ~[])
-        },
-        (&None, &Some(ref bins)) => {
-            (~[], bin_targets(bins.as_slice(), |bin| format!("src/{}.rs", bin.name)))
-        },
-        (&None, &None) => {
-            (~[], ~[])
-        }
-    }
+    Manifest::from_serialized(manifest_path.as_slice(), &toml_manifest).map(|manifest| {
+        Some(manifest)
+    })
 }