-use core::NameVer;
+use semver::Version;
+use core::{NameVer,VersionReq};
+use util::CargoResult;
-#[deriving(Eq,Clone,Show,Encodable,Decodable)]
+#[deriving(Eq,Clone,Show)]
pub struct Dependency {
- name: NameVer
+ name: ~str,
+ req: VersionReq
}
impl Dependency {
- pub fn new(name: &str) -> Dependency {
- Dependency { name: NameVer::new(name.to_owned(), "1.0.0") }
+ pub fn new(name: &str, req: &VersionReq) -> Dependency {
+ Dependency {
+ name: name.to_owned(),
+ req: req.clone()
+ }
}
- pub fn with_namever(name: &NameVer) -> Dependency {
- Dependency { name: name.clone() }
+ pub fn parse(name: &str, version: &str) -> CargoResult<Dependency> {
+ Ok(Dependency {
+ name: name.to_owned(),
+ req: try!(VersionReq::parse(version))
+ })
}
- pub fn with_name_and_version(name: &str, version: &str) -> Dependency {
- Dependency { name: NameVer::new(name, version) }
+ pub fn exact(name: &str, version: &Version) -> Dependency {
+ Dependency {
+ name: name.to_owned(),
+ req: VersionReq::exact(version)
+ }
}
- pub fn get_namever<'a>(&'a self) -> &'a NameVer {
- &self.name
+ pub fn get_version_req<'a>(&'a self) -> &'a VersionReq {
+ &self.req
}
pub fn get_name<'a>(&'a self) -> &'a str {
- self.name.get_name()
+ self.name.as_slice()
}
}
-pub trait DependencyNameVers {
- fn namevers(&self) -> Vec<NameVer>;
+#[deriving(Eq,Clone,Encodable)]
+pub struct SerializedDependency {
+ name: ~str,
+ req: ~str
}
-impl DependencyNameVers for Vec<Dependency> {
- fn namevers(&self) -> Vec<NameVer> {
- self.iter().map(|dep| dep.get_namever().clone()).collect()
+impl SerializedDependency {
+ pub fn from_dependency(dep: &Dependency) -> SerializedDependency {
+ SerializedDependency {
+ name: dep.get_name().to_owned(),
+ req: dep.get_version_req().to_str()
+ }
}
}
use std::fmt;
use std::fmt::{Show,Formatter};
use collections::HashMap;
+use semver::Version;
use serialize::{Encoder,Encodable};
use core::{
Dependency,
Package,
Summary
};
+use core::dependency::SerializedDependency;
+use util::CargoResult;
#[deriving(Eq,Clone)]
pub struct Manifest {
#[deriving(Eq,Clone,Encodable)]
pub struct SerializedManifest {
- summary: Summary,
+ name: ~str,
+ version: ~str,
+ dependencies: Vec<SerializedDependency>,
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(),
+ name: self.summary.get_name().to_owned(),
+ version: self.summary.get_version().to_str(),
+ dependencies: self.summary.get_dependencies().iter().map(|d| SerializedDependency::from_dependency(d)).collect(),
authors: self.authors.clone(),
targets: self.targets.clone(),
target_dir: self.target_dir.as_str().unwrap().to_owned()
self.get_summary().get_name_ver().get_name()
}
+ pub fn get_version<'a>(&'a self) -> &'a Version {
+ self.get_summary().get_name_ver().get_version()
+ }
+
pub fn get_authors<'a>(&'a self) -> &'a [~str] {
self.authors.as_slice()
}
}
impl TomlManifest {
- pub fn to_package(&self, path: &str) -> Package {
+ pub fn to_package(&self, path: &str) -> CargoResult<Package> {
// TODO: Convert hte argument to take a Path
let path = Path::new(path);
// Get targets
let targets = normalize(&self.lib, &self.bin);
- // Get deps
- let deps = self.dependencies.clone().map(|deps| {
- deps.iter().map(|(k,v)| {
- // This can produce an invalid version, but it's temporary because this needs
- // to be replaced with Dependency, not NameVer
- Dependency::with_namever(&NameVer::new(k.clone(), v.clone()))
- }).collect()
- }).unwrap_or_else(|| vec!());
+
+ let mut deps = Vec::new();
+
+ // Collect the deps
+ match self.dependencies {
+ Some(ref dependencies) => {
+ for (n, v) in dependencies.iter() {
+ deps.push(try!(Dependency::parse(*n, *v)));
+ }
+ }
+ None => ()
+ }
// TODO: https://github.com/mozilla/rust/issues/14049
let root = Path::new(path.dirname());
- Package::new(
+ Ok(Package::new(
&Manifest::new(
&Summary::new(&self.project.to_name_ver(), deps.as_slice()),
targets.as_slice(),
&Path::new("target")),
- &root)
+ &root))
}
}
Target,
Summary
};
+use core::dependency::SerializedDependency;
use util::graph;
use serialize::{Encoder,Encodable};
struct SerializedPackage {
name: ~str,
version: ~str,
- dependencies: Vec<Dependency>,
+ dependencies: Vec<SerializedDependency>,
authors: Vec<~str>,
targets: Vec<Target>,
root: ~str
SerializedPackage {
name: name_ver.get_name().to_owned(),
version: name_ver.get_version().to_str(),
- dependencies: Vec::from_slice(summary.get_dependencies()),
+ 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()),
root: self.root.as_str().unwrap().to_owned()
}
pub fn to_dependency(&self) -> Dependency {
- Dependency::with_namever(self.manifest.get_summary().get_name_ver())
+ Dependency::exact(self.manifest.get_name(), self.manifest.get_version())
}
pub fn get_manifest<'a>(&'a self) -> &'a Manifest {
macro_rules! pkg(
($name:expr => $($deps:expr),+) => (
{
- let d: Vec<Dependency> = vec!($($deps),+).iter().map(|s| Dependency::new(*s)).collect();
+ 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())
}
);
}
fn dep(name: &str) -> Dependency {
- Dependency::new(name)
+ Dependency::parse(name, "1.0.0").unwrap()
}
fn registry(pkgs: Vec<Summary>) -> Vec<Summary> {
+use semver::Version;
use core::{
Dependency,
NameVer
};
-#[deriving(Show,Clone,Eq,Encodable)]
+#[deriving(Show,Clone,Eq)]
pub struct Summary {
name_ver: NameVer,
dependencies: Vec<Dependency>
self.get_name_ver().get_name()
}
+ pub fn get_version<'a>(&'a self) -> &'a Version {
+ self.get_name_ver().get_version()
+ }
+
pub fn get_dependencies<'a>(&'a self) -> &'a [Dependency] {
self.dependencies.as_slice()
}
// TODO: Delete
fn deps(&self) -> Vec<Dependency> {
- self.iter().map(|summary| Dependency::with_namever(summary.get_name_ver())).collect()
+ self.iter().map(|summary| Dependency::exact(summary.get_name(), summary.get_version())).collect()
}
}
use semver::Version;
use util::{other_error,CargoResult};
+#[deriving(Eq,Clone)]
pub struct VersionReq {
predicates: Vec<Predicate>
}
-#[deriving(Eq)]
+#[deriving(Eq,Clone)]
enum Op {
Ex, // Exact
Gt, // Greater than
LtEq // Less than or equal to
}
+#[deriving(Eq,Clone)]
struct Predicate {
op: Op,
major: uint,
Ok(VersionReq { predicates: predicates })
}
+ pub fn exact(version: &Version) -> VersionReq {
+ VersionReq { predicates: vec!(Predicate::exact(version)) }
+ }
+
pub fn matches(&self, version: &Version) -> bool {
self.predicates.iter().all(|p| p.matches(version))
}
}
impl Predicate {
+ pub fn exact(version: &Version) -> Predicate {
+ Predicate {
+ op: Ex,
+ major: version.major,
+ minor: Some(version.minor),
+ patch: Some(version.patch)
+ }
+ }
+
pub fn matches(&self, ver: &Version) -> bool {
match self.op {
Ex => self.is_exact(ver),
let toml = try!(load_toml(root).map_err(|err: CargoError|
human_error(format!("Cargo.toml is not a valid Cargo manifest"), format!("path={}", path), err)));
- Ok(toml.to_package(path))
+ toml.to_package(path)
}
fn parse_from_file(path: &str) -> CargoResult<toml::Value> {
projects / cargo.git / commitdiff