-Subproject commit c305bcb84ed51d7bd808bc20c09c00a1beb1b087
+Subproject commit 5fbc58a5f2251c427f405234a52a4bb54241b19a
-Subproject commit 0de103ed19997884f2766456f7a003b94f1daa42
+Subproject commit ca130156b599a8f48e0edee3e782e8de93e00c34
#[deriving(Eq,Clone,Decodable,Encodable)]
pub struct Options {
- manifest_path: Option<StrBuf>
+ manifest_path: Option<String>
}
impl FlagConfig for Options {}
let root = match options.manifest_path {
Some(path) => Path::new(path),
- None => try!(find_project(os::getcwd(), "Cargo.toml".to_owned())
+ None => try!(find_project(os::getcwd(), "Cargo.toml")
.map(|path| path.join("Cargo.toml"))
.to_result(|err|
CLIError::new("Could not find Cargo.toml in this directory or any parent directory", Some(err), 102)))
use hammer::FlagConfig;
use cargo::{execute_main_without_stdin,CLIResult,CLIError,ToResult};
-use cargo::core::Package;
-use cargo::util::{Require,ToCLI,simple_human};
+use cargo::util::ToCLI;
use cargo::sources::git::{GitCommand,GitRepo};
use url::Url;
#[deriving(Eq,Clone,Decodable)]
struct Options {
- directory: StrBuf,
- url: StrBuf,
- reference: StrBuf
+ directory: String,
+ url: String,
+ reference: String
}
impl FlagConfig for Options {}
#[deriving(Eq,Clone,Decodable)]
struct Options {
- manifest_path: StrBuf
+ manifest_path: String
}
impl FlagConfig for Options {}
fn execute(options: Options) -> CLIResult<Option<Package>> {
ops::read_manifest(options.manifest_path.as_slice()).map(|m| Some(m))
- .map_err(|err| CLIError {
- msg: err.get_desc().to_strbuf(),
- detail: err.get_detail().map(|s| s.to_strbuf()),
- exit_code: 1
- })
+ .map_err(|err| CLIError::new(err.get_desc(), Some(err.get_detail()), 1))
}
*/
fn main() {
- let arguments: Vec<StrBuf> = args().iter().map(|a| a.to_strbuf()).collect();
+ let arguments = args();
let opts = vec!(
reqopt("m", "manifest", "the location of the manifest", "MANIFEST")
#[deriving(Encodable)]
struct ProjectLocation {
- root: StrBuf
+ root: String
}
/**
Err(err) => return handle_error(err)
};
- if cmd == "config-for-key".to_strbuf() {
+ if cmd == "config-for-key".to_str() {
log!(4, "cmd == config-for-key");
execute_main_without_stdin(config_for_key)
}
- else if cmd == "config-list".to_strbuf() {
+ else if cmd == "config-list".to_str() {
log!(4, "cmd == config-list");
execute_main_without_stdin(config_list)
}
- else if cmd == "locate-project".to_strbuf() {
+ else if cmd == "locate-project".to_str() {
log!(4, "cmd == locate-project");
execute_main_without_stdin(locate_project)
}
}
}
-fn process(args: Vec<~str>) -> CLIResult<(StrBuf, Vec<StrBuf>)> {
- let args: Vec<StrBuf> = args.tail().iter().map(|a| a.to_strbuf()).collect();
+fn process(args: Vec<String>) -> CLIResult<(String, Vec<String>)> {
+ let args: Vec<String> = Vec::from_slice(args.tail());
let head = try!(args.iter().nth(0).to_result(|_| CLIError::new("No subcommand found", None::<&str>, 1))).to_owned();
let tail = Vec::from_slice(args.tail());
- Ok((head.to_strbuf(), tail))
+ Ok((head, tail))
}
#[deriving(Encodable)]
struct ConfigOut {
- values: collections::HashMap<StrBuf, config::ConfigValue>
+ values: collections::HashMap<String, config::ConfigValue>
}
#[deriving(Decodable)]
struct ConfigForKeyFlags {
- key: StrBuf,
+ key: String,
human: bool
}
let string = try!(root.as_str().to_result(|_|
CLIError::new(format!("Your project path contains characters not representable in Unicode: {}", os::getcwd().display()), None::<&str>, 1)));
- Ok(Some(ProjectLocation { root: string.to_strbuf() }))
+ Ok(Some(ProjectLocation { root: string.to_str() }))
}
#[deriving(Eq,Clone,Show)]
pub struct Dependency {
- name: StrBuf,
+ name: String,
req: VersionReq
}
impl Dependency {
pub fn new(name: &str, req: &VersionReq) -> Dependency {
Dependency {
- name: name.to_strbuf(),
+ name: name.to_str(),
req: req.clone()
}
}
pub fn parse(name: &str, version: &str) -> CargoResult<Dependency> {
Ok(Dependency {
- name: name.to_strbuf(),
+ name: name.to_str(),
req: try!(VersionReq::parse(version))
})
}
pub fn exact(name: &str, version: &Version) -> Dependency {
Dependency {
- name: name.to_strbuf(),
+ name: name.to_str(),
req: VersionReq::exact(version)
}
}
#[deriving(Eq,Clone,Encodable)]
pub struct SerializedDependency {
- name: StrBuf,
- req: StrBuf
+ name: String,
+ req: String
}
impl SerializedDependency {
pub fn from_dependency(dep: &Dependency) -> SerializedDependency {
SerializedDependency {
- name: dep.get_name().to_strbuf(),
- req: format_strbuf!("{}", dep.get_version_req())
+ name: dep.get_name().to_str(),
+ req: dep.get_version_req().to_str()
}
}
}
}
pub struct CLIError {
- pub msg: StrBuf,
- pub detail: Option<StrBuf>,
+ pub msg: String,
+ pub detail: Option<String>,
pub exit_code: uint
}
impl CLIError {
pub fn new<T: Show, U: Show>(msg: T, detail: Option<U>, exit_code: uint) -> CLIError {
- let detail = detail.map(|d| format_strbuf!("{}", d));
- CLIError { msg: format_strbuf!("{}", msg), detail: detail, exit_code: exit_code }
+ let detail = detail.map(|d| d.to_str());
+ CLIError { msg: msg.to_str(), detail: detail, exit_code: exit_code }
}
}
}
pub enum InternalError {
- StringConversionError(StrBuf, &'static str),
- MissingManifest(Path, StrBuf),
+ StringConversionError(String, &'static str),
+ MissingManifest(Path, String),
WrappedIoError(IoError),
- PathError(StrBuf),
- Described(StrBuf),
+ PathError(String),
+ Described(String),
Other
}
}
impl CargoError {
- pub fn cli(msg: StrBuf, detail: Option<StrBuf>, exit_code: uint) -> CargoError {
+ pub fn cli(msg: String, detail: Option<String>, exit_code: uint) -> CargoError {
CargoCLIError(CLIError::new(msg, detail, exit_code))
}
}
pub fn described<T: Show>(description: T) -> CargoError {
- CargoInternalError(Described(format_strbuf!("{}", description)))
+ CargoInternalError(Described(description.to_str()))
}
pub fn other() -> CargoError {
#[deriving(Eq,Clone)]
pub struct Manifest {
summary: Summary,
- authors: Vec<StrBuf>,
+ authors: Vec<String>,
targets: Vec<Target>,
target_dir: Path,
}
#[deriving(Eq,Clone,Encodable)]
pub struct SerializedManifest {
- name: StrBuf,
- version: StrBuf,
+ name: String,
+ version: String,
dependencies: Vec<SerializedDependency>,
- authors: Vec<StrBuf>,
+ authors: Vec<String>,
targets: Vec<Target>,
- target_dir: StrBuf
+ target_dir: String
}
impl<E, S: Encoder<E>> Encodable<S, E> for Manifest {
fn encode(&self, s: &mut S) -> Result<(), E> {
SerializedManifest {
- name: self.summary.get_name().to_strbuf(),
- version: format_strbuf!("{}", self.summary.get_version()),
+ name: self.summary.get_name().to_str(),
+ 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_strbuf()
+ target_dir: self.target_dir.display().to_str()
}.encode(s)
}
}
#[deriving(Clone,Eq)]
pub struct Target {
kind: TargetKind,
- name: StrBuf,
+ name: String,
path: Path
}
#[deriving(Encodable)]
pub struct SerializedTarget {
kind: &'static str,
- name: StrBuf,
- path: StrBuf
+ name: String,
+ path: String
}
impl<E, S: Encoder<E>> Encodable<S, E> for Target {
SerializedTarget {
kind: kind,
name: self.name.clone(),
- path: self.path.as_str().unwrap().to_strbuf()
+ path: self.path.display().to_str()
}.encode(s)
}
}
self.get_summary().get_name_ver().get_version()
}
- pub fn get_authors<'a>(&'a self) -> &'a [StrBuf] {
+ pub fn get_authors<'a>(&'a self) -> &'a [String] {
self.authors.as_slice()
}
pub fn lib_target(name: &str, path: &Path) -> Target {
Target {
kind: LibTarget,
- name: name.to_strbuf(),
+ name: name.to_str(),
path: path.clone()
}
}
pub fn bin_target(name: &str, path: &Path) -> Target {
Target {
kind: BinTarget,
- name: name.to_strbuf(),
+ name: name.to_str(),
path: path.clone()
}
}
#[deriving(Decodable,Encodable,Eq,Clone,Show)]
pub struct Project {
- pub name: StrBuf,
- pub version: StrBuf,
- pub authors: Vec<StrBuf>
+ pub name: String,
+ pub version: String,
+ pub authors: Vec<String>
}
/*
project: Box<Project>,
lib: Option<~[TomlLibTarget]>,
bin: Option<~[TomlExecTarget]>,
- dependencies: Option<HashMap<StrBuf, StrBuf>>
+ dependencies: Option<HashMap<String, String>>
}
impl TomlManifest {
#[deriving(Decodable,Encodable,Eq,Clone)]
struct TomlTarget {
- name: StrBuf,
- path: Option<StrBuf>
+ name: String,
+ path: Option<String>
}
fn normalize(lib: &Option<~[TomlLibTarget]>, bin: &Option<~[TomlExecTarget]>) -> Vec<Target> {
fn lib_targets(dst: &mut Vec<Target>, libs: &[TomlLibTarget]) {
let l = &libs[0];
- let path = l.path.clone().unwrap_or_else(|| format_strbuf!("src/{}.rs", l.name));
+ let path = l.path.clone().unwrap_or_else(|| format!("src/{}.rs", l.name));
dst.push(Target::lib_target(l.name.as_slice(), &Path::new(path)));
}
- fn bin_targets(dst: &mut Vec<Target>, bins: &[TomlExecTarget], default: |&TomlExecTarget| -> StrBuf) {
+ fn bin_targets(dst: &mut Vec<Target>, bins: &[TomlExecTarget], default: |&TomlExecTarget| -> String) {
for bin in bins.iter() {
let path = bin.path.clone().unwrap_or_else(|| default(bin));
dst.push(Target::bin_target(bin.name.as_slice(), &Path::new(path)));
match (lib, bin) {
(&Some(ref libs), &Some(ref bins)) => {
lib_targets(&mut ret, libs.as_slice());
- bin_targets(&mut ret, bins.as_slice(), |bin| format_strbuf!("src/bin/{}.rs", bin.name));
+ bin_targets(&mut ret, bins.as_slice(), |bin| format!("src/bin/{}.rs", bin.name));
},
(&Some(ref libs), &None) => {
lib_targets(&mut ret, libs.as_slice());
},
(&None, &Some(ref bins)) => {
- bin_targets(&mut ret, bins.as_slice(), |bin| format_strbuf!("src/{}.rs", bin.name));
+ bin_targets(&mut ret, bins.as_slice(), |bin| format!("src/{}.rs", bin.name));
},
(&None, &None) => ()
}
#[deriving(Clone,Eq,Ord)]
pub struct NameVer {
- name: StrBuf,
+ name: String,
version: semver::Version
}
impl NameVer {
pub fn new(name: &str, version: &str) -> NameVer {
- NameVer { name: name.to_strbuf(), version: semver::parse(version.to_owned()).unwrap() }
+ NameVer { name: name.to_str(), version: semver::parse(version.as_slice()).unwrap() }
}
pub fn get_name<'a>(&'a self) -> &'a str {
impl<E, D: Decoder<E>> Decodable<D,E> for NameVer {
fn decode(d: &mut D) -> Result<NameVer, E> {
- let vector: Vec<StrBuf> = try!(Decodable::decode(d));
+ 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(), format_strbuf!("{}", self.version))).encode(e)
+ (vec!(self.name.clone(), self.version.to_str())).encode(e)
}
}
#[deriving(Encodable)]
struct SerializedPackage {
- name: StrBuf,
- version: StrBuf,
+ name: String,
+ version: String,
dependencies: Vec<SerializedDependency>,
- authors: Vec<StrBuf>,
+ authors: Vec<String>,
targets: Vec<Target>,
- root: StrBuf
+ root: String
}
impl<E, S: Encoder<E>> Encodable<S, E> for Package {
let name_ver = summary.get_name_ver();
SerializedPackage {
- name: name_ver.get_name().to_strbuf(),
- version: format_strbuf!("{}", name_ver.get_version()),
+ name: name_ver.get_name().to_str(),
+ version: name_ver.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()),
- root: self.root.as_str().unwrap().to_strbuf()
+ root: self.root.display().to_str()
}.encode(s)
}
}
}
pub trait SummaryVec {
- fn names(&self) -> Vec<StrBuf>;
+ fn names(&self) -> Vec<String>;
fn deps(&self) -> Vec<Dependency>;
}
impl SummaryVec for Vec<Summary> {
- // TODO: Move to Registery
- fn names(&self) -> Vec<StrBuf> {
- self.iter().map(|summary| summary.name_ver.get_name().to_strbuf()).collect()
+ // TODO: Move to Registry
+ fn names(&self) -> Vec<String> {
+ self.iter().map(|summary| summary.name_ver.get_name().to_str()).collect()
}
// TODO: Delete
std::os::set_exit_status(exit_code as int);
}
-fn args() -> Vec<StrBuf> {
- std::os::args().iter().map(|a| a.to_strbuf()).collect()
+fn args() -> Vec<String> {
+ std::os::args()
}
fn flags_from_args<T: RepresentsFlags>() -> CLIResult<T> {
let mut reader = io::stdin();
let input = try!(reader.read_to_str().to_result(|_| CLIError::new("Standard in did not exist or was not UTF-8", None::<&str>, 1)));
- let json = try!(json::from_str(input).to_result(|_| CLIError::new("Could not parse standard in as JSON", Some(input.to_strbuf()), 1)));
+ let json = try!(json::from_str(input.as_slice()).to_result(|_| CLIError::new("Could not parse standard in as JSON", Some(input.clone()), 1)));
let mut decoder = json::Decoder::new(json);
Decodable::decode(&mut decoder).to_result(|e: json::DecoderError| CLIError::new("Could not process standard in as input", Some(e), 1))
let configs = try!(config::all_configs(os::getcwd()));
- let config_paths = configs.find(&"paths".to_strbuf()).map(|v| v.clone()).unwrap_or_else(|| ConfigValue::new());
+ let config_paths = configs.find_equiv(&"paths").map(|v| v.clone()).unwrap_or_else(|| ConfigValue::new());
let mut paths: Vec<Path> = match config_paths.get_value() {
&config::String(_) => return Err(other_error("The path was configured as a String instead of a List")),
pub fn read_manifest(path: &str) -> CargoResult<Package> {
let root = try!(parse_from_file(path).map_err(|err: CargoError|
- human_error("Cargo.toml is not valid Toml".to_strbuf(), format_strbuf!("path={}", path), err)));
+ human_error("Cargo.toml is not valid Toml".to_str(), format!("path={}", path), err)));
let toml = try!(load_toml(root).map_err(|err: CargoError|
- human_error("Cargo.toml is not a valid Cargo manifest".to_strbuf(), format_strbuf!("path={}", path), err)));
+ human_error("Cargo.toml is not a valid Cargo manifest".to_str(), format!("path={}", path), err)));
toml.to_package(path)
}
use util::{other_error,human_error,CargoResult,CargoError,ProcessBuilder};
use util::result::ProcessError;
-type Args = Vec<StrBuf>;
+type Args = Vec<String>;
pub fn compile_packages(pkgs: &core::PackageSet) -> CargoResult<()> {
let mut sorted = match pkgs.sort() {
}
fn build_base_args(into: &mut Args, target: &core::Target, dest: &Path) {
- into.push(target.get_path().as_str().unwrap().to_strbuf());
- into.push("--crate-type".to_strbuf());
- into.push(target.rustc_crate_type().to_strbuf());
- into.push("--out-dir".to_strbuf());
- into.push(dest.as_str().unwrap().to_strbuf());
+ // TODO: Handle errors in converting paths into args
+ into.push(target.get_path().display().to_str());
+ into.push("--crate-type".to_str());
+ into.push(target.rustc_crate_type().to_str());
+ into.push("--out-dir".to_str());
+ into.push(dest.display().to_str());
}
fn build_deps_args(dst: &mut Args, deps: &[core::Package]) {
for dep in deps.iter() {
let dir = dep.get_absolute_target_dir();
- dst.push("-L".to_strbuf());
- dst.push(dir.as_str().unwrap().to_strbuf());
+ dst.push("-L".to_str());
+ dst.push(dir.display().to_str());
}
}
-fn rustc_to_cargo_err(args: &[StrBuf], cwd: &Path, err: CargoError) -> CargoError {
+fn rustc_to_cargo_err(args: &[String], cwd: &Path, err: CargoError) -> CargoError {
let msg = {
let output = match err {
CargoError { kind: ProcessError(_, ref output), .. } => output,
_ => fail!("Bug! exec() returned an error other than a ProcessError")
};
- let mut msg = StrBuf::from_str(format!("failed to execute: `rustc {}`", args.connect(" ")));
- output.as_ref().map(|o| msg.push_str(format!("; Error:\n{}", str::from_utf8_lossy(o.error.as_slice()))));
+ let mut msg = format!("failed to execute: `rustc {}`", args.connect(" "));
+
+ output.as_ref().map(|o| {
+ let second = format!("; Error:\n{}", str::from_utf8_lossy(o.error.as_slice()));
+ msg.push_str(second.as_slice());
+ });
+
msg
};
- human_error(msg, format_strbuf!("root={}", cwd.display()), err)
+ human_error(msg, format!("root={}", cwd.display()), err)
}
+#![allow(dead_code)]
+
use url::Url;
use util::{CargoResult,ProcessBuilder,io_error,human_error,process};
use std::str;
macro_rules! git(
($config:expr, $str:expr, $($rest:expr),*) => (
- try!(git_inherit(&$config, format_strbuf!($str, $($rest),*)))
+ try!(git_inherit(&$config, format!($str, $($rest),*)))
);
($config:expr, $str:expr) => (
- try!(git_inherit(&$config, format_strbuf!($str)))
+ try!(git_inherit(&$config, format!($str)))
);
)
macro_rules! git_output(
($config:expr, $str:expr, $($rest:expr),*) => (
- try!(git_output(&$config, format_strbuf!($str, $($rest),*)))
+ try!(git_output(&$config, format!($str, $($rest),*)))
);
($config:expr, $str:expr) => (
- try!(git_output(&$config, format_strbuf!($str)))
+ try!(git_output(&$config, format!($str)))
);
)
struct GitConfig {
path: Path,
uri: Url,
- reference: StrBuf
+ reference: String
}
#[deriving(Eq,Clone,Encodable)]
struct EncodableGitConfig {
- path: StrBuf,
- uri: StrBuf,
- reference: StrBuf
+ path: String,
+ uri: String,
+ reference: String
}
impl<E, S: Encoder<E>> Encodable<S, E> for GitConfig {
fn encode(&self, s: &mut S) -> Result<(), E> {
EncodableGitConfig {
- path: format_strbuf!("{}", self.path.display()),
- uri: format_strbuf!("{}", self.uri),
+ path: self.path.display().to_str(),
+ uri: self.uri.to_str(),
reference: self.reference.clone()
}.encode(s)
}
#[deriving(Eq,Clone,Encodable)]
pub struct GitRepo {
config: GitConfig,
- revision: StrBuf
+ revision: String
}
impl GitCommand {
- pub fn new(path: Path, uri: Url, reference: StrBuf) -> GitCommand {
+ pub fn new(path: Path, uri: Url, reference: String) -> GitCommand {
GitCommand { config: GitConfig { path: path, uri: uri, reference: reference } }
}
checkout_config.path = dirname;
try!(mkdir_recursive(&checkout_config.path, UserDir).map_err(|err|
- human_error(format_strbuf!("Couldn't recursively create `{}`", checkout_config.path.display()), format_strbuf!("path={}", checkout_config.path.display()), io_error(err))));
+ human_error(format!("Couldn't recursively create `{}`", checkout_config.path.display()), format!("path={}", checkout_config.path.display()), io_error(err))));
git!(checkout_config, "clone {} {} --bare --no-hardlinks --quiet", config.uri, config.path.display());
}
}
impl GitRepo {
+ #[allow(unused_variable)]
fn copy_to(destination: &Path) -> CargoResult<()> {
Ok(())
}
}
}
-fn rev_for(config: &GitConfig) -> CargoResult<StrBuf> {
+fn rev_for(config: &GitConfig) -> CargoResult<String> {
Ok(git_output!(*config, "rev-parse {}", config.reference))
}
process("git").args(str.split(' ').collect::<Vec<&str>>().as_slice()).cwd(config.path.clone())
}
-fn git_inherit(config: &GitConfig, str: StrBuf) -> CargoResult<()> {
+fn git_inherit(config: &GitConfig, str: String) -> CargoResult<()> {
git(config, str.as_slice()).exec().map_err(|err|
- human_error(format_strbuf!("Couldn't execute `git {}`: {}", str, err), None::<&str>, err))
+ human_error(format!("Couldn't execute `git {}`: {}", str, err), None::<&str>, err))
}
-fn git_output(config: &GitConfig, str: StrBuf) -> CargoResult<StrBuf> {
+fn git_output(config: &GitConfig, str: String) -> CargoResult<String> {
let output = try!(git(config, str.as_slice()).exec_with_output().map_err(|err|
- human_error(format_strbuf!("Couldn't execute `git {}`", str), None::<&str>, err)));
+ human_error(format!("Couldn't execute `git {}`", str), None::<&str>, err)));
Ok(to_str(output.output.as_slice()))
}
-fn to_str(vec: &[u8]) -> StrBuf {
- format_strbuf!("{}", str::from_utf8_lossy(vec))
+fn to_str(vec: &[u8]) -> String {
+ str::from_utf8_lossy(vec).to_str()
}
#[deriving(Eq,TotalEq,Clone,Decodable)]
pub enum ConfigValueValue {
- String(StrBuf),
- List(Vec<StrBuf>)
+ String(String),
+ List(Vec<String>)
}
impl fmt::Show for ConfigValueValue {
impl fmt::Show for ConfigValue {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let paths: Vec<StrBuf> = self.path.iter().map(|p| format_strbuf!("{}", p.display())).collect();
+ let paths: Vec<String> = self.path.iter().map(|p| p.display().to_str()).collect();
write!(f, "{} (from {})", self.value, paths)
}
}
.map_err(|_| other_error("config key not found").with_detail(format!("key={}", key)))
}
-pub fn all_configs(pwd: Path) -> CargoResult<HashMap<StrBuf, ConfigValue>> {
+pub fn all_configs(pwd: Path) -> CargoResult<HashMap<String, ConfigValue>> {
let mut map = HashMap::new();
try!(walk_tree(&pwd, |file| {
}
#[allow(unused_variable)]
-pub fn set_config(key: StrBuf, value: StrBuf, location: Location) -> CargoResult<()> {
+pub fn set_config(key: String, value: String, location: Location) -> CargoResult<()> {
Ok(())
}
let v = match val {
&toml::String(ref val) => String(val.clone()),
- &toml::Array(ref val) => List(val.iter().map(|s: &toml::Value| format_strbuf!("{}", s)).collect()),
+ &toml::Array(ref val) => List(val.iter().map(|s: &toml::Value| s.to_str()).collect()),
_ => return Err(other_error(""))
};
Ok(ConfigValue{ value: v, path: vec!(path) })
}
-fn extract_all_configs(file: io::fs::File, map: &mut HashMap<StrBuf, ConfigValue>) -> CargoResult<()> {
+fn extract_all_configs(file: io::fs::File, map: &mut HashMap<String, ConfigValue>) -> CargoResult<()> {
let path = file.path().clone();
let mut buf = io::BufferedReader::new(file);
let root = try!(toml::parse_from_buffer(&mut buf).map_err(|err|
match existing.value {
String(_) => return Err(other_error("should be an Array, but it was a String")),
List(ref mut list) => {
- let new_list: Vec<CargoResult<StrBuf>> = val.iter().map(|s: &toml::Value| toml_string(s)).collect();
+ let new_list: Vec<CargoResult<String>> = val.iter().map(|s: &toml::Value| toml_string(s)).collect();
if new_list.iter().any(|v| v.is_err()) {
return Err(other_error("should be an Array of Strings, but was an Array of other values"));
} else {
- let new_list: Vec<StrBuf> = new_list.move_iter().map(|v| v.unwrap()).collect();
+ let new_list: Vec<String> = new_list.move_iter().map(|v| v.unwrap()).collect();
list.push_all(new_list.as_slice());
existing.path.push(path.clone());
Ok(())
}
}
-fn toml_string(val: &toml::Value) -> CargoResult<StrBuf> {
+fn toml_string(val: &toml::Value) -> CargoResult<String> {
match val {
&toml::String(ref str) => Ok(str.clone()),
_ => Err(other_error(""))
#[deriving(Clone,Eq)]
pub struct ProcessBuilder {
- program: StrBuf,
- args: Vec<StrBuf>,
- path: Vec<StrBuf>,
- env: HashMap<StrBuf, StrBuf>,
+ program: String,
+ args: Vec<String>,
+ path: Vec<String>,
+ env: HashMap<String, String>,
cwd: Path
}
impl ProcessBuilder {
pub fn args<T: Show>(mut self, arguments: &[T]) -> ProcessBuilder {
- self.args = arguments.iter().map(|a| format_strbuf!("{}", a)).collect();
+ self.args = arguments.iter().map(|a| a.to_str()).collect();
self
}
- pub fn get_args<'a>(&'a self) -> &'a [StrBuf] {
+ pub fn get_args<'a>(&'a self) -> &'a [String] {
self.args.as_slice()
}
pub fn extra_path(mut self, path: Path) -> ProcessBuilder {
// For now, just convert to a string, but we should do something better
- self.path.push(format_strbuf!("{}", path.display()));
+ self.path.push(path.display().to_str());
self
}
if exit.success() {
Ok(())
} else {
- let msg = format_strbuf!("Could not execute process `{}`", self.debug_string());
+ let msg = format!("Could not execute process `{}`", self.debug_string());
Err(process_error(msg, exit, None))
}
}
if output.status.success() {
Ok(output)
} else {
- let msg = format_strbuf!("Could not execute process `{}`", self.debug_string());
+ let msg = format!("Could not execute process `{}`", self.debug_string());
Err(process_error(msg, output.status.clone(), Some(output)))
}
}
command
}
- fn debug_string(&self) -> StrBuf {
- format_strbuf!("{} {}", self.program, self.args.connect(" "))
+ fn debug_string(&self) -> String {
+ format!("{} {}", self.program, self.args.connect(" "))
}
- fn build_env(&self) -> ~[(StrBuf, StrBuf)] {
+ fn build_env(&self) -> ~[(String, String)] {
let mut ret = Vec::new();
for (key, val) in self.env.iter() {
}
match self.build_path() {
- Some(path) => ret.push(("PATH".to_strbuf(), path)),
+ Some(path) => ret.push(("PATH".to_str(), path)),
_ => ()
}
ret.as_slice().to_owned()
}
- fn build_path(&self) -> Option<StrBuf> {
+ fn build_path(&self) -> Option<String> {
let path = self.path.connect(PATH_SEP);
match self.env.find_equiv(&("PATH")) {
if self.path.is_empty() {
Some(existing.clone())
} else {
- Some(format_strbuf!("{}{}{}", existing, PATH_SEP, path))
+ Some(format!("{}{}{}", existing, PATH_SEP, path))
}
},
None => {
if self.path.is_empty() {
None
} else {
- Some(path.to_strbuf())
+ Some(path)
}
}
}
pub fn process(cmd: &str) -> ProcessBuilder {
ProcessBuilder {
- program: cmd.to_strbuf(),
+ program: cmd.to_str(),
args: vec!(),
path: vec!(),
cwd: os::getcwd(),
}
}
-fn system_env() -> HashMap<StrBuf, StrBuf> {
+fn system_env() -> HashMap<String, String> {
let mut ret = HashMap::new();
for &(ref key, ref val) in os::env().iter() {
- ret.insert(key.to_strbuf(), val.to_strbuf());
+ ret.insert(key.to_str(), val.to_str());
}
ret
}
}
-pub fn process_error(detail: Str
Buf, exit: ProcessExit, output: Option<ProcessOutput>) -> CargoError {
+pub fn process_error(detail: Str
ing, exit: ProcessExit, output: Option<ProcessOutput>) -> CargoError {
CargoError {
kind: ProcessError(exit, output),
desc: BoxedDescription(detail),
pub fn human_error<T: ToStr, U: ToStr>(desc: T, detail: U, cause: CargoError) -> CargoError {
CargoError {
kind: HumanReadableError,
- desc: BoxedDescription(desc.to_str().to_strbuf()),
- detail: Some(detail.to_str().to_strbuf()),
+ desc: BoxedDescription(desc.to_str()),
+ detail: Some(detail.to_str()),
cause: Some(box cause)
}
}
pub fn simple_human<T: Show>(desc: T) -> CargoError {
CargoError {
kind: HumanReadableError,
- desc: BoxedDescription(format_strbuf!("{}", desc)),
+ desc: BoxedDescription(desc.to_str()),
detail: None,
cause: None
}
pub struct CargoError {
pub kind: CargoErrorKind,
desc: CargoErrorDescription,
- detail: Option<StrBuf>,
+ detail: Option<String>,
cause: Option<Box<CargoError>>
}
#[deriving(Show,Clone)]
enum CargoErrorDescription {
StaticDescription(&'static str),
- BoxedDescription(StrBuf)
+ BoxedDescription(String)
}
impl CargoError {
}
pub fn with_detail<T: Show>(mut self, detail: T) -> CargoError {
- self.detail = Some(format_strbuf!("{}", detail));
+ self.detail = Some(detail.to_str());
self
}
pub fn to_cli(self, exit_code: uint) -> CLIError {
match self {
CargoError { kind: HumanReadableError, desc: BoxedDescription(desc), detail: detail, .. } => {
- CLIError::new(desc, detail.map(|d| d.to_strbuf()), exit_code)
+ CLIError::new(desc, detail, exit_code)
},
CargoError { kind: InternalError, desc: StaticDescription(desc), detail: None, .. } => {
CLIError::new("An unexpected error occurred", Some(desc), exit_code)
},
CargoError { kind: InternalError, desc: StaticDescription(desc), detail: Some(detail), .. } => {
- CLIError::new("An unexpected error occurred", Some(format_strbuf!("{}\n{}", desc, detail)), exit_code)
+ CLIError::new("An unexpected error occurred", Some(format!("{}\n{}", desc, detail)), exit_code)
},
_ => {
CLIError::new("An unexpected error occurred", None::<&str>, exit_code)
kind: CargoCliErrorKind,
exit_status: uint,
desc: &'static str,
- detail: Option<StrBuf>,
+ detail: Option<String>,
cause: Option<CargoError>
}
projects / cargo.git / commitdiff