Initial pass at namespacing packages

src/cargo/core/manifest.rs

@@ -1,8 +1,7 @@
 use std::fmt;
 use std::fmt::{Show,Formatter};
-use semver;
 use semver::Version;
-use serialize::{Encoder,Decoder,Encodable};
+use serialize::{Encoder,Encodable};
 use core::{
     Dependency,
     PackageId,
@@ -173,20 +172,3 @@ 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,
-    pub version: String,
-    pub authors: Vec<String>
-}
-
-impl Project {
-    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

@@ -6,7 +6,6 @@ pub use self::manifest::{
     Manifest,
     Target,
     TargetKind,
-    Project
 };
 
 pub use self::package::{

src/cargo/core/package_id.rs

@@ -1,4 +1,6 @@
 use semver;
+use url;
+use url::Url;
 use std::fmt;
 use std::fmt::{Show,Formatter};
 use serialize::{
@@ -24,17 +26,35 @@ impl<'a> ToVersion for &'a str {
     }
 }
 
-#[deriving(Clone,PartialEq,PartialOrd)]
+trait ToUrl {
+    fn to_url(self) -> Option<Url>;
+}
+
+impl<'a> ToUrl for &'a str {
+    fn to_url(self) -> Option<Url> {
+        url::from_str(self).ok()
+    }
+}
+
+impl ToUrl for Url {
+    fn to_url(self) -> Option<Url> {
+        Some(self)
+    }
+}
+
+#[deriving(Clone,PartialEq)]
 pub struct PackageId {
     name: String,
-    version: semver::Version
+    version: semver::Version,
+    namespace: Url
 }
 
 impl PackageId {
-    pub fn new<T: ToVersion>(name: &str, version: T) -> PackageId {
+    pub fn new<T: ToVersion, U: ToUrl>(name: &str, version: T, namespace: U) -> PackageId {
         PackageId {
             name: name.to_str(),
-            version: version.to_version().unwrap()
+            version: version.to_version().unwrap(),
+            namespace: namespace.to_url().unwrap()
         }
     }
 
@@ -45,11 +65,23 @@ impl PackageId {
     pub fn get_version<'a>(&'a self) -> &'a semver::Version {
         &self.version
     }
+
+    pub fn get_namespace<'a>(&'a self) -> &'a Url {
+        &self.namespace
+    }
 }
 
+static central_repo: &'static str = "http://rust-lang.org/central-repo";
+
 impl Show for PackageId {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{} v{}", self.name, self.version)
+        try!(write!(f, "{} v{}", self.name, self.version));
+
+        if self.namespace.to_str().as_slice() != central_repo {
+            try!(write!(f, " ({})", self.namespace));
+        }
+
+        Ok(())
     }
 }
 
@@ -59,12 +91,13 @@ impl<E, D: Decoder<E>> Decodable<D,E> for PackageId {
 
         Ok(PackageId::new(
             vector.get(0).as_slice(),
-            semver::parse(vector.get(1).as_slice()).unwrap()))
+            vector.get(1).as_slice(),
+            vector.get(2).as_slice()))
     }
 }
 
 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)
+        (vec!(self.name.clone(), self.version.to_str()), self.namespace.to_str()).encode(e)
     }
 }

src/cargo/core/resolver.rs

@@ -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(&PackageId::new($name, "1.0.0"), d.as_slice())
+            Summary::new(&PackageId::new($name, "1.0.0", "http://www.example.com/"), d.as_slice())
             }
         );
 
         ($name:expr) => (
-            Summary::new(&PackageId::new($name, "1.0.0"), [])
+            Summary::new(&PackageId::new($name, "1.0.0", "http://www.example.com/"), [])
         )
     )
 
     fn pkg(name: &str) -> Summary {
-        Summary::new(&PackageId::new(name, "1.0.0"), &[])
+        Summary::new(&PackageId::new(name, "1.0.0", "http://www.example.com/"), &[])
     }
 
     fn dep(name: &str) -> Dependency {
@@ -85,7 +85,7 @@ mod test {
 
     fn names(names: &[&'static str]) -> Vec<PackageId> {
         names.iter()
-            .map(|name| PackageId::new(*name, "1.0.0"))
+            .map(|name| PackageId::new(*name, "1.0.0", "http://www.example.com/"))
             .collect()
     }
 

src/cargo/util/toml.rs

@@ -2,7 +2,7 @@ use toml;
 use std::collections::HashMap;
 use serialize::Decodable;
 
-use core::{Summary,Manifest,Target,Project,Dependency};
+use core::{Summary,Manifest,Target,Dependency,PackageId};
 use util::{CargoResult,Require,simple_human,toml_error};
 
 pub fn to_manifest(contents: &[u8]) -> CargoResult<Manifest> {
@@ -90,12 +90,25 @@ pub struct DetailedTomlDependency {
 
 #[deriving(Encodable,PartialEq,Clone)]
 pub struct TomlManifest {
-    project: Box<Project>,
+    project: Box<TomlProject>,
     lib: Option<Vec<TomlLibTarget>>,
     bin: Option<Vec<TomlBinTarget>>,
     dependencies: Option<HashMap<String, TomlDependency>>,
 }
 
+#[deriving(Decodable,Encodable,PartialEq,Clone,Show)]
+pub struct TomlProject {
+    pub name: String,
+    pub version: String,
+    pub authors: Vec<String>
+}
+
+impl TomlProject {
+    pub fn to_package_id(&self, namespace: &str) -> PackageId {
+        PackageId::new(self.name.as_slice(), self.version.as_slice(), namespace)
+    }
+}
+
 impl TomlManifest {
     pub fn to_manifest(&self) -> CargoResult<Manifest> {
 
@@ -124,7 +137,7 @@ impl TomlManifest {
         }
 
         Ok(Manifest::new(
-                &Summary::new(&self.project.to_package_id(), deps.as_slice()),
+                &Summary::new(&self.project.to_package_id("http://rust-lang.org/central-repo"), deps.as_slice()),
                 targets.as_slice(),
                 &Path::new("target")))
     }