Test unit tests passing again

diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs
index efc7ea99fd91b88faffba6a0a06c96335432ece1..700a366351e82c92aa076d579fc4efc826e4f832 100644 (file)
--- a/src/cargo/core/package.rs
+++ b/src/cargo/core/package.rs
@@ -71,9 +71,7 @@ impl PackageSet {
      * Get a package by name out of the set
      */
     pub fn get<'a>(&'a self, name: &str) -> &'a Package {
-        let opts = self.query(name);
-        assert!(opts.len() == 1, "expected exactly one package named `{}`", name);
-        *opts.get(0)
+        self.packages.iter().find(|pkg| name == pkg.get_name()).unwrap()
     }
 
     pub fn get_all<'a>(&'a self, names: &[&str]) -> ~[&'a Package] {
@@ -106,9 +104,10 @@ impl PackageSet {
 }
 
 impl Registry for PackageSet {
-  fn query<'a>(&'a self, name: &str) -> Vec<&'a Package> {
+  fn query<'a>(&'a self, name: &str) -> Vec<&'a Summary> {
     self.packages.iter()
       .filter(|pkg| name == pkg.get_name())
+      .map(|pkg| pkg.get_summary())
       .collect()
   }
 }

diff --git a/src/cargo/core/registry.rs b/src/cargo/core/registry.rs
index b8e40a84ca8c2a81790176f0248c284b386ce3a2..2aeeca19d569e44fd932833e9cb9bdb2f23237a3 100644 (file)
--- a/src/cargo/core/registry.rs
+++ b/src/cargo/core/registry.rs
@@ -1,10 +1,17 @@
 use std::vec::Vec;
 
 use core::{
-  // Dependency,
-  Package
+    Summary
 };
 
 pub trait Registry {
-  fn query<'a>(&'a self, name: &str) -> Vec<&'a Package>;
+    fn query<'a>(&'a self, name: &str) -> Vec<&'a Summary>;
+}
+
+impl Registry for Vec<Summary> {
+    fn query<'a>(&'a self, name: &str) -> Vec<&'a Summary> {
+        self.iter()
+          .filter(|summary| name == summary.get_name())
+          .collect()
+    }
 }

diff --git a/src/cargo/core/resolver.rs b/src/cargo/core/resolver.rs
index 0a944c980b0fefcfc3a3c639bb50870b72447ff8..5ec587713a98329fb50840682fdaf941fc8252ba 100644 (file)
--- a/src/cargo/core/resolver.rs
+++ b/src/cargo/core/resolver.rs
@@ -1,6 +1,10 @@
 use collections::HashMap;
-use core;
-use core::package::PackageSet;
+use core::{
+    Dependency,
+    NameVer,
+    Summary,
+    Registry
+};
 use core::errors::CargoResult;
 
 /* TODO:
@@ -8,16 +12,15 @@ use core::errors::CargoResult;
  * on package summaries vs. the packages themselves.
  */
 #[allow(dead_code)]
-pub fn resolve(deps: &[core::Dependency], registry: &core::Registry) -> CargoResult<PackageSet> {
+pub fn resolve(deps: &[Dependency], registry: &Registry) -> CargoResult<Vec<NameVer>> {
     let mut remaining = Vec::from_slice(deps);
-    let mut resolve = HashMap::<&str, &core::Package>::new();
+    let mut resolve = HashMap::<&str, &Summary>::new();
 
     loop {
         let curr = match remaining.pop() {
             Some(curr) => curr,
             None => {
-                let packages: Vec<core::Package> = resolve.values().map(|v| (*v).clone()).collect();
-                return Ok(PackageSet::new(packages.as_slice()))
+                return Ok(resolve.values().map(|summary| summary.get_name_ver().clone()).collect());
             }
         };
 
@@ -40,7 +43,6 @@ pub fn resolve(deps: &[core::Dependency], registry: &core::Registry) -> CargoRes
 
 #[cfg(test)]
 mod test {
-
     use hamcrest::{
         assert_that,
         equal_to,
@@ -49,8 +51,8 @@ mod test {
 
     use core::{
         Dependency,
-        Package,
-        PackageSet
+        NameVer,
+        Summary
     };
 
     use super::{
@@ -59,70 +61,79 @@ mod test {
 
     macro_rules! pkg(
         ($name:expr => $($deps:expr),+) => (
-            Package::new($name, &vec!($($deps),+).iter().map(|s| Dependency::new(*s)).collect())
+            {
+            let d: Vec<Dependency> = vec!($($deps),+).iter().map(|s| Dependency::new(*s)).collect();
+            Summary::new(&NameVer::new($name, "1.0.0"), d.as_slice())
+            }
         );
 
         ($name:expr) => (
-            Package::new($name, &vec!())
+            Summary::new(&NameVer::new($name, "1.0.0"), [])
         )
     )
 
-    fn pkg(name: &str) -> Package {
-        Package::new(name, &Vec::<Dependency>::new())
+    fn pkg(name: &str) -> Summary {
+        Summary::new(&NameVer::new(name, "1.0.0"), &[])
     }
 
     fn dep(name: &str) -> Dependency {
         Dependency::new(name)
     }
 
-    fn registry(pkgs: Vec<Package>) -> PackageSet {
-        PackageSet::new(&pkgs)
+    fn registry(pkgs: Vec<Summary>) -> Vec<Summary> {
+        pkgs
+    }
+
+    fn names(names: &[&'static str]) -> Vec<NameVer> {
+        names.iter()
+            .map(|name| NameVer::new(*name, "1.0.0"))
+            .collect()
     }
 
     #[test]
     pub fn test_resolving_empty_dependency_list() {
-        let res = resolve(&vec!(), &registry(vec!())).unwrap();
+        let res = resolve([], &registry(vec!())).unwrap();
 
-        assert_that(&res, equal_to(&Vec::<Package>::new()));
+        assert_that(&res, equal_to(&names([])));
     }
 
     #[test]
     pub fn test_resolving_only_package() {
         let reg = registry(vec!(pkg("foo")));
-        let res = resolve(&vec!(dep("foo")), &reg);
+        let res = resolve([dep("foo")], &reg);
 
-        assert_that(&res.unwrap(), equal_to(&vec!(pkg("foo"))));
+        assert_that(&res.unwrap(), equal_to(&names(["foo"])));
     }
 
     #[test]
     pub fn test_resolving_one_dep() {
         let reg = registry(vec!(pkg("foo"), pkg("bar")));
-        let res = resolve(&vec!(dep("foo")), &reg);
+        let res = resolve([dep("foo")], &reg);
 
-        assert_that(&res.unwrap(), equal_to(&vec!(pkg("foo"))));
+        assert_that(&res.unwrap(), equal_to(&names(["foo"])));
     }
 
     #[test]
     pub fn test_resolving_multiple_deps() {
         let reg = registry(vec!(pkg!("foo"), pkg!("bar"), pkg!("baz")));
-        let res = resolve(&vec!(dep("foo"), dep("baz")), &reg).unwrap();
+        let res = resolve([dep("foo"), dep("baz")], &reg).unwrap();
 
-        assert_that(&res, contains(vec!(pkg("foo"), pkg("baz"))).exactly());
+        assert_that(&res, contains(names(["foo", "baz"])).exactly());
     }
 
     #[test]
     pub fn test_resolving_transitive_deps() {
         let reg = registry(vec!(pkg!("foo"), pkg!("bar" => "foo")));
-        let res = resolve(&vec!(dep("bar")), &reg).unwrap();
+        let res = resolve([dep("bar")], &reg).unwrap();
 
-        assert_that(&res, contains(vec!(pkg!("foo"), pkg!("bar" => "foo"))));
+        assert_that(&res, contains(names(["foo", "bar"])));
     }
 
     #[test]
     pub fn test_resolving_common_transitive_deps() {
         let reg = registry(vec!(pkg!("foo" => "bar"), pkg!("bar")));
-        let res = resolve(&vec!(dep("foo"), dep("bar")), &reg).unwrap();
+        let res = resolve([dep("foo"), dep("bar")], &reg).unwrap();
 
-        assert_that(&res, contains(vec!(pkg!("foo" => "bar"), pkg!("bar"))));
+        assert_that(&res, contains(names(["foo", "bar"])));
     }
 }

diff --git a/src/cargo/core/summary.rs b/src/cargo/core/summary.rs
index eb1a21208724cd70af84f17d36d96a3fd5974499..efd35e7383d0b7d9db3e73fb8854ded4c7714bd5 100644 (file)
--- a/src/cargo/core/summary.rs
+++ b/src/cargo/core/summary.rs
@@ -21,6 +21,10 @@ impl Summary {
         &self.name_ver
     }
 
+    pub fn get_name<'a>(&'a self) -> &'a str {
+        self.get_name_ver().get_name()
+    }
+
     pub fn get_dependencies<'a>(&'a self) -> &'a [Dependency] {
         self.dependencies.as_slice()
     }

diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs
index 28e763e84f8f20062f418fcb074eb915ba3fa5d1..f6196e297cda2fbd9673792101569f5c63c0163b 100644 (file)
--- a/src/cargo/ops/cargo_compile.rs
+++ b/src/cargo/ops/cargo_compile.rs
@@ -25,6 +25,7 @@ use ops::cargo_rustc;
 use core::errors::{CargoError,CLIError,CLIResult,ToResult};
 
 pub fn compile(manifest_path: &str) -> CLIResult<()> {
+    // TODO: Fix
     let configs = try!(all_configs(os::getcwd()).to_result(|err: CargoError|
         CLIError::new("Could not load configurations", Some(err.to_str()), 1)));
 
@@ -54,7 +55,7 @@ pub fn compile(manifest_path: &str) -> CLIResult<()> {
     let resolved = try!(resolve(deps.as_slice(), &registry).to_result(|err: CargoError|
         CLIError::new("Unable to resolve dependencies", Some(err.to_str()), 1)));
 
-    try!(cargo_rustc::compile(&resolved));
+    try!(cargo_rustc::compile(&registry));
 
     Ok(())
 }