Rename NameVer -> PackageId

src/cargo/core/manifest.rs

@@ -1,10 +1,11 @@
 use std::fmt;
 use std::fmt::{Show,Formatter};
+use semver;
 use semver::Version;
 use serialize::{Encoder,Decoder,Encodable};
 use core::{
     Dependency,
-    NameVer,
+    PackageId,
     Summary
 };
 use core::dependency::SerializedDependency;
@@ -101,12 +102,16 @@ impl Manifest {
         &self.summary
     }
 
+    pub fn get_package_id<'a>(&'a self) -> &'a PackageId {
+        self.get_summary().get_package_id()
+    }
+
     pub fn get_name<'a>(&'a self) -> &'a str {
-        self.get_summary().get_name_ver().get_name()
+        self.get_package_id().get_name()
     }
 
     pub fn get_version<'a>(&'a self) -> &'a Version {
-        self.get_summary().get_name_ver().get_version()
+        self.get_summary().get_package_id().get_version()
     }
 
     pub fn get_authors<'a>(&'a self) -> &'a [String] {
@@ -169,6 +174,9 @@ impl Target {
     }
 }
 
+/* TODO:
+ * - Figure out if this is needed and/or if it should be moved somewhere else
+ */
 #[deriving(Decodable,Encodable,PartialEq,Clone,Show)]
 pub struct Project {
     pub name: String,
@@ -177,8 +185,8 @@ pub struct Project {
 }
 
 impl Project {
-    pub fn to_name_ver(&self) -> NameVer {
-        NameVer::new(self.name.as_slice(), self.version.as_slice())
+    pub fn to_package_id(&self) -> PackageId {
+        PackageId::new(self.name.as_slice(), semver::parse(self.version.as_slice()).unwrap())
     }
 }
 

src/cargo/core/mod.rs

@@ -1,7 +1,3 @@
-pub use self::namever::{
-    NameVer
-};
-
 pub use self::registry::{
     Registry,
 };
@@ -18,6 +14,10 @@ pub use self::package::{
     PackageSet
 };
 
+pub use self::package_id::{
+    PackageId
+};
+
 pub use self::source::{
     Source
 };
@@ -30,9 +30,9 @@ pub use self::dependency::Dependency;
 pub use self::version_req::VersionReq;
 
 pub mod errors;
-pub mod namever;
 pub mod source;
 pub mod package;
+pub mod package_id;
 pub mod dependency;
 pub mod manifest;
 pub mod resolver;

src/cargo/core/namever.rs

@@ -1,48 +0,0 @@
-use semver;
-use std::fmt;
-use std::fmt::{Show,Formatter};
-use serialize::{
-    Encodable,
-    Encoder,
-    Decodable,
-    Decoder
-};
-
-#[deriving(Clone,PartialEq,PartialOrd)]
-pub struct NameVer {
-    name: String,
-    version: semver::Version
-}
-
-impl NameVer {
-    pub fn new(name: &str, version: &str) -> NameVer {
-        NameVer { name: name.to_str(), version: semver::parse(version.as_slice()).unwrap() }
-    }
-
-    pub fn get_name<'a>(&'a self) -> &'a str {
-        self.name.as_slice()
-    }
-
-    pub fn get_version<'a>(&'a self) -> &'a semver::Version {
-        &self.version
-    }
-}
-
-impl Show for NameVer {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{} v{}", self.name, self.version)
-    }
-}
-
-impl<E, D: Decoder<E>> Decodable<D,E> for NameVer {
-    fn decode(d: &mut D) -> Result<NameVer, E> {
-        let vector: Vec<String> = try!(Decodable::decode(d));
-        Ok(NameVer { name: vector.get(0).clone(), version: semver::parse(vector.get(1).as_slice()).unwrap() })
-    }
-}
-
-impl<E, S: Encoder<E>> Encodable<S,E> for NameVer {
-    fn encode(&self, e: &mut S) -> Result<(), E> {
-        (vec!(self.name.clone(), self.version.to_str())).encode(e)
-    }
-}

src/cargo/core/package.rs

@@ -4,9 +4,9 @@ use std::fmt::{Show,Formatter};
 use std::path::Path;
 use semver::Version;
 use core::{
-    NameVer,
     Dependency,
     Manifest,
+    PackageId,
     Registry,
     Target,
     Summary
@@ -37,11 +37,11 @@ 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();
+        let package_id = summary.get_package_id();
 
         SerializedPackage {
-            name: name_ver.get_name().to_str(),
-            version: name_ver.get_version().to_str(),
+            name: package_id.get_name().to_str(),
+            version: package_id.get_version().to_str(),
             dependencies: summary.get_dependencies().iter().map(|d| SerializedDependency::from_dependency(d)).collect(),
             authors: Vec::from_slice(manifest.get_authors()),
             targets: Vec::from_slice(manifest.get_targets()),
@@ -70,12 +70,16 @@ impl Package {
         self.manifest.get_summary()
     }
 
+    pub fn get_package_id<'a>(&'a self) -> &'a PackageId {
+        self.manifest.get_package_id()
+    }
+
     pub fn get_name<'a>(&'a self) -> &'a str {
-        self.get_manifest().get_name()
+        self.get_package_id().get_name()
     }
 
     pub fn get_version<'a>(&'a self) -> &'a Version {
-        self.get_manifest().get_version()
+        self.get_package_id().get_version()
     }
 
     pub fn get_dependencies<'a>(&'a self) -> &'a [Dependency] {
@@ -97,15 +101,11 @@ impl Package {
     pub fn get_absolute_target_dir(&self) -> Path {
         self.get_root().join(self.get_target_dir())
     }
-
-    pub fn is_for_name_ver(&self, name_ver: &NameVer) -> bool {
-        self.get_name() == name_ver.get_name() && self.get_version() == name_ver.get_version()
-    }
 }
 
 impl Show for Package {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{}", self.get_summary().get_name_ver())
+        write!(f, "{}", self.get_summary().get_package_id())
     }
 }
 

src/cargo/core/package_id.rs

@@ -0,0 +1,70 @@
+use semver;
+use std::fmt;
+use std::fmt::{Show,Formatter};
+use serialize::{
+    Encodable,
+    Encoder,
+    Decodable,
+    Decoder
+};
+
+trait ToVersion {
+    fn to_version(self) -> Option<semver::Version>;
+}
+
+impl ToVersion for semver::Version {
+    fn to_version(self) -> Option<semver::Version> {
+        Some(self)
+    }
+}
+
+impl<'a> ToVersion for &'a str {
+    fn to_version(self) -> Option<semver::Version> {
+        semver::parse(self)
+    }
+}
+
+#[deriving(Clone,PartialEq,PartialOrd)]
+pub struct PackageId {
+    name: String,
+    version: semver::Version
+}
+
+impl PackageId {
+    pub fn new<T: ToVersion>(name: &str, version: T) -> PackageId {
+        PackageId {
+            name: name.to_str(),
+            version: version.to_version().unwrap()
+        }
+    }
+
+    pub fn get_name<'a>(&'a self) -> &'a str {
+        self.name.as_slice()
+    }
+
+    pub fn get_version<'a>(&'a self) -> &'a semver::Version {
+        &self.version
+    }
+}
+
+impl Show for PackageId {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "{} v{}", self.name, self.version)
+    }
+}
+
+impl<E, D: Decoder<E>> Decodable<D,E> for PackageId {
+    fn decode(d: &mut D) -> Result<PackageId, E> {
+        let vector: Vec<String> = try!(Decodable::decode(d));
+
+        Ok(PackageId::new(
+            vector.get(0).as_slice(),
+            semver::parse(vector.get(1).as_slice()).unwrap()))
+    }
+}
+
+impl<E, S: Encoder<E>> Encodable<S,E> for PackageId {
+    fn encode(&self, e: &mut S) -> Result<(), E> {
+        (vec!(self.name.clone(), self.version.to_str())).encode(e)
+    }
+}

src/cargo/core/resolver.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use core::{
     Dependency,
-    NameVer,
+    PackageId,
     Summary,
     Registry
 };
@@ -11,7 +11,7 @@ use util::result::CargoResult;
  * - The correct input here is not a registry. Resolves should be performable
  * on package summaries vs. the packages themselves.
  */
-pub fn resolve(deps: &[Dependency], registry: &Registry) -> CargoResult<Vec<NameVer>> {
+pub fn resolve(deps: &[Dependency], registry: &Registry) -> CargoResult<Vec<PackageId>> {
     let mut remaining = Vec::from_slice(deps);
     let mut resolve = HashMap::<&str, &Summary>::new();
 
@@ -19,7 +19,7 @@ pub fn resolve(deps: &[Dependency], registry: &Registry) -> CargoResult<Vec<Name
         let curr = match remaining.pop() {
             Some(curr) => curr,
             None => {
-                return Ok(resolve.values().map(|summary| summary.get_name_ver().clone()).collect());
+                return Ok(resolve.values().map(|summary| summary.get_package_id().clone()).collect());
             }
         };
 
@@ -50,7 +50,7 @@ mod test {
 
     use core::{
         Dependency,
-        NameVer,
+        PackageId,
         Summary
     };
 
@@ -62,17 +62,17 @@ mod test {
         ($name:expr => $($deps:expr),+) => (
             {
             let d: Vec<Dependency> = vec!($($deps),+).iter().map(|s| Dependency::parse(*s, "1.0.0").unwrap()).collect();
-            Summary::new(&NameVer::new($name, "1.0.0"), d.as_slice())
+            Summary::new(&PackageId::new($name, "1.0.0"), d.as_slice())
             }
         );
 
         ($name:expr) => (
-            Summary::new(&NameVer::new($name, "1.0.0"), [])
+            Summary::new(&PackageId::new($name, "1.0.0"), [])
         )
     )
 
     fn pkg(name: &str) -> Summary {
-        Summary::new(&NameVer::new(name, "1.0.0"), &[])
+        Summary::new(&PackageId::new(name, "1.0.0"), &[])
     }
 
     fn dep(name: &str) -> Dependency {
@@ -83,9 +83,9 @@ mod test {
         pkgs
     }
 
-    fn names(names: &[&'static str]) -> Vec<NameVer> {
+    fn names(names: &[&'static str]) -> Vec<PackageId> {
         names.iter()
-            .map(|name| NameVer::new(*name, "1.0.0"))
+            .map(|name| PackageId::new(*name, "1.0.0"))
             .collect()
     }
 

src/cargo/core/source.rs

@@ -1,4 +1,4 @@
-use core::{Summary,NameVer,Package};
+use core::{Summary,Package,PackageId};
 use util::CargoResult;
 
 /**
@@ -25,7 +25,7 @@ pub trait Source {
      * The download method fetches the full package for each name and
      * version specified.
      */
-    fn download(&self, packages: &[NameVer]) -> CargoResult<()>;
+    fn download(&self, packages: &[PackageId]) -> CargoResult<()>;
 
     /**
      * The get method returns the Path of each specified package on the
@@ -33,7 +33,7 @@ pub trait Source {
      * and that the packages are already locally available on the file
      * system.
      */
-    fn get(&self, packages: &[NameVer]) -> CargoResult<Vec<Package>>;
+    fn get(&self, packages: &[PackageId]) -> CargoResult<Vec<Package>>;
 }
 
 impl Source for Vec<Box<Source>> {
@@ -56,7 +56,7 @@ impl Source for Vec<Box<Source>> {
         Ok(ret)
     }
 
-    fn download(&self, packages: &[NameVer]) -> CargoResult<()> {
+    fn download(&self, packages: &[PackageId]) -> CargoResult<()> {
         for source in self.iter() {
             try!(source.download(packages));
         }
@@ -64,7 +64,7 @@ impl Source for Vec<Box<Source>> {
         Ok(())
     }
 
-    fn get(&self, packages: &[NameVer]) -> CargoResult<Vec<Package>> {
+    fn get(&self, packages: &[PackageId]) -> CargoResult<Vec<Package>> {
         let mut ret = Vec::new();
 
         for source in self.iter() {

src/cargo/core/summary.rs

@@ -1,33 +1,33 @@
 use semver::Version;
 use core::{
     Dependency,
-    NameVer
+    PackageId
 };
 
 #[deriving(Show,Clone,PartialEq)]
 pub struct Summary {
-    name_ver: NameVer,
+    package_id: PackageId,
     dependencies: Vec<Dependency>
 }
 
 impl Summary {
-    pub fn new(name_ver: &NameVer, dependencies: &[Dependency]) -> Summary {
+    pub fn new(pkg_id: &PackageId, dependencies: &[Dependency]) -> Summary {
         Summary {
-            name_ver: name_ver.clone(),
+            package_id: pkg_id.clone(),
             dependencies: Vec::from_slice(dependencies)
         }
     }
 
-    pub fn get_name_ver<'a>(&'a self) -> &'a NameVer {
-        &self.name_ver
+    pub fn get_package_id<'a>(&'a self) -> &'a PackageId {
+        &self.package_id
     }
 
     pub fn get_name<'a>(&'a self) -> &'a str {
-        self.get_name_ver().get_name()
+        self.get_package_id().get_name()
     }
 
     pub fn get_version<'a>(&'a self) -> &'a Version {
-        self.get_name_ver().get_version()
+        self.get_package_id().get_version()
     }
 
     pub fn get_dependencies<'a>(&'a self) -> &'a [Dependency] {
@@ -43,7 +43,7 @@ pub trait SummaryVec {
 impl SummaryVec for Vec<Summary> {
     // TODO: Move to Registry
     fn names(&self) -> Vec<String> {
-        self.iter().map(|summary| summary.name_ver.get_name().to_str()).collect()
+        self.iter().map(|summary| summary.get_name().to_str()).collect()
     }
 
     // TODO: Delete

src/cargo/sources/git/source.rs

@@ -1,6 +1,6 @@
 use ops;
 use core::source::Source;
-use core::{NameVer,Package,Summary};
+use core::{Package,PackageId,Summary};
 use util::CargoResult;
 use sources::git::utils::{GitReference,GitRemote,Master,Other};
 use std::fmt;
@@ -44,15 +44,15 @@ impl Source for GitSource {
         Ok(vec!(pkg.get_summary().clone()))
     }
 
-    fn download(&self, _: &[NameVer]) -> CargoResult<()> {
+    fn download(&self, _: &[PackageId]) -> CargoResult<()> {
         Ok(())
     }
 
-    fn get(&self, packages: &[NameVer]) -> CargoResult<Vec<Package>> {
+    fn get(&self, package_ids: &[PackageId]) -> CargoResult<Vec<Package>> {
         // TODO: Support multiple manifests per repo
         let pkg = try!(read_manifest(&self.checkout_path));
 
-        if packages.iter().any(|nv| pkg.is_for_name_ver(nv)) {
+        if package_ids.iter().any(|pkg_id| pkg_id == pkg.get_package_id()) {
             Ok(vec!(pkg))
         } else {
             Ok(vec!())

src/cargo/sources/path.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 use std::fmt::{Show,Formatter};
-use core::{NameVer,Package,Summary};
+use core::{Package,PackageId,Summary};
 use core::source::Source;
 use ops;
 use util::{CargoResult};
@@ -37,15 +37,15 @@ impl Source for PathSource {
         }).collect())
     }
 
-    fn download(&self, _: &[NameVer])  -> CargoResult<()>{
+    fn download(&self, _: &[PackageId])  -> CargoResult<()>{
         Ok(())
     }
 
-    fn get(&self, name_vers: &[NameVer]) -> CargoResult<Vec<Package>> {
+    fn get(&self, name_vers: &[PackageId]) -> CargoResult<Vec<Package>> {
         Ok(self.paths.iter().filter_map(|path| {
             match read_manifest(path) {
                 Ok(pkg) => {
-                    if name_vers.iter().any(|nv| pkg.is_for_name_ver(nv)) {
+                    if name_vers.iter().any(|pkg_id| pkg.get_package_id() == pkg_id) {
                         Some(pkg)
                     } else {
                         None

src/cargo/util/toml.rs

@@ -124,7 +124,7 @@ impl TomlManifest {
         }
 
         Ok(Manifest::new(
-                &Summary::new(&self.project.to_name_ver(), deps.as_slice()),
+                &Summary::new(&self.project.to_package_id(), deps.as_slice()),
                 targets.as_slice(),
                 &Path::new("target")))
     }