-Subproject commit ceae88af087e047309d4cedb971d6ec931fd20b8
+Subproject commit ae740b4ba884050eeae5b39048de0c31c6bdef30
-Subproject commit cf8026d844409c3469891e41edb6044567e41c79
+Subproject commit f4299be4b130502650ef6759dedd0aa05d766be5
use cargo::util::important_paths::find_project;
use cargo::util::ToCLI;
-#[deriving(Eq,Clone,Decodable,Encodable)]
+#[deriving(PartialEq,Clone,Decodable,Encodable)]
pub struct Options {
manifest_path: Option<String>
}
use cargo::sources::git::{GitSource,GitRemote};
use url::Url;
-#[deriving(Eq,Clone,Decodable)]
+#[deriving(PartialEq,Clone,Decodable)]
struct Options {
database_path: String,
checkout_path: String,
use cargo::core::Package;
use cargo::ops;
-#[deriving(Eq,Clone,Decodable)]
+#[deriving(PartialEq,Clone,Decodable)]
struct Options {
manifest_path: String
}
extern crate toml;
extern crate hammer;
extern crate serialize;
-extern crate collections;
#[phase(syntax, link)]
extern crate log;
#[deriving(Encodable)]
struct ConfigOut {
- values: collections::HashMap<String, config::ConfigValue>
+ values: std::collections::HashMap<String, config::ConfigValue>
}
#[deriving(Decodable)]
println!("{}", value);
Ok(None)
} else {
- let mut map = collections::HashMap::new();
+ let mut map = std::collections::HashMap::new();
map.insert(args.key.clone(), value);
Ok(Some(ConfigOut { values: map }))
}
use core::{VersionReq};
use util::CargoResult;
-#[deriving(Eq,Clone,Show)]
+#[deriving(PartialEq,Clone,Show)]
pub struct Dependency {
name: String,
req: VersionReq
}
}
-#[deriving(Eq,Clone,Encodable)]
+#[deriving(PartialEq,Clone,Encodable)]
pub struct SerializedDependency {
name: String,
req: String
use std::fmt;
use std::fmt::{Show,Formatter};
-use collections::HashMap;
+use std::collections::HashMap;
use semver::Version;
use serialize::{Encoder,Encodable};
use core::{
use core::dependency::SerializedDependency;
use util::CargoResult;
-#[deriving(Eq,Clone)]
+#[deriving(PartialEq,Clone)]
pub struct Manifest {
summary: Summary,
authors: Vec<String>,
}
}
-#[deriving(Eq,Clone,Encodable)]
+#[deriving(PartialEq,Clone,Encodable)]
pub struct SerializedManifest {
name: String,
version: String,
}
}
-#[deriving(Show,Clone,Eq,Encodable)]
+#[deriving(Show,Clone,PartialEq,Encodable)]
pub enum TargetKind {
LibTarget,
BinTarget
}
-#[deriving(Clone,Eq)]
+#[deriving(Clone,PartialEq)]
pub struct Target {
kind: TargetKind,
name: String,
type TomlLibTarget = TomlTarget;
type TomlBinTarget = TomlTarget;
-#[deriving(Decodable,Encodable,Eq,Clone,Show)]
+#[deriving(Decodable,Encodable,PartialEq,Clone,Show)]
pub struct Project {
pub name: String,
pub version: String,
* TODO: Make all struct fields private
*/
-#[deriving(Decodable,Encodable,Eq,Clone)]
+#[deriving(Decodable,Encodable,PartialEq,Clone)]
pub struct TomlManifest {
project: Box<Project>,
lib: Option<~[TomlLibTarget]>,
}
}
-#[deriving(Decodable,Encodable,Eq,Clone,Show)]
+#[deriving(Decodable,Encodable,PartialEq,Clone,Show)]
struct TomlTarget {
name: String,
path: Option<String>
Decoder
};
-#[deriving(Clone,Eq,Ord)]
+#[deriving(Clone,PartialEq,PartialOrd)]
pub struct NameVer {
name: String,
version: semver::Version
use util::graph;
use serialize::{Encoder,Encodable};
-#[deriving(Clone,Eq)]
+#[deriving(Clone,PartialEq)]
pub struct Package {
// The package's manifest
manifest: Manifest,
}
}
-#[deriving(Eq,Clone,Show)]
+#[deriving(PartialEq,Clone,Show)]
pub struct PackageSet {
packages: Vec<Package>
}
-use collections::HashMap;
+use std::collections::HashMap;
use core::{
Dependency,
NameVer,
NameVer
};
-#[deriving(Show,Clone,Eq)]
+#[deriving(Show,Clone,PartialEq)]
pub struct Summary {
name_ver: NameVer,
dependencies: Vec<Dependency>
use semver::Version;
use util::{other_error,CargoResult};
-#[deriving(Eq,Clone)]
+#[deriving(PartialEq,Clone)]
pub struct VersionReq {
predicates: Vec<Predicate>
}
-#[deriving(Eq,Clone)]
+#[deriving(PartialEq,Clone)]
enum Op {
Ex, // Exact
Gt, // Greater than
LtEq // Less than or equal to
}
-#[deriving(Eq,Clone)]
+#[deriving(PartialEq,Clone)]
struct Predicate {
op: Op,
major: uint,
state: LexState
}
-#[deriving(Show,Eq)]
+#[deriving(Show,PartialEq)]
enum LexState {
LexInit,
LexStart,
#![allow(deprecated_owned_vector)]
#![feature(macro_rules,phase)]
-extern crate collections;
extern crate term;
extern crate url;
extern crate serialize;
use std::io::fs::{mkdir_recursive,rmdir_recursive,chmod};
use serialize::{Encodable,Encoder};
-#[deriving(Eq,Clone,Encodable)]
+#[deriving(PartialEq,Clone,Encodable)]
pub enum GitReference {
Master,
Other(String)
* GitRemote represents a remote repository. It gets cloned into a local GitDatabase.
*/
-#[deriving(Eq,Clone)]
+#[deriving(PartialEq,Clone)]
pub struct GitRemote {
url: Url,
verbose: bool
}
-#[deriving(Eq,Clone,Encodable)]
+#[deriving(PartialEq,Clone,Encodable)]
struct EncodableGitRemote {
url: String
}
* can be cloned from this GitDatabase.
*/
-#[deriving(Eq,Clone)]
+#[deriving(PartialEq,Clone)]
pub struct GitDatabase {
remote: GitRemote,
path: Path,
use std::{io,fmt};
-use collections::HashMap;
+use std::collections::HashMap;
use serialize::{Encodable,Encoder};
use toml;
use util::{other_error,CargoResult,Require};
-#[deriving(Eq,TotalEq,Clone,Encodable,Decodable)]
+#[deriving(Eq,PartialEq,Clone,Encodable,Decodable)]
pub enum Location {
Project,
Global
}
-#[deriving(Eq,TotalEq,Clone,Decodable)]
+#[deriving(Eq,PartialEq,Clone,Decodable)]
pub enum ConfigValueValue {
String(String),
List(Vec<String>)
}
}
-#[deriving(Eq,TotalEq,Clone,Decodable)]
+#[deriving(Eq,PartialEq,Clone,Decodable)]
pub struct ConfigValue {
value: ConfigValueValue,
path: Vec<Path>
use std::hash::Hash;
-use collections::HashMap;
+use std::collections::HashMap;
pub struct Graph<N> {
nodes: HashMap<N, ~[N]>
Done
}
-impl<N: TotalEq + Hash + Clone> Graph<N> {
+impl<N: Eq + Hash + Clone> Graph<N> {
pub fn new() -> Graph<N> {
Graph { nodes: HashMap::new() }
}
use std::path::Path;
use std::io::process::{Command,ProcessOutput,InheritFd};
use util::{CargoResult,io_error,process_error};
-use collections::HashMap;
+use std::collections::HashMap;
-#[deriving(Clone,Eq)]
+#[deriving(Clone,PartialEq)]
pub struct ProcessBuilder {
program: String,
args: Vec<String>,
}
}
-#[deriving(Eq,Clone)]
+#[deriving(PartialEq,Clone)]
pub struct CargoError {
pub kind: CargoErrorKind,
desc: CargoErrorDescription,
}
}
-#[deriving(Eq,Show,Clone)]
+#[deriving(PartialEq,Show,Clone)]
enum CargoErrorDescription {
StaticDescription(&'static str),
BoxedDescription(String)
}
}
-#[deriving(Eq)]
+#[deriving(PartialEq)]
pub enum CargoErrorKind {
HumanReadableError,
InternalError,