itsscb/cargo
1
0
Fork 0
mirror of https://github.com/rust-lang/cargo.git synced 2025-09-28 11:20:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

ToStr::to_str -> ToString::to_string

Browse Source 
Conflicts:
	src/cargo/core/resolver.rs
	src/cargo/ops/cargo_rustc.rs
This commit is contained in:
Michael Gehring 2014-07-09 15:38:10 +02:00 committed by Alex Crichton
parent 215ae2f9a1
commit 139e81ea82
27 changed files with 154 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/cargo-test.rs
View File

@ -64,7 +64,7 @@ fn execute(options: Options, shell: &mut MultiShell) -> CliResult<Option<()>> {
for file in walk {
// TODO: The proper fix is to have target knows its expected
// output and only run expected executables.
if file.display().to_str().as_slice().contains("dSYM") { continue; }
if file.display().to_string().as_slice().contains("dSYM") { continue; }
if !is_executable(&file) { continue; }
try!(util::process(file).exec().map_err(|e| {

2
src/bin/cargo-verify-project.rs
View File

@ -34,7 +34,7 @@ fn main() {
}
};
let file = Path::new(manifest);
let contents = match File::open(&file).read_to_str() {
let contents = match File::open(&file).read_to_string() {
Ok(s) => s,
Err(e) => return fail("invalid", format!("error reading file: {}",
e).as_slice())

4
src/bin/cargo.rs
View File

@ -81,7 +81,7 @@ fn execute() {
fn process(args: Vec<String>) -> (String, Vec<String>) {
let mut args = Vec::from_slice(args.tail());
let head = args.shift().unwrap_or("--help".to_str());
let head = args.shift().unwrap_or("--help".to_string());
(head, args)
}
@ -156,5 +156,5 @@ fn locate_project(_: NoFlags, _: &mut MultiShell) -> CliResult<Option<ProjectLoc
not representable in Unicode"))
.map_err(|e| CliError::from_boxed(e, 1)));
Ok(Some(ProjectLocation { root: string.to_str() }))
Ok(Some(ProjectLocation { root: string.to_string() }))
}

6
src/cargo/core/dependency.rs
View File

@ -19,7 +19,7 @@ impl Dependency {
};
Ok(Dependency {
name: name.to_str(),
name: name.to_string(),
namespace: namespace.clone(),
req: version,
transitive: true
@ -67,8 +67,8 @@ pub struct SerializedDependency {
impl SerializedDependency {
pub fn from_dependency(dep: &Dependency) -> SerializedDependency {
SerializedDependency {
name: dep.get_name().to_str(),
req: dep.get_version_req().to_str()
name: dep.get_name().to_string(),
req: dep.get_version_req().to_string()
}
}
}

6
src/cargo/core/errors.rs
View File

@ -32,8 +32,8 @@ pub struct CLIError {
impl CLIError {
pub fn new<T: Show, U: Show>(msg: T, detail: Option<U>,
exit_code: uint) -> CLIError {
let detail = detail.map(|d| d.to_str());
CLIError { msg: msg.to_str(), detail: detail, exit_code: exit_code }
let detail = detail.map(|d| d.to_string());
CLIError { msg: msg.to_string(), detail: detail, exit_code: exit_code }
}
}
@ -84,7 +84,7 @@ impl CargoError {
}
pub fn described<T: Show>(description: T) -> CargoError {
CargoInternalError(Described(description.to_str()))
CargoInternalError(Described(description.to_string()))
}
pub fn other() -> CargoError {

26
src/cargo/core/manifest.rs
View File

@ -47,14 +47,14 @@ pub struct SerializedManifest {
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_str(),
version: self.summary.get_version().to_str(),
name: self.summary.get_name().to_string(),
version: self.summary.get_version().to_string(),
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.display().to_str(),
target_dir: self.target_dir.display().to_string(),
build: if self.build.len() == 0 { None } else { Some(self.build.clone()) },
}.encode(s)
}
@ -112,7 +112,7 @@ pub struct Profile {
impl Profile {
pub fn default_dev() -> Profile {
Profile {
env: "compile".to_str(), // run in the default environment only
env: "compile".to_string(), // run in the default environment only
opt_level: 0,
debug: true,
test: false, // whether or not to pass --test
@ -122,31 +122,31 @@ impl Profile {
pub fn default_test() -> Profile {
Profile {
env: "test".to_str(), // run in the default environment only
env: "test".to_string(), // run in the default environment only
opt_level: 0,
debug: true,
test: true, // whether or not to pass --test
dest: Some("test".to_str())
dest: Some("test".to_string())
}
}
pub fn default_bench() -> Profile {
Profile {
env: "bench".to_str(), // run in the default environment only
env: "bench".to_string(), // run in the default environment only
opt_level: 3,
debug: false,
test: true, // whether or not to pass --test
dest: Some("bench".to_str())
dest: Some("bench".to_string())
}
}
pub fn default_release() -> Profile {
Profile {
env: "release".to_str(), // run in the default environment only
env: "release".to_string(), // run in the default environment only
opt_level: 3,
debug: false,
test: false, // whether or not to pass --test
dest: Some("release".to_str())
dest: Some("release".to_string())
}
}
@ -218,7 +218,7 @@ impl<E, S: Encoder<E>> Encodable<S, E> for Target {
SerializedTarget {
kind: kind,
name: self.name.clone(),
src_path: self.src_path.display().to_str(),
src_path: self.src_path.display().to_string(),
profile: self.profile.clone(),
metadata: self.metadata.clone()
}.encode(s)
@ -312,7 +312,7 @@ impl Target {
{
Target {
kind: LibTarget(crate_targets),
name: name.to_str(),
name: name.to_string(),
src_path: src_path.clone(),
profile: profile.clone(),
metadata: Some(metadata.clone())
@ -322,7 +322,7 @@ impl Target {
pub fn bin_target(name: &str, src_path: &Path, profile: &Profile) -> Target {
Target {
kind: BinTarget,
name: name.to_str(),
name: name.to_string(),
src_path: src_path.clone(),
profile: profile.clone(),
metadata: None

8
src/cargo/core/package.rs
View File

@ -45,14 +45,14 @@ impl<E, S: Encoder<E>> Encodable<S, E> for Package {
let package_id = summary.get_package_id();
SerializedPackage {
name: package_id.get_name().to_str(),
version: package_id.get_version().to_str(),
name: package_id.get_name().to_string(),
version: package_id.get_version().to_string(),
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()),
manifest_path: self.manifest_path.display().to_str()
manifest_path: self.manifest_path.display().to_string()
}.encode(s)
}
}
@ -123,7 +123,7 @@ impl Package {
// Sort the sources just to make sure we have a consistent fingerprint.
sources.sort_by(|a, b| {
cmp::lexical_ordering(a.kind.cmp(&b.kind),
a.location.to_str().cmp(&b.location.to_str()))
a.location.to_string().cmp(&b.location.to_string()))
});
let sources = sources.iter().map(|source_id| {
source_id.load(config)

8
src/cargo/core/package_id.rs
View File

@ -99,7 +99,7 @@ impl PackageId {
sid: &SourceId) -> CargoResult<PackageId> {
let v = try!(version.to_version().map_err(InvalidVersion));
Ok(PackageId {
name: name.to_str(),
name: name.to_string(),
version: v,
source_id: sid.clone()
})
@ -120,7 +120,7 @@ impl PackageId {
pub fn generate_metadata(&self) -> Metadata {
let metadata = format!("{}:-:{}:-:{}", self.name, self.version, self.source_id);
let extra_filename = short_hash(
&(self.name.as_slice(), self.version.to_str(), &self.source_id));
&(self.name.as_slice(), self.version.to_string(), &self.source_id));
Metadata { metadata: metadata, extra_filename: format!("-{}", extra_filename) }
}
@ -132,7 +132,7 @@ impl Show for PackageId {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
try!(write!(f, "{} v{}", self.name, self.version));
if self.source_id.to_str().as_slice() != central_repo {
if self.source_id.to_string().as_slice() != central_repo {
try!(write!(f, " ({})", self.source_id));
}
@ -153,7 +153,7 @@ impl<D: Decoder<Box<CargoError + Send>>>
impl<E, S: Encoder<E>> Encodable<S,E> for PackageId {
fn encode(&self, e: &mut S) -> Result<(), E> {
(self.name.clone(), self.version.to_str(), self.source_id.clone()).encode(e)
(self.name.clone(), self.version.to_string(), self.source_id.clone()).encode(e)
}
}

6
src/cargo/core/resolver.rs
View File

@ -82,7 +82,7 @@ fn resolve_deps<'a, R: Registry>(parent: &PackageId,
}
let summary = pkgs.get(0).clone();
let name = summary.get_name().to_str();
let name = summary.get_name().to_string();
let source_id = summary.get_source_id().clone();
let version = summary.get_version().clone();
@ -179,7 +179,7 @@ mod test {
fn pkg_id_loc(name: &str, loc: &str) -> PackageId {
let remote = Location::parse(loc);
let source_id = SourceId::new(GitKind("master".to_str()),
let source_id = SourceId::new(GitKind("master".to_string()),
remote.unwrap());
PackageId::new(name, "1.0.0", &source_id).unwrap()
@ -197,7 +197,7 @@ mod test {
fn dep_loc(name: &str, location: &str) -> Dependency {
let url = from_str(location).unwrap();
let source_id = SourceId::new(GitKind("master".to_str()), Remote(url));
let source_id = SourceId::new(GitKind("master".to_string()), Remote(url));
Dependency::parse(name, Some("1.0.0"), &source_id).unwrap()
}

10
src/cargo/core/shell.rs
View File

@ -42,7 +42,7 @@ impl MultiShell {
&mut self.err
}
pub fn say<T: ToStr>(&mut self, message: T, color: Color) -> IoResult<()> {
pub fn say<T: ToString>(&mut self, message: T, color: Color) -> IoResult<()> {
self.out().say(message, color)
}
@ -60,11 +60,11 @@ impl MultiShell {
Ok(())
}
pub fn error<T: ToStr>(&mut self, message: T) -> IoResult<()> {
pub fn error<T: ToString>(&mut self, message: T) -> IoResult<()> {
self.err().say(message, RED)
}
pub fn warn<T: ToStr>(&mut self, message: T) -> IoResult<()> {
pub fn warn<T: ToString>(&mut self, message: T) -> IoResult<()> {
self.err().say(message, YELLOW)
}
}
@ -96,10 +96,10 @@ impl Shell {
Ok(())
}
pub fn say<T: ToStr>(&mut self, message: T, color: Color) -> IoResult<()> {
pub fn say<T: ToString>(&mut self, message: T, color: Color) -> IoResult<()> {
try!(self.reset());
if color != BLACK { try!(self.fg(color)); }
try!(self.write_line(message.to_str().as_slice()));
try!(self.write_line(message.to_string().as_slice()));
try!(self.reset());
try!(self.flush());
Ok(())

8
src/cargo/core/source.rs
View File

@ -73,7 +73,7 @@ impl<E, D: Decoder<E>> Decodable<D, E> for Location {
impl<E, S: Encoder<E>> Encodable<S, E> for Location {
fn encode(&self, e: &mut S) -> Result<(), E> {
self.to_str().encode(e)
self.to_string().encode(e)
}
}
@ -137,8 +137,8 @@ impl PartialEq for SourceId {
match (&self.kind, &other.kind, &self.location, &other.location) {
(&GitKind(..), &GitKind(..),
&Remote(ref u1), &Remote(ref u2)) => {
git::canonicalize_url(u1.to_str().as_slice()) ==
git::canonicalize_url(u2.to_str().as_slice())
git::canonicalize_url(u1.to_string().as_slice()) ==
git::canonicalize_url(u2.to_string().as_slice())
}
_ => false,
}
@ -156,7 +156,7 @@ impl SourceId {
}
pub fn for_git(url: &Url, reference: &str) -> SourceId {
SourceId::new(GitKind(reference.to_str()), Remote(url.clone()))
SourceId::new(GitKind(reference.to_string()), Remote(url.clone()))
}
pub fn for_central() -> SourceId {

2
src/cargo/core/summary.rs
View File

@ -48,7 +48,7 @@ pub trait SummaryVec {
impl SummaryVec for Vec<Summary> {
// TODO: Move to Registry
fn names(&self) -> Vec<String> {
self.iter().map(|summary| summary.get_name().to_str()).collect()
self.iter().map(|summary| summary.get_name().to_string()).collect()
}
}

6
src/cargo/core/version_req.rs
View File

@ -487,14 +487,14 @@ mod test {
pub fn test_parsing_exact() {
let r = req("1.0.0");
assert!(r.to_str() == "= 1.0.0".to_str());
assert!(r.to_string() == "= 1.0.0".to_string());
assert_match(&r, ["1.0.0"]);
assert_not_match(&r, ["1.0.1", "0.9.9", "0.10.0", "0.1.0"]);
let r = req("0.9.0");
assert!(r.to_str() == "= 0.9.0".to_str());
assert!(r.to_string() == "= 0.9.0".to_string());
assert_match(&r, ["0.9.0"]);
assert_not_match(&r, ["0.9.1", "1.9.0", "0.0.9"]);
@ -504,7 +504,7 @@ mod test {
pub fn test_parsing_greater_than() {
let r = req(">= 1.0.0");
assert!(r.to_str() == ">= 1.0.0".to_str());
assert!(r.to_string() == ">= 1.0.0".to_string());
assert_match(&r, ["1.0.0"]);
}

4
src/cargo/lib.rs
View File

@ -206,7 +206,7 @@ pub fn handle_error(err: CliError, shell: &mut MultiShell) {
if unknown {
let _ = shell.error("An unknown error occurred");
} else {
let _ = shell.error(error.to_str());
let _ = shell.error(error.to_string());
}
if error.cause().is_some() {
@ -248,7 +248,7 @@ fn global_flags() -> CliResult<GlobalFlags> {
fn json_from_stdin<T: RepresentsJSON>() -> CliResult<T> {
let mut reader = io::stdin();
let input = try!(reader.read_to_str().map_err(|_| {
let input = try!(reader.read_to_string().map_err(|_| {
CliError::new("Standard in did not exist or was not UTF-8", 1)
}));

52
src/cargo/ops/cargo_rustc.rs
View File

@ -80,7 +80,7 @@ pub fn compile_targets<'a>(env: &str, targets: &[&Target], pkg: &Package,
try!(File::create(&file));
let output = try!(util::process("rustc")
.arg(file.display().to_str())
.arg(file.display().to_string())
.arg("--crate-name").arg("-")
.arg("--crate-type").arg("dylib")
.arg("--print-file-name")
@ -99,7 +99,7 @@ pub fn compile_targets<'a>(env: &str, targets: &[&Target], pkg: &Package,
resolve: resolve,
package_set: deps,
config: config,
dylib: (parts.get(0).to_str(), parts.get(1).to_str())
dylib: (parts.get(0).to_string(), parts.get(1).to_string())
};
// Build up a list of pending jobs, each of which represent compiling a
@ -196,7 +196,7 @@ fn is_fresh(dep: &Package, loc: &Path,
Err(..) => return Ok((false, new_fingerprint)),
};
let old_fingerprint = try!(file.read_to_str());
let old_fingerprint = try!(file.read_to_string());
log!(5, "old fingerprint: {}", old_fingerprint);
log!(5, "new fingerprint: {}", new_fingerprint);
@ -247,16 +247,16 @@ fn rustc(package: &Package, target: &Target, cx: &mut Context) -> Job {
log!(5, "command={}", rustc);
let _ = cx.config.shell().verbose(|shell| shell.status("Running", rustc.to_str()));
let _ = cx.config.shell().verbose(|shell| shell.status("Running", rustc.to_string()));
proc() {
if primary {
log!(5, "executing primary");
rustc.exec().map_err(|err| human(err.to_str()))
rustc.exec().map_err(|err| human(err.to_string()))
} else {
log!(5, "executing deps");
rustc.exec_with_output().and(Ok(())).map_err(|err| {
human(err.to_str())
human(err.to_string())
})
}
}
@ -285,61 +285,61 @@ fn build_base_args(into: &mut Args,
let metadata = target.get_metadata();
// TODO: Handle errors in converting paths into args
into.push(target.get_src_path().display().to_str());
into.push(target.get_src_path().display().to_string());
into.push("--crate-name".to_str());
into.push(target.get_name().to_str());
into.push("--crate-name".to_string());
into.push(target.get_name().to_string());
for crate_type in crate_types.iter() {
into.push("--crate-type".to_str());
into.push(crate_type.to_str());
into.push("--crate-type".to_string());
into.push(crate_type.to_string());
}
let out = cx.dest.clone();
let profile = target.get_profile();
if profile.get_opt_level() != 0 {
into.push("--opt-level".to_str());
into.push(profile.get_opt_level().to_str());
into.push("--opt-level".to_string());
into.push(profile.get_opt_level().to_string());
}
// Right now -g is a little buggy, so we're not passing -g just yet
// if profile.get_debug() {
// into.push("-g".to_str());
// into.push("-g".to_string());
// }
if profile.is_test() {
into.push("--test".to_str());
into.push("--test".to_string());
}
match metadata {
Some(m) => {
into.push("-C".to_str());
into.push("-C".to_string());
into.push(format!("metadata={}", m.metadata));
into.push("-C".to_str());
into.push("-C".to_string());
into.push(format!("extra-filename={}", m.extra_filename));
}
None => {}
}
if target.is_lib() {
into.push("--out-dir".to_str());
into.push(out.display().to_str());
into.push("--out-dir".to_string());
into.push(out.display().to_string());
} else {
into.push("-o".to_str());
into.push(out.join(target.get_name()).display().to_str());
into.push("-o".to_string());
into.push(out.join(target.get_name()).display().to_string());
}
}
fn build_deps_args(dst: &mut Args, package: &Package, cx: &Context) {
dst.push("-L".to_str());
dst.push(cx.dest.display().to_str());
dst.push("-L".to_str());
dst.push(cx.deps_dir.display().to_str());
dst.push("-L".to_string());
dst.push(cx.dest.display().to_string());
dst.push("-L".to_string());
dst.push(cx.deps_dir.display().to_string());
for target in dep_targets(package, cx).iter() {
dst.push("--extern".to_str());
dst.push("--extern".to_string());
dst.push(format!("{}={}/{}",
target.get_name(),
cx.deps_dir.display(),

6
src/cargo/sources/git/source.rs
View File

@ -65,11 +65,11 @@ fn ident(location: &Location) -> String {
let ident = match *location {
Local(ref path) => {
let last = path.components().last().unwrap();
str::from_utf8(last).unwrap().to_str()
str::from_utf8(last).unwrap().to_string()
}
Remote(ref url) => {
let path = canonicalize_url(url.path.path.as_slice());
path.as_slice().split('/').last().unwrap().to_str()
path.as_slice().split('/').last().unwrap().to_string()
}
};
@ -79,7 +79,7 @@ fn ident(location: &Location) -> String {
ident
};
let location = canonicalize_url(location.to_str().as_slice());
let location = canonicalize_url(location.to_string().as_slice());
format!("{}-{}", ident, to_hex(hasher.hash(&location.as_slice())))
}

20
src/cargo/sources/git/utils.rs
View File

@ -19,7 +19,7 @@ impl GitReference {
if string.as_slice() == "master" {
Master
} else {
Other(string.as_slice().to_str())
Other(string.as_slice().to_string())
}
}
}
@ -79,7 +79,7 @@ struct EncodableGitRemote {
impl<E, S: Encoder<E>> Encodable<S, E> for GitRemote {
fn encode(&self, s: &mut S) -> Result<(), E> {
EncodableGitRemote {
location: self.location.to_str()
location: self.location.to_string()
}.encode(s)
}
}
@ -102,7 +102,7 @@ impl<E, S: Encoder<E>> Encodable<S, E> for GitDatabase {
fn encode(&self, s: &mut S) -> Result<(), E> {
EncodableGitDatabase {
remote: self.remote.clone(),
path: self.path.display().to_str()
path: self.path.display().to_string()
}.encode(s)
}
}
@ -129,9 +129,9 @@ impl<E, S: Encoder<E>> Encodable<S, E> for GitCheckout {
fn encode(&self, s: &mut S) -> Result<(), E> {
EncodableGitCheckout {
database: self.database.clone(),
location: self.location.display().to_str(),
reference: self.reference.to_str(),
revision: self.revision.to_str()
location: self.location.display().to_string(),
reference: self.reference.to_string(),
revision: self.revision.to_string()
}.encode(s)
}
}
@ -182,8 +182,8 @@ impl GitRemote {
fn fetch_location(&self) -> String {
match self.location {
Local(ref p) => p.display().to_str(),
Remote(ref u) => u.to_str(),
Local(ref p) => p.display().to_string(),
Remote(ref u) => u.to_string(),
}
}
}
@ -308,10 +308,10 @@ fn git_output(path: &Path, str: String) -> CargoResult<String> {
.chain_error(||
human(format!("Executing `git {}` failed", str))));
Ok(to_str(output.output.as_slice()).as_slice().trim_right().to_str())
Ok(to_str(output.output.as_slice()).as_slice().trim_right().to_string())
}
fn to_str(vec: &[u8]) -> String {
str::from_utf8_lossy(vec).to_str()
str::from_utf8_lossy(vec).to_string()
}

2
src/cargo/sources/path.rs
View File

@ -102,7 +102,7 @@ impl Source for PathSource {
let loc = pkg.get_manifest_path().dir_path();
max = cmp::max(max, try!(walk(&loc, true)));
}
return Ok(max.to_str());
return Ok(max.to_string());
fn walk(path: &Path, is_root: bool) -> CargoResult<u64> {
if !path.is_dir() {

12
src/cargo/util/config.rs
View File

@ -118,7 +118,7 @@ impl<E, S: Encoder<E>> Encodable<S, E> for ConfigValue {
impl fmt::Show for ConfigValue {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let paths: Vec<String> = self.path.iter().map(|p| {
p.display().to_str()
p.display().to_string()
}).collect();
write!(f, "{} (from {})", self.value, paths)
}
@ -184,16 +184,16 @@ fn walk_tree(pwd: &Path,
}
fn extract_config(mut file: io::fs::File, key: &str) -> CargoResult<ConfigValue> {
let contents = try!(file.read_to_str());
let contents = try!(file.read_to_string());
let toml = try!(cargo_toml::parse(contents.as_slice(),
file.path().filename_display()
.to_str().as_slice()));
.to_string().as_slice()));
let val = try!(toml.find_equiv(&key).require(|| internal("")));
let v = match *val {
toml::String(ref val) => String(val.clone()),
toml::Array(ref val) => {
List(val.iter().map(|s: &toml::Value| s.to_str()).collect())
List(val.iter().map(|s: &toml::Value| s.to_string()).collect())
}
_ => return Err(internal(""))
};
@ -204,8 +204,8 @@ fn extract_config(mut file: io::fs::File, key: &str) -> CargoResult<ConfigValue>
fn extract_all_configs(mut file: io::fs::File,
map: &mut HashMap<String, ConfigValue>) -> CargoResult<()> {
let path = file.path().clone();
let contents = try!(file.read_to_str());
let file = path.filename_display().to_str();
let contents = try!(file.read_to_string());
let file = path.filename_display().to_string();
let table = try!(cargo_toml::parse(contents.as_slice(),
file.as_slice()).chain_error(|| {
internal(format!("could not parse Toml manifest; path={}",

14
src/cargo/util/dependency_queue.rs
View File

@ -61,7 +61,7 @@ impl<T> DependencyQueue<T> {
///
/// Only registered packages will be returned from dequeue().
pub fn register(&mut self, pkg: &Package) {
self.reverse_dep_map.insert(pkg.get_name().to_str(), HashSet::new());
self.reverse_dep_map.insert(pkg.get_name().to_string(), HashSet::new());
}
/// Adds a new package to this dependency queue.
@ -70,10 +70,10 @@ impl<T> DependencyQueue<T> {
/// be added to the dependency queue.
pub fn enqueue(&mut self, pkg: &Package, fresh: Freshness, data: T) {
// ignore self-deps
if self.pkgs.contains_key(&pkg.get_name().to_str()) { return }
if self.pkgs.contains_key(&pkg.get_name().to_string()) { return }
if fresh == Dirty {
self.dirty.insert(pkg.get_name().to_str());
self.dirty.insert(pkg.get_name().to_string());
}
let mut my_dependencies = HashSet::new();
@ -84,12 +84,12 @@ impl<T> DependencyQueue<T> {
continue
}
let name = dep.get_name().to_str();
let name = dep.get_name().to_string();
assert!(my_dependencies.insert(name.clone()));
let rev = self.reverse_dep_map.find_or_insert(name, HashSet::new());
assert!(rev.insert(pkg.get_name().to_str()));
assert!(rev.insert(pkg.get_name().to_string()));
}
assert!(self.pkgs.insert(pkg.get_name().to_str(),
assert!(self.pkgs.insert(pkg.get_name().to_string(),
(my_dependencies, data)));
}
@ -100,7 +100,7 @@ impl<T> DependencyQueue<T> {
pub fn dequeue(&mut self) -> Option<(String, Freshness, T)> {
let pkg = match self.pkgs.iter()
.find(|&(_, &(ref deps, _))| deps.len() == 0)
.map(|(ref name, _)| name.to_str()) {
.map(|(ref name, _)| name.to_string()) {
Some(pkg) => pkg,
None => return None
};

26
src/cargo/util/errors.rs
View File

@ -120,20 +120,20 @@ impl<T, E: CargoError + Send> ChainError<T> for Result<T, E> {
}
impl CargoError for IoError {
fn description(&self) -> String { self.to_str() }
fn description(&self) -> String { self.to_string() }
}
from_error!(IoError)
impl CargoError for TomlError {
fn description(&self) -> String { self.to_str() }
fn description(&self) -> String { self.to_string() }
}
from_error!(TomlError)
impl CargoError for FormatError {
fn description(&self) -> String {
"formatting failed".to_str()
"formatting failed".to_string()
}
}
@ -152,8 +152,8 @@ from_error!(ProcessError)
impl Show for ProcessError {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
let exit = match self.exit {
Some(ExitStatus(i)) | Some(ExitSignal(i)) => i.to_str(),
None => "never executed".to_str()
Some(ExitStatus(i)) | Some(ExitSignal(i)) => i.to_string(),
None => "never executed".to_string()
};
try!(write!(f, "{} (status={})", self.msg, exit));
match self.output {
@ -178,7 +178,7 @@ impl Show for ProcessError {
}
impl CargoError for ProcessError {
fn description(&self) -> String { self.to_str() }
fn description(&self) -> String { self.to_string() }
fn detail(&self) -> Option<String> {
self.detail.clone()
@ -248,7 +248,7 @@ pub struct CliError {
impl CargoError for CliError {
fn description(&self) -> String {
self.error.to_str()
self.error.to_string()
}
}
@ -256,7 +256,7 @@ from_error!(CliError)
impl CliError {
pub fn new<S: Str>(error: S, code: uint) -> CliError {
let error = human(error.as_slice().to_str());
let error = human(error.as_slice().to_string());
CliError::from_boxed(error, code)
}
@ -276,7 +276,7 @@ pub fn process_error<S: Str>(msg: S,
status: Option<&ProcessExit>,
output: Option<&ProcessOutput>) -> ProcessError {
ProcessError {
msg: msg.as_slice().to_str(),
msg: msg.as_slice().to_string(),
exit: status.map(|o| o.clone()),
output: output.map(|o| o.clone()),
detail: None,
@ -287,8 +287,8 @@ pub fn process_error<S: Str>(msg: S,
pub fn internal_error<S1: Str, S2: Str>(error: S1,
detail: S2) -> Box<CargoError + Send> {
box ConcreteCargoError {
description: error.as_slice().to_str(),
detail: Some(detail.as_slice().to_str()),
description: error.as_slice().to_string(),
detail: Some(detail.as_slice().to_string()),
cause: None,
is_human: false
} as Box<CargoError + Send>
@ -296,7 +296,7 @@ pub fn internal_error<S1: Str, S2: Str>(error: S1,
pub fn internal<S: Show>(error: S) -> Box<CargoError + Send> {
box ConcreteCargoError {
description: error.to_str(),
description: error.to_string(),
detail: None,
cause: None,
is_human: false
@ -305,7 +305,7 @@ pub fn internal<S: Show>(error: S) -> Box<CargoError + Send> {
pub fn human<S: Show>(error: S) -> Box<CargoError + Send> {
box ConcreteCargoError {
description: error.to_str(),
description: error.to_string(),
detail: None,
cause: None,
is_human: true

12
src/cargo/util/process_builder.rs
View File

@ -36,12 +36,12 @@ static PATH_SEP : &'static str = ";";
impl ProcessBuilder {
pub fn arg<T: Str>(mut self, arg: T) -> ProcessBuilder {
self.args.push(arg.as_slice().to_str());
self.args.push(arg.as_slice().to_string());
self
}
pub fn args<T: Str>(mut self, arguments: &[T]) -> ProcessBuilder {
self.args = arguments.iter().map(|a| a.as_slice().to_str()).collect();
self.args = arguments.iter().map(|a| a.as_slice().to_string()).collect();
self
}
@ -51,7 +51,7 @@ impl ProcessBuilder {
pub fn extra_path(mut self, path: Path) -> ProcessBuilder {
// For now, just convert to a string, but we should do something better
self.path.unshift(path.display().to_str());
self.path.unshift(path.display().to_string());
self
}
@ -63,10 +63,10 @@ impl ProcessBuilder {
pub fn env(mut self, key: &str, val: Option<&str>) -> ProcessBuilder {
match val {
Some(v) => {
self.env.insert(key.to_str(), v.to_str());
self.env.insert(key.to_string(), v.to_string());
},
None => {
self.env.remove(&key.to_str());
self.env.remove(&key.to_string());
}
}
@ -139,7 +139,7 @@ impl ProcessBuilder {
}
match self.build_path() {
Some(path) => ret.push(("PATH".to_str(), path)),
Some(path) => ret.push(("PATH".to_string(), path)),
_ => ()
}

16
src/cargo/util/toml.rs
View File

@ -198,9 +198,9 @@ struct Context<'a> {
fn inferred_lib_target(name: &str, layout: &Layout) -> Option<Vec<TomlTarget>> {
layout.lib.as_ref().map(|lib| {
vec![TomlTarget {
name: name.to_str(),
name: name.to_string(),
crate_type: None,
path: Some(lib.display().to_str()),
path: Some(lib.display().to_string()),
test: None
}]
})
@ -209,16 +209,16 @@ fn inferred_lib_target(name: &str, layout: &Layout) -> Option<Vec<TomlTarget>> {
fn inferred_bin_targets(name: &str, layout: &Layout) -> Option<Vec<TomlTarget>> {
Some(layout.bins.iter().filter_map(|bin| {
let name = if bin.as_str() == Some("src/main.rs") {
Some(name.to_str())
Some(name.to_string())
} else {
bin.filestem_str().map(|f| f.to_str())
bin.filestem_str().map(|f| f.to_string())
};
name.map(|name| {
TomlTarget {
name: name,
crate_type: None,
path: Some(bin.display().to_str()),
path: Some(bin.display().to_string()),
test: None
}
})
@ -252,7 +252,7 @@ impl TomlManifest {
TomlTarget {
name: t.name.clone(),
crate_type: t.crate_type.clone(),
path: layout.lib.as_ref().map(|p| p.display().to_str()),
path: layout.lib.as_ref().map(|p| p.display().to_string()),
test: t.test
}
} else {
@ -271,7 +271,7 @@ impl TomlManifest {
TomlTarget {
name: t.name.clone(),
crate_type: t.crate_type.clone(),
path: bin.as_ref().map(|p| p.display().to_str()),
path: bin.as_ref().map(|p| p.display().to_string()),
test: t.test
}
} else {
@ -336,7 +336,7 @@ fn process_dependencies<'a>(cx: &mut Context<'a>, dev: bool,
let reference = details.branch.clone()
.or_else(|| details.tag.clone())
.or_else(|| details.rev.clone())
.unwrap_or_else(|| "master".to_str());
.unwrap_or_else(|| "master".to_string());
let new_source_id = match details.git {
Some(ref git) => {

24
tests/support/mod.rs
View File

@ -30,7 +30,7 @@ struct FileBuilder {
impl FileBuilder {
pub fn new(path: Path, body: &str) -> FileBuilder {
FileBuilder { path: path, body: body.to_str() }
FileBuilder { path: path, body: body.to_string() }
}
fn mk(&self) -> Result<(), String> {
@ -86,7 +86,7 @@ pub struct ProjectBuilder {
impl ProjectBuilder {
pub fn new(name: &str, root: Path) -> ProjectBuilder {
ProjectBuilder {
name: name.to_str(),
name: name.to_string(),
root: root,
files: vec!(),
symlinks: vec!()
@ -108,7 +108,7 @@ impl ProjectBuilder {
pub fn process<T: ToCStr>(&self, program: T) -> ProcessBuilder {
process(program)
.cwd(self.root())
.env("HOME", Some(paths::home().display().to_str().as_slice()))
.env("HOME", Some(paths::home().display().to_string().as_slice()))
.extra_path(cargo_dir())
}
@ -195,7 +195,7 @@ pub fn main_file<T: Str>(println: T, deps: &[&str]) -> String {
buf.push_str(println.as_slice());
buf.push_str("); }\n");
buf.to_str()
buf.to_string()
}
trait ErrMsg<T> {
@ -238,13 +238,13 @@ struct Execs {
impl Execs {
pub fn with_stdout<S: ToStr>(mut ~self, expected: S) -> Box<Execs> {
self.expect_stdout = Some(expected.to_str());
pub fn with_stdout<S: ToString>(mut ~self, expected: S) -> Box<Execs> {
self.expect_stdout = Some(expected.to_string());
self
}
pub fn with_stderr<S: ToStr>(mut ~self, expected: S) -> Box<Execs> {
self.expect_stderr = Some(expected.to_str());
pub fn with_stderr<S: ToString>(mut ~self, expected: S) -> Box<Execs> {
self.expect_stderr = Some(expected.to_string());
self
}
@ -310,7 +310,7 @@ impl Execs {
impl ham::SelfDescribing for Execs {
fn describe(&self) -> String {
"execs".to_str()
"execs".to_string()
}
}
@ -354,13 +354,13 @@ impl<'a> ham::Matcher<&'a [u8]> for ShellWrites {
{
println!("{}", actual);
let actual = std::str::from_utf8_lossy(actual);
let actual = actual.to_str();
let actual = actual.to_string();
ham::expect(actual == self.expected, actual)
}
}
pub fn shell_writes<T: Show>(string: T) -> Box<ShellWrites> {
box ShellWrites { expected: string.to_str() }
box ShellWrites { expected: string.to_string() }
}
pub trait ResultTest<T,E> {
@ -397,7 +397,7 @@ impl<T> Tap for T {
}
pub fn escape_path(p: &Path) -> String {
p.display().to_str().as_slice().replace("\\", "\\\\")
p.display().to_string().as_slice().replace("\\", "\\\\")
}
pub fn basic_bin_manifest(name: &str) -> String {

22
tests/test_cargo_compile.rs
View File

@ -153,7 +153,7 @@ test!(cargo_compile_with_warnings_in_a_dep_package {
"#)
.file("bar/src/bar.rs", r#"
pub fn gimme() -> String {
"test passed".to_str()
"test passed".to_string()
}
fn dead() {}
@ -230,7 +230,7 @@ test!(cargo_compile_with_nested_deps_inferred {
"#)
.file("baz/src/lib.rs", r#"
pub fn gimme() -> String {
"test passed".to_str()
"test passed".to_string()
}
"#);
@ -298,7 +298,7 @@ test!(cargo_compile_with_nested_deps_correct_bin {
"#)
.file("baz/src/lib.rs", r#"
pub fn gimme() -> String {
"test passed".to_str()
"test passed".to_string()
}
"#);
@ -374,7 +374,7 @@ test!(cargo_compile_with_nested_deps_shorthand {
"#)
.file("baz/src/baz.rs", r#"
pub fn gimme() -> String {
"test passed".to_str()
"test passed".to_string()
}
"#);
@ -450,7 +450,7 @@ test!(cargo_compile_with_nested_deps_longhand {
"#)
.file("baz/src/baz.rs", r#"
pub fn gimme() -> String {
"test passed".to_str()
"test passed".to_string()
}
"#);
@ -692,8 +692,8 @@ test!(custom_build_env_vars {
.file("src/foo.rs", format!(r#"
use std::os;
fn main() {{
assert_eq!(os::getenv("OUT_DIR").unwrap(), "{}".to_str());
assert_eq!(os::getenv("DEPS_DIR").unwrap(), "{}".to_str());
assert_eq!(os::getenv("OUT_DIR").unwrap(), "{}".to_string());
assert_eq!(os::getenv("DEPS_DIR").unwrap(), "{}".to_string());
}}
"#,
escape_path(&p.root().join("target")),
@ -737,8 +737,8 @@ test!(custom_build_in_dependency {
.file("src/foo.rs", format!(r#"
use std::os;
fn main() {{
assert_eq!(os::getenv("OUT_DIR").unwrap(), "{}".to_str());
assert_eq!(os::getenv("DEPS_DIR").unwrap(), "{}".to_str());
assert_eq!(os::getenv("OUT_DIR").unwrap(), "{}".to_string());
assert_eq!(os::getenv("DEPS_DIR").unwrap(), "{}".to_string());
}}
"#,
escape_path(&p.root().join("target/deps")),
@ -808,7 +808,7 @@ test!(many_crate_types_old_style_lib_location {
match f.filename_str().unwrap() {
"deps" => None,
s if s.contains("fingerprint") || s.contains("dSYM") => None,
s => Some(s.to_str())
s => Some(s.to_string())
}
}).collect();
files.sort();
@ -846,7 +846,7 @@ test!(many_crate_types_correct {
match f.filename_str().unwrap() {
"deps" => None,
s if s.contains("fingerprint") || s.contains("dSYM") => None,
s => Some(s.to_str())
s => Some(s.to_string())
}
}).collect();
files.sort();

2
tests/test_cargo_compile_path_deps.rs
View File

@ -66,7 +66,7 @@ test!(cargo_compile_with_nested_deps_shorthand {
"#)
.file("bar/baz/src/baz.rs", r#"
pub fn gimme() -> String {
"test passed".to_str()
"test passed".to_string()
}
"#);

2
tests/test_shell.rs
View File

@ -56,5 +56,5 @@ fn colored_output<S: Str>(string: S, color: color::Color) -> IoResult<String> {
try!(term.write_str(string.as_slice()));
try!(term.reset());
try!(term.flush());
Ok(from_utf8_lossy(term.get_ref().get_ref()).to_str())
Ok(from_utf8_lossy(term.get_ref().get_ref()).to_string())
}