bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

libstd: Change Path::new to Path::init.

Browse source
This commit is contained in:
Patrick Walton 2013-11-22 15:45:12 -08:00
parent 6c672ee094
commit c54427ddfb
40 changed files with 546 additions and 541 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/compiletest/compiletest.rs
View file

@ -103,15 +103,15 @@ pub fn parse_config(args: ~[~str]) -> config {
} }
fn opt_path(m: &getopts::Matches, nm: &str) -> Path { fn opt_path(m: &getopts::Matches, nm: &str) -> Path {
Path::new(m.opt_str(nm).unwrap()) Path::init(m.opt_str(nm).unwrap())
} }
config { config {
compile_lib_path: matches.opt_str("compile-lib-path").unwrap(), compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
run_lib_path: matches.opt_str("run-lib-path").unwrap(), run_lib_path: matches.opt_str("run-lib-path").unwrap(),
rustc_path: opt_path(matches, "rustc-path"), rustc_path: opt_path(matches, "rustc-path"),
clang_path: matches.opt_str("clang-path").map(|s| Path::new(s)), clang_path: matches.opt_str("clang-path").map(|s| Path::init(s)),
llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| Path::new(s)), llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| Path::init(s)),
src_base: opt_path(matches, "src-base"), src_base: opt_path(matches, "src-base"),
build_base: opt_path(matches, "build-base"), build_base: opt_path(matches, "build-base"),
aux_base: opt_path(matches, "aux-base"), aux_base: opt_path(matches, "aux-base"),
@ -124,10 +124,10 @@ pub fn parse_config(args: ~[~str]) -> config {
} else { } else {
None None
}, },
logfile: matches.opt_str("logfile").map(|s| Path::new(s)), logfile: matches.opt_str("logfile").map(|s| Path::init(s)),
save_metrics: matches.opt_str("save-metrics").map(|s| Path::new(s)), save_metrics: matches.opt_str("save-metrics").map(|s| Path::init(s)),
ratchet_metrics: ratchet_metrics:
matches.opt_str("ratchet-metrics").map(|s| Path::new(s)), matches.opt_str("ratchet-metrics").map(|s| Path::init(s)),
ratchet_noise_percent: ratchet_noise_percent:
matches.opt_str("ratchet-noise-percent").and_then(|s| from_str::<f64>(s)), matches.opt_str("ratchet-noise-percent").and_then(|s| from_str::<f64>(s)),
runtool: matches.opt_str("runtool"), runtool: matches.opt_str("runtool"),

4
src/compiletest/header.rs
View file

@ -160,10 +160,10 @@ fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> { fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {
match parse_name_value_directive(line, ~"pp-exact") { match parse_name_value_directive(line, ~"pp-exact") {
Some(s) => Some(Path::new(s)), Some(s) => Some(Path::init(s)),
None => { None => {
if parse_name_directive(line, "pp-exact") { if parse_name_directive(line, "pp-exact") {
testfile.filename().map(|s| Path::new(s)) testfile.filename().map(|s| Path::init(s))
} else { } else {
None None
} }

4
src/compiletest/runtest.rs
View file

@ -45,7 +45,7 @@ pub fn run_metrics(config: config, testfile: ~str, mm: &mut MetricMap) {
// We're going to be dumping a lot of info. Start on a new line. // We're going to be dumping a lot of info. Start on a new line.
print!("\n\n"); print!("\n\n");
} }
let testfile = Path::new(testfile); let testfile = Path::init(testfile);
debug!("running {}", testfile.display()); debug!("running {}", testfile.display());
let props = load_props(&testfile); let props = load_props(&testfile);
debug!("loaded props"); debug!("loaded props");
@ -852,7 +852,7 @@ fn aux_output_dir_name(config: &config, testfile: &Path) -> Path {
} }
fn output_testname(testfile: &Path) -> Path { fn output_testname(testfile: &Path) -> Path {
Path::new(testfile.filestem().unwrap()) Path::init(testfile.filestem().unwrap())
} }
fn output_base_name(config: &config, testfile: &Path) -> Path { fn output_base_name(config: &config, testfile: &Path) -> Path {

6
src/libextra/glob.rs
View file

@ -90,7 +90,7 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> GlobIterator {
// calculate root this way to handle volume-relative Windows paths correctly // calculate root this way to handle volume-relative Windows paths correctly
let mut root = os::getcwd(); let mut root = os::getcwd();
let pat_root = Path::new(pattern).root_path(); let pat_root = Path::init(pattern).root_path();
if pat_root.is_some() { if pat_root.is_some() {
if check_windows_verbatim(pat_root.get_ref()) { if check_windows_verbatim(pat_root.get_ref()) {
// XXX: How do we want to handle verbatim paths? I'm inclined to return nothing, // XXX: How do we want to handle verbatim paths? I'm inclined to return nothing,
@ -766,9 +766,9 @@ mod test {
#[test] #[test]
fn test_matches_path() { fn test_matches_path() {
// on windows, (Path::new("a/b").as_str().unwrap() == "a\\b"), so this // on windows, (Path::init("a/b").as_str().unwrap() == "a\\b"), so this
// tests that / and \ are considered equivalent on windows // tests that / and \ are considered equivalent on windows
assert!(Pattern::new("a/b").matches_path(&Path::new("a/b"))); assert!(Pattern::new("a/b").matches_path(&Path::init("a/b")));
} }
} }

10
src/libextra/terminfo/searcher.rs
View file

@ -29,7 +29,7 @@ pub fn get_dbpath_for_term(term: &str) -> Option<~Path> {
// Find search directory // Find search directory
match getenv("TERMINFO") { match getenv("TERMINFO") {
Some(dir) => dirs_to_search.push(Path::new(dir)), Some(dir) => dirs_to_search.push(Path::init(dir)),
None => { None => {
if homedir.is_some() { if homedir.is_some() {
// ncurses compatability; // ncurses compatability;
@ -38,17 +38,17 @@ pub fn get_dbpath_for_term(term: &str) -> Option<~Path> {
match getenv("TERMINFO_DIRS") { match getenv("TERMINFO_DIRS") {
Some(dirs) => for i in dirs.split(':') { Some(dirs) => for i in dirs.split(':') {
if i == "" { if i == "" {
dirs_to_search.push(Path::new("/usr/share/terminfo")); dirs_to_search.push(Path::init("/usr/share/terminfo"));
} else { } else {
dirs_to_search.push(Path::new(i.to_owned())); dirs_to_search.push(Path::init(i.to_owned()));
} }
}, },
// Found nothing, use the default paths // Found nothing, use the default paths
// /usr/share/terminfo is the de facto location, but it seems // /usr/share/terminfo is the de facto location, but it seems
// Ubuntu puts it in /lib/terminfo // Ubuntu puts it in /lib/terminfo
None => { None => {
dirs_to_search.push(Path::new("/usr/share/terminfo")); dirs_to_search.push(Path::init("/usr/share/terminfo"));
dirs_to_search.push(Path::new("/lib/terminfo")); dirs_to_search.push(Path::init("/lib/terminfo"));
} }
} }
} }

6
src/libextra/test.rs
View file

@ -276,20 +276,20 @@ pub fn parse_opts(args: &[~str]) -> Option<OptRes> {
let run_ignored = matches.opt_present("ignored"); let run_ignored = matches.opt_present("ignored");
let logfile = matches.opt_str("logfile"); let logfile = matches.opt_str("logfile");
let logfile = logfile.map(|s| Path::new(s)); let logfile = logfile.map(|s| Path::init(s));
let run_benchmarks = matches.opt_present("bench"); let run_benchmarks = matches.opt_present("bench");
let run_tests = ! run_benchmarks || let run_tests = ! run_benchmarks ||
matches.opt_present("test"); matches.opt_present("test");
let ratchet_metrics = matches.opt_str("ratchet-metrics"); let ratchet_metrics = matches.opt_str("ratchet-metrics");
let ratchet_metrics = ratchet_metrics.map(|s| Path::new(s)); let ratchet_metrics = ratchet_metrics.map(|s| Path::init(s));
let ratchet_noise_percent = matches.opt_str("ratchet-noise-percent"); let ratchet_noise_percent = matches.opt_str("ratchet-noise-percent");
let ratchet_noise_percent = ratchet_noise_percent.map(|s| from_str::<f64>(s).unwrap()); let ratchet_noise_percent = ratchet_noise_percent.map(|s| from_str::<f64>(s).unwrap());
let save_metrics = matches.opt_str("save-metrics"); let save_metrics = matches.opt_str("save-metrics");
let save_metrics = save_metrics.map(|s| Path::new(s)); let save_metrics = save_metrics.map(|s| Path::init(s));
let test_shard = matches.opt_str("test-shard"); let test_shard = matches.opt_str("test-shard");
let test_shard = opt_shard(test_shard); let test_shard = opt_shard(test_shard);

18
src/librustc/back/rpath.rs
View file

@ -148,7 +148,7 @@ pub fn get_install_prefix_rpath(target_triple: &str) -> ~str {
let install_prefix = env!("CFG_PREFIX"); let install_prefix = env!("CFG_PREFIX");
let tlib = filesearch::relative_target_lib_path(target_triple); let tlib = filesearch::relative_target_lib_path(target_triple);
let mut path = Path::new(install_prefix); let mut path = Path::init(install_prefix);
path.push(&tlib); path.push(&tlib);
let path = os::make_absolute(&path); let path = os::make_absolute(&path);
// FIXME (#9639): This needs to handle non-utf8 paths // FIXME (#9639): This needs to handle non-utf8 paths
@ -183,7 +183,7 @@ mod test {
#[test] #[test]
fn test_prefix_rpath() { fn test_prefix_rpath() {
let res = get_install_prefix_rpath("triple"); let res = get_install_prefix_rpath("triple");
let mut d = Path::new(env!("CFG_PREFIX")); let mut d = Path::init(env!("CFG_PREFIX"));
d.push("lib/rustc/triple/lib"); d.push("lib/rustc/triple/lib");
debug!("test_prefix_path: {} vs. {}", debug!("test_prefix_path: {} vs. {}",
res, res,
@ -194,7 +194,7 @@ mod test {
#[test] #[test]
fn test_prefix_rpath_abs() { fn test_prefix_rpath_abs() {
let res = get_install_prefix_rpath("triple"); let res = get_install_prefix_rpath("triple");
assert!(Path::new(res).is_absolute()); assert!(Path::init(res).is_absolute());
} }
#[test] #[test]
@ -218,7 +218,7 @@ mod test {
fn test_rpath_relative() { fn test_rpath_relative() {
let o = abi::OsLinux; let o = abi::OsLinux;
let res = get_rpath_relative_to_output(o, let res = get_rpath_relative_to_output(o,
&Path::new("bin/rustc"), &Path::new("lib/libstd.so")); &Path::init("bin/rustc"), &Path::init("lib/libstd.so"));
assert_eq!(res.as_slice(), "$ORIGIN/../lib"); assert_eq!(res.as_slice(), "$ORIGIN/../lib");
} }
@ -227,7 +227,7 @@ mod test {
fn test_rpath_relative() { fn test_rpath_relative() {
let o = abi::OsFreebsd; let o = abi::OsFreebsd;
let res = get_rpath_relative_to_output(o, let res = get_rpath_relative_to_output(o,
&Path::new("bin/rustc"), &Path::new("lib/libstd.so")); &Path::init("bin/rustc"), &Path::init("lib/libstd.so"));
assert_eq!(res.as_slice(), "$ORIGIN/../lib"); assert_eq!(res.as_slice(), "$ORIGIN/../lib");
} }
@ -236,15 +236,15 @@ mod test {
fn test_rpath_relative() { fn test_rpath_relative() {
let o = abi::OsMacos; let o = abi::OsMacos;
let res = get_rpath_relative_to_output(o, let res = get_rpath_relative_to_output(o,
&Path::new("bin/rustc"), &Path::init("bin/rustc"),
&Path::new("lib/libstd.so")); &Path::init("lib/libstd.so"));
assert_eq!(res.as_slice(), "@loader_path/../lib"); assert_eq!(res.as_slice(), "@loader_path/../lib");
} }
#[test] #[test]
fn test_get_absolute_rpath() { fn test_get_absolute_rpath() {
let res = get_absolute_rpath(&Path::new("lib/libstd.so")); let res = get_absolute_rpath(&Path::init("lib/libstd.so"));
let lib = os::make_absolute(&Path::new("lib")); let lib = os::make_absolute(&Path::init("lib"));
debug!("test_get_absolute_rpath: {} vs. {}", debug!("test_get_absolute_rpath: {} vs. {}",
res.to_str(), lib.display()); res.to_str(), lib.display());

4
src/librustc/driver/driver.rs
View file

@ -719,7 +719,7 @@ pub fn build_session_options(binary: @str,
} else if matches.opt_present("emit-llvm") { } else if matches.opt_present("emit-llvm") {
link::output_type_bitcode link::output_type_bitcode
} else { link::output_type_exe }; } else { link::output_type_exe };
let sysroot_opt = matches.opt_str("sysroot").map(|m| @Path::new(m)); let sysroot_opt = matches.opt_str("sysroot").map(|m| @Path::init(m));
let target = matches.opt_str("target").unwrap_or(host_triple()); let target = matches.opt_str("target").unwrap_or(host_triple());
let target_cpu = matches.opt_str("target-cpu").unwrap_or(~"generic"); let target_cpu = matches.opt_str("target-cpu").unwrap_or(~"generic");
let target_feature = matches.opt_str("target-feature").unwrap_or(~""); let target_feature = matches.opt_str("target-feature").unwrap_or(~"");
@ -753,7 +753,7 @@ pub fn build_session_options(binary: @str,
let statik = debugging_opts & session::statik != 0; let statik = debugging_opts & session::statik != 0;
let addl_lib_search_paths = matches.opt_strs("L").map(|s| { let addl_lib_search_paths = matches.opt_strs("L").map(|s| {
Path::new(s.as_slice()) Path::init(s.as_slice())
}).move_iter().collect(); }).move_iter().collect();
let linker = matches.opt_str("linker"); let linker = matches.opt_str("linker");
let linker_args = matches.opt_strs("link-args").flat_map( |a| { let linker_args = matches.opt_strs("link-args").flat_map( |a| {

6
src/librustc/lib.rs
View file

@ -248,7 +248,7 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) {
let src = str::from_utf8(io::stdin().read_to_end()); let src = str::from_utf8(io::stdin().read_to_end());
str_input(src.to_managed()) str_input(src.to_managed())
} else { } else {
file_input(Path::new(ifile)) file_input(Path::init(ifile))
} }
} }
_ => early_error(demitter, "multiple input filenames provided") _ => early_error(demitter, "multiple input filenames provided")
@ -256,8 +256,8 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) {
let sopts = build_session_options(binary, matches, demitter); let sopts = build_session_options(binary, matches, demitter);
let sess = build_session(sopts, demitter); let sess = build_session(sopts, demitter);
let odir = matches.opt_str("out-dir").map(|o| Path::new(o)); let odir = matches.opt_str("out-dir").map(|o| Path::init(o));
let ofile = matches.opt_str("o").map(|o| Path::new(o)); let ofile = matches.opt_str("o").map(|o| Path::init(o));
let cfg = build_configuration(sess); let cfg = build_configuration(sess);
let pretty = matches.opt_default("pretty", "normal").map(|a| { let pretty = matches.opt_default("pretty", "normal").map(|a| {
parse_pretty(sess, a) parse_pretty(sess, a)

4
src/librustc/metadata/creader.rs
View file

@ -143,7 +143,7 @@ fn visit_view_item(e: @mut Env, i: &ast::view_item) {
let meta_items = match path_opt { let meta_items = match path_opt {
None => meta_items.clone(), None => meta_items.clone(),
Some((p, _path_str_style)) => { Some((p, _path_str_style)) => {
let p_path = Path::new(p); let p_path = Path::init(p);
match p_path.filestem_str() { match p_path.filestem_str() {
None|Some("") => None|Some("") =>
e.diag.span_bug(i.span, "Bad package path in `extern mod` item"), e.diag.span_bug(i.span, "Bad package path in `extern mod` item"),
@ -275,7 +275,7 @@ fn resolve_crate(e: @mut Env,
}; };
let (lident, ldata) = loader::load_library_crate(&load_ctxt); let (lident, ldata) = loader::load_library_crate(&load_ctxt);
let cfilename = Path::new(lident); let cfilename = Path::init(lident);
let cdata = ldata; let cdata = ldata;
let attrs = decoder::get_crate_attributes(cdata); let attrs = decoder::get_crate_attributes(cdata);

4
src/librustc/metadata/filesearch.rs
View file

@ -145,7 +145,7 @@ pub fn search(filesearch: @FileSearch, pick: pick) {
pub fn relative_target_lib_path(target_triple: &str) -> Path { pub fn relative_target_lib_path(target_triple: &str) -> Path {
let dir = libdir(); let dir = libdir();
let mut p = Path::new(dir.as_slice()); let mut p = Path::init(dir.as_slice());
assert!(p.is_relative()); assert!(p.is_relative());
p.push("rustc"); p.push("rustc");
p.push(target_triple); p.push(target_triple);
@ -199,7 +199,7 @@ pub fn rust_path() -> ~[Path] {
Some(env_path) => { Some(env_path) => {
let env_path_components: ~[&str] = let env_path_components: ~[&str] =
env_path.split_str(PATH_ENTRY_SEPARATOR).collect(); env_path.split_str(PATH_ENTRY_SEPARATOR).collect();
env_path_components.map(|&s| Path::new(s)) env_path_components.map(|&s| Path::init(s))
} }
None => ~[] None => ~[]
}; };

4
src/librustdoc/html/render.rs
View file

@ -336,7 +336,7 @@ fn mkdir(path: &Path) {
/// static HTML tree. /// static HTML tree.
// FIXME (#9639): The closure should deal with &[u8] instead of &str // FIXME (#9639): The closure should deal with &[u8] instead of &str
fn clean_srcpath(src: &[u8], f: |&str|) { fn clean_srcpath(src: &[u8], f: |&str|) {
let p = Path::new(src); let p = Path::init(src);
if p.as_vec() != bytes!(".") { if p.as_vec() != bytes!(".") {
for c in p.str_components().map(|x|x.unwrap()) { for c in p.str_components().map(|x|x.unwrap()) {
if ".." == c { if ".." == c {
@ -411,7 +411,7 @@ impl<'self> DocFolder for SourceCollector<'self> {
impl<'self> SourceCollector<'self> { impl<'self> SourceCollector<'self> {
/// Renders the given filename into its corresponding HTML source file. /// Renders the given filename into its corresponding HTML source file.
fn emit_source(&mut self, filename: &str) -> bool { fn emit_source(&mut self, filename: &str) -> bool {
let p = Path::new(filename); let p = Path::init(filename);
// Read the contents of the file // Read the contents of the file
let mut contents = ~[]; let mut contents = ~[];

14
src/librustdoc/lib.rs
View file

@ -140,13 +140,13 @@ pub fn main_args(args: &[~str]) -> int {
info!("going to format"); info!("going to format");
let started = time::precise_time_ns(); let started = time::precise_time_ns();
let output = matches.opt_str("o").map(|s| Path::new(s)); let output = matches.opt_str("o").map(|s| Path::init(s));
match matches.opt_str("w") { match matches.opt_str("w") {
Some(~"html") | None => { Some(~"html") | None => {
html::render::run(crate, output.unwrap_or(Path::new("doc"))) html::render::run(crate, output.unwrap_or(Path::init("doc")))
} }
Some(~"json") => { Some(~"json") => {
json_output(crate, res, output.unwrap_or(Path::new("doc.json"))) json_output(crate, res, output.unwrap_or(Path::init("doc.json")))
} }
Some(s) => { Some(s) => {
println!("unknown output format: {}", s); println!("unknown output format: {}", s);
@ -194,9 +194,9 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
let mut plugins = matches.opt_strs("plugins"); let mut plugins = matches.opt_strs("plugins");
// First, parse the crate and extract all relevant information. // First, parse the crate and extract all relevant information.
let libs = Cell::new(matches.opt_strs("L").map(|s| Path::new(s.as_slice()))); let libs = Cell::new(matches.opt_strs("L").map(|s| Path::init(s.as_slice())));
let cfgs = Cell::new(matches.opt_strs("cfg")); let cfgs = Cell::new(matches.opt_strs("cfg"));
let cr = Cell::new(Path::new(cratefile)); let cr = Cell::new(Path::init(cratefile));
info!("starting to run rustc"); info!("starting to run rustc");
let (crate, analysis) = do std::task::try { let (crate, analysis) = do std::task::try {
let cr = cr.take(); let cr = cr.take();
@ -238,7 +238,7 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
// Load all plugins/passes into a PluginManager // Load all plugins/passes into a PluginManager
let path = matches.opt_str("plugin-path").unwrap_or(~"/tmp/rustdoc_ng/plugins"); let path = matches.opt_str("plugin-path").unwrap_or(~"/tmp/rustdoc_ng/plugins");
let mut pm = plugins::PluginManager::new(Path::new(path)); let mut pm = plugins::PluginManager::new(Path::init(path));
for pass in passes.iter() { for pass in passes.iter() {
let plugin = match PASSES.iter().position(|&(p, _, _)| p == *pass) { let plugin = match PASSES.iter().position(|&(p, _, _)| p == *pass) {
Some(i) => PASSES[i].n1(), Some(i) => PASSES[i].n1(),
@ -262,7 +262,7 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
/// This input format purely deserializes the json output file. No passes are /// This input format purely deserializes the json output file. No passes are
/// run over the deserialized output. /// run over the deserialized output.
fn json_input(input: &str) -> Result<Output, ~str> { fn json_input(input: &str) -> Result<Output, ~str> {
let input = match File::open(&Path::new(input)) { let input = match File::open(&Path::init(input)) {
Some(f) => f, Some(f) => f,
None => return Err(format!("couldn't open {} for reading", input)), None => return Err(format!("couldn't open {} for reading", input)),
}; };

6
src/librustpkg/api.rs
View file

@ -56,12 +56,12 @@ pub fn new_default_context(c: workcache::Context, p: Path) -> BuildContext {
} }
fn file_is_fresh(path: &str, in_hash: &str) -> bool { fn file_is_fresh(path: &str, in_hash: &str) -> bool {
let path = Path::new(path); let path = Path::init(path);
path.exists() && in_hash == digest_file_with_date(&path) path.exists() && in_hash == digest_file_with_date(&path)
} }
fn binary_is_fresh(path: &str, in_hash: &str) -> bool { fn binary_is_fresh(path: &str, in_hash: &str) -> bool {
let path = Path::new(path); let path = Path::init(path);
path.exists() && in_hash == digest_only_date(&path) path.exists() && in_hash == digest_only_date(&path)
} }
@ -189,7 +189,7 @@ pub fn my_workspace(context: &Context, package_name: &str) -> Path {
let pkgid = PkgId::new(package_name); let pkgid = PkgId::new(package_name);
let workspaces = pkg_parent_workspaces(context, &pkgid); let workspaces = pkg_parent_workspaces(context, &pkgid);
if workspaces.is_empty() { if workspaces.is_empty() {
bad_pkg_id.raise((Path::new(package_name), package_name.to_owned())); bad_pkg_id.raise((Path::init(package_name), package_name.to_owned()));
} }
workspaces[0] workspaces[0]
} }

16
src/librustpkg/lib.rs
View file

@ -483,7 +483,7 @@ impl CtxMethods for BuildContext {
}) })
}); });
// We always *run* the package script // We always *run* the package script
let (cfgs, hook_result) = PkgScript::run_custom(&Path::new(pkg_exe), &sysroot); let (cfgs, hook_result) = PkgScript::run_custom(&Path::init(pkg_exe), &sysroot);
debug!("Command return code = {:?}", hook_result); debug!("Command return code = {:?}", hook_result);
if !hook_result.success() { if !hook_result.success() {
fail!("Error running custom build command") fail!("Error running custom build command")
@ -509,7 +509,7 @@ impl CtxMethods for BuildContext {
// Find crates inside the workspace // Find crates inside the workspace
Everything => pkg_src.find_crates(), Everything => pkg_src.find_crates(),
// Find only tests // Find only tests
Tests => pkg_src.find_crates_with_filter(|s| { is_test(&Path::new(s)) }), Tests => pkg_src.find_crates_with_filter(|s| { is_test(&Path::init(s)) }),
// Don't infer any crates -- just build the one that was requested // Don't infer any crates -- just build the one that was requested
JustOne(ref p) => { JustOne(ref p) => {
// We expect that p is relative to the package source's start directory, // We expect that p is relative to the package source's start directory,
@ -588,7 +588,7 @@ impl CtxMethods for BuildContext {
let result = self.install_no_build(pkg_src.build_workspace(), let result = self.install_no_build(pkg_src.build_workspace(),
build_inputs, build_inputs,
&pkg_src.destination_workspace, &pkg_src.destination_workspace,
&id).map(|s| Path::new(s.as_slice())); &id).map(|s| Path::init(s.as_slice()));
installed_files = installed_files + result; installed_files = installed_files + result;
note(format!("Installed package {} to {}", note(format!("Installed package {} to {}",
id.to_str(), id.to_str(),
@ -709,10 +709,10 @@ impl CtxMethods for BuildContext {
} }
fn init(&self) { fn init(&self) {
fs::mkdir_recursive(&Path::new("src"), io::UserRWX); fs::mkdir_recursive(&Path::init("src"), io::UserRWX);
fs::mkdir_recursive(&Path::new("bin"), io::UserRWX); fs::mkdir_recursive(&Path::init("bin"), io::UserRWX);
fs::mkdir_recursive(&Path::new("lib"), io::UserRWX); fs::mkdir_recursive(&Path::init("lib"), io::UserRWX);
fs::mkdir_recursive(&Path::new("build"), io::UserRWX); fs::mkdir_recursive(&Path::init("build"), io::UserRWX);
} }
fn uninstall(&self, _id: &str, _vers: Option<~str>) { fn uninstall(&self, _id: &str, _vers: Option<~str>) {
@ -894,7 +894,7 @@ pub fn main_args(args: &[~str]) -> int {
let mut remaining_args: ~[~str] = remaining_args.map(|s| (*s).clone()).collect(); let mut remaining_args: ~[~str] = remaining_args.map(|s| (*s).clone()).collect();
remaining_args.shift(); remaining_args.shift();
let sroot = match supplied_sysroot { let sroot = match supplied_sysroot {
Some(s) => Path::new(s), Some(s) => Path::init(s),
_ => filesearch::get_or_default_sysroot() _ => filesearch::get_or_default_sysroot()
}; };

6
src/librustpkg/package_id.rs
View file

@ -58,7 +58,7 @@ impl PkgId {
} }
}; };
let path = Path::new(s); let path = Path::init(s);
if !path.is_relative() { if !path.is_relative() {
return cond.raise((path, ~"absolute pkgid")); return cond.raise((path, ~"absolute pkgid"));
} }
@ -136,8 +136,8 @@ impl Iterator<(Path, Path)> for Prefixes {
let last = self.components.pop(); let last = self.components.pop();
self.remaining.unshift(last); self.remaining.unshift(last);
// converting to str and then back is a little unfortunate // converting to str and then back is a little unfortunate
Some((Path::new(self.components.connect("/")), Some((Path::init(self.components.connect("/")),
Path::new(self.remaining.connect("/")))) Path::init(self.remaining.connect("/"))))
} }
} }
} }

6
src/librustpkg/package_source.rs
View file

@ -332,7 +332,7 @@ impl PkgSrc {
it.nth(prefix-1); // skip elements it.nth(prefix-1); // skip elements
} }
assert!(it.peek().is_some()); assert!(it.peek().is_some());
let mut sub = Path::new("."); let mut sub = Path::init(".");
for c in it { for c in it {
sub.push(c); sub.push(c);
} }
@ -414,11 +414,11 @@ impl PkgSrc {
(k.clone(), p.as_str().unwrap().to_owned())); (k.clone(), p.as_str().unwrap().to_owned()));
prep.exec(proc(exec) { prep.exec(proc(exec) {
for &(ref kind, ref p) in inputs.iter() { for &(ref kind, ref p) in inputs.iter() {
let pth = Path::new(p.clone()); let pth = Path::init(p.clone());
exec.discover_input(*kind, *p, if *kind == ~"file" { exec.discover_input(*kind, *p, if *kind == ~"file" {
digest_file_with_date(&pth) digest_file_with_date(&pth)
} else if *kind == ~"binary" { } else if *kind == ~"binary" {
digest_only_date(&Path::new(p.clone())) digest_only_date(&Path::init(p.clone()))
} else { } else {
fail!("Bad kind in build_crates") fail!("Bad kind in build_crates")
}); });

94
src/librustpkg/tests.rs
View file

@ -63,7 +63,7 @@ fn fake_ctxt(sysroot: Path, workspace: &Path) -> BuildContext {
fn fake_pkg() -> PkgId { fn fake_pkg() -> PkgId {
let sn = ~"bogus"; let sn = ~"bogus";
PkgId { PkgId {
path: Path::new(sn.as_slice()), path: Path::init(sn.as_slice()),
short_name: sn, short_name: sn,
version: NoVersion version: NoVersion
} }
@ -71,7 +71,7 @@ fn fake_pkg() -> PkgId {
fn git_repo_pkg() -> PkgId { fn git_repo_pkg() -> PkgId {
PkgId { PkgId {
path: Path::new("mockgithub.com/catamorphism/test-pkg"), path: Path::init("mockgithub.com/catamorphism/test-pkg"),
short_name: ~"test-pkg", short_name: ~"test-pkg",
version: NoVersion version: NoVersion
} }
@ -79,7 +79,7 @@ fn git_repo_pkg() -> PkgId {
fn git_repo_pkg_with_tag(a_tag: ~str) -> PkgId { fn git_repo_pkg_with_tag(a_tag: ~str) -> PkgId {
PkgId { PkgId {
path: Path::new("mockgithub.com/catamorphism/test-pkg"), path: Path::init("mockgithub.com/catamorphism/test-pkg"),
short_name: ~"test-pkg", short_name: ~"test-pkg",
version: Tagged(a_tag) version: Tagged(a_tag)
} }
@ -479,7 +479,7 @@ fn command_line_test_output_with_env(args: &[~str], env: ~[(~str, ~str)]) -> ~[~
fn lib_output_file_name(workspace: &Path, short_name: &str) -> Path { fn lib_output_file_name(workspace: &Path, short_name: &str) -> Path {
debug!("lib_output_file_name: given {} and short name {}", debug!("lib_output_file_name: given {} and short name {}",
workspace.display(), short_name); workspace.display(), short_name);
library_in_workspace(&Path::new(short_name), library_in_workspace(&Path::init(short_name),
short_name, short_name,
Build, Build,
workspace, workspace,
@ -752,12 +752,12 @@ fn test_package_ids_must_be_relative_path_like() {
}); });
cond.trap(|(p, e)| { cond.trap(|(p, e)| {
let abs = os::make_absolute(&Path::new("foo/bar/quux")); let abs = os::make_absolute(&Path::init("foo/bar/quux"));
assert_eq!(p, abs); assert_eq!(p, abs);
assert!("absolute pkgid" == e); assert!("absolute pkgid" == e);
whatever.clone() whatever.clone()
}).inside(|| { }).inside(|| {
let zp = os::make_absolute(&Path::new("foo/bar/quux")); let zp = os::make_absolute(&Path::init("foo/bar/quux"));
// FIXME (#9639): This needs to handle non-utf8 paths // FIXME (#9639): This needs to handle non-utf8 paths
let z = PkgId::new(zp.as_str().unwrap()); let z = PkgId::new(zp.as_str().unwrap());
assert_eq!(~"foo-0.1", z.to_str()); assert_eq!(~"foo-0.1", z.to_str());
@ -768,7 +768,7 @@ fn test_package_ids_must_be_relative_path_like() {
#[test] #[test]
fn test_package_version() { fn test_package_version() {
let local_path = "mockgithub.com/catamorphism/test_pkg_version"; let local_path = "mockgithub.com/catamorphism/test_pkg_version";
let repo = init_git_repo(&Path::new(local_path)); let repo = init_git_repo(&Path::init(local_path));
let repo = repo.path(); let repo = repo.path();
let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test_pkg_version"]); let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test_pkg_version"]);
debug!("Writing files in: {}", repo_subdir.display()); debug!("Writing files in: {}", repo_subdir.display());
@ -808,7 +808,7 @@ fn test_package_version() {
#[test] #[test]
fn test_package_request_version() { fn test_package_request_version() {
let local_path = "mockgithub.com/catamorphism/test_pkg_version"; let local_path = "mockgithub.com/catamorphism/test_pkg_version";
let repo = init_git_repo(&Path::new(local_path)); let repo = init_git_repo(&Path::init(local_path));
let repo = repo.path(); let repo = repo.path();
let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test_pkg_version"]); let repo_subdir = repo.join_many(["mockgithub.com", "catamorphism", "test_pkg_version"]);
debug!("Writing files in: {}", repo_subdir.display()); debug!("Writing files in: {}", repo_subdir.display());
@ -827,7 +827,7 @@ fn test_package_request_version() {
command_line_test([~"install", format!("{}\\#0.3", local_path)], repo); command_line_test([~"install", format!("{}\\#0.3", local_path)], repo);
assert!(match installed_library_in_workspace(&Path::new("test_pkg_version"), assert!(match installed_library_in_workspace(&Path::init("test_pkg_version"),
&repo.join(".rust")) { &repo.join(".rust")) {
Some(p) => { Some(p) => {
debug!("installed: {}", p.display()); debug!("installed: {}", p.display());
@ -841,7 +841,7 @@ fn test_package_request_version() {
== repo.join_many([".rust", "bin", "test_pkg_version"])); == repo.join_many([".rust", "bin", "test_pkg_version"]));
let mut dir = target_build_dir(&repo.join(".rust")); let mut dir = target_build_dir(&repo.join(".rust"));
dir.push(&Path::new("src/mockgithub.com/catamorphism/test_pkg_version-0.3")); dir.push(&Path::init("src/mockgithub.com/catamorphism/test_pkg_version-0.3"));
debug!("dir = {}", dir.display()); debug!("dir = {}", dir.display());
assert!(dir.is_dir()); assert!(dir.is_dir());
assert!(dir.join("version-0.3-file.txt").exists()); assert!(dir.join("version-0.3-file.txt").exists());
@ -858,7 +858,7 @@ fn rustpkg_install_url_2() {
#[test] #[test]
fn rustpkg_library_target() { fn rustpkg_library_target() {
let foo_repo = init_git_repo(&Path::new("foo")); let foo_repo = init_git_repo(&Path::init("foo"));
let foo_repo = foo_repo.path(); let foo_repo = foo_repo.path();
let package_dir = foo_repo.join("foo"); let package_dir = foo_repo.join("foo");
@ -874,7 +874,7 @@ fn rustpkg_library_target() {
add_git_tag(&package_dir, ~"1.0"); add_git_tag(&package_dir, ~"1.0");
command_line_test([~"install", ~"foo"], foo_repo); command_line_test([~"install", ~"foo"], foo_repo);
assert_lib_exists(&foo_repo.join(".rust"), &Path::new("foo"), ExactRevision(~"1.0")); assert_lib_exists(&foo_repo.join(".rust"), &Path::init("foo"), ExactRevision(~"1.0"));
} }
#[test] #[test]
@ -885,18 +885,19 @@ fn rustpkg_local_pkg() {
} }
#[test] #[test]
#[ignore(reason="busted")]
fn package_script_with_default_build() { fn package_script_with_default_build() {
let dir = create_local_package(&PkgId::new("fancy-lib")); let dir = create_local_package(&PkgId::new("fancy-lib"));
let dir = dir.path(); let dir = dir.path();
debug!("dir = {}", dir.display()); debug!("dir = {}", dir.display());
let mut source = test_sysroot().dir_path(); let mut source = test_sysroot().dir_path();
source.pop(); source.pop(); source.pop(); source.pop();
let source = Path::new(file!()).dir_path().join_many( let source = Path::init(file!()).dir_path().join_many(
[~"testsuite", ~"pass", ~"src", ~"fancy-lib", ~"pkg.rs"]); [~"testsuite", ~"pass", ~"src", ~"fancy-lib", ~"pkg.rs"]);
debug!("package_script_with_default_build: {}", source.display()); debug!("package_script_with_default_build: {}", source.display());
fs::copy(&source, &dir.join_many(["src", "fancy-lib-0.1", "pkg.rs"])); fs::copy(&source, &dir.join_many(["src", "fancy-lib-0.1", "pkg.rs"]));
command_line_test([~"install", ~"fancy-lib"], dir); command_line_test([~"install", ~"fancy-lib"], dir);
assert_lib_exists(dir, &Path::new("fancy-lib"), NoVersion); assert_lib_exists(dir, &Path::init("fancy-lib"), NoVersion);
assert!(target_build_dir(dir).join_many([~"fancy-lib", ~"generated.rs"]).exists()); assert!(target_build_dir(dir).join_many([~"fancy-lib", ~"generated.rs"]).exists());
let generated_path = target_build_dir(dir).join_many([~"fancy-lib", ~"generated.rs"]); let generated_path = target_build_dir(dir).join_many([~"fancy-lib", ~"generated.rs"]);
debug!("generated path = {}", generated_path.display()); debug!("generated path = {}", generated_path.display());
@ -927,7 +928,7 @@ fn rustpkg_install_no_arg() {
"fn main() { let _x = (); }"); "fn main() { let _x = (); }");
debug!("install_no_arg: dir = {}", package_dir.display()); debug!("install_no_arg: dir = {}", package_dir.display());
command_line_test([~"install"], &package_dir); command_line_test([~"install"], &package_dir);
assert_lib_exists(&tmp, &Path::new("foo"), NoVersion); assert_lib_exists(&tmp, &Path::init("foo"), NoVersion);
} }
#[test] #[test]
@ -950,7 +951,7 @@ fn rustpkg_clean_no_arg() {
#[test] #[test]
fn rust_path_test() { fn rust_path_test() {
let dir_for_path = TempDir::new("more_rust").expect("rust_path_test failed"); let dir_for_path = TempDir::new("more_rust").expect("rust_path_test failed");
let dir = mk_workspace(dir_for_path.path(), &Path::new("foo"), &NoVersion); let dir = mk_workspace(dir_for_path.path(), &Path::init("foo"), &NoVersion);
debug!("dir = {}", dir.display()); debug!("dir = {}", dir.display());
writeFile(&dir.join("main.rs"), "fn main() { let _x = (); }"); writeFile(&dir.join("main.rs"), "fn main() { let _x = (); }");
@ -991,9 +992,9 @@ fn rust_path_contents() {
fn rust_path_parse() { fn rust_path_parse() {
os::setenv("RUST_PATH", "/a/b/c:/d/e/f:/g/h/i"); os::setenv("RUST_PATH", "/a/b/c:/d/e/f:/g/h/i");
let paths = rust_path(); let paths = rust_path();
assert!(paths.contains(&Path::new("/g/h/i"))); assert!(paths.contains(&Path::init("/g/h/i")));
assert!(paths.contains(&Path::new("/d/e/f"))); assert!(paths.contains(&Path::init("/d/e/f")));
assert!(paths.contains(&Path::new("/a/b/c"))); assert!(paths.contains(&Path::init("/a/b/c")));
os::unsetenv("RUST_PATH"); os::unsetenv("RUST_PATH");
} }
@ -1373,8 +1374,8 @@ fn multiple_workspaces() {
// Copy the exact same package into directory B and install it // Copy the exact same package into directory B and install it
// Set the RUST_PATH to A:B // Set the RUST_PATH to A:B
// Make a third package that uses foo, make sure we can build/install it // Make a third package that uses foo, make sure we can build/install it
let (a_loc, _pkg_dir) = mk_temp_workspace(&Path::new("foo"), &NoVersion); let (a_loc, _pkg_dir) = mk_temp_workspace(&Path::init("foo"), &NoVersion);
let (b_loc, _pkg_dir) = mk_temp_workspace(&Path::new("foo"), &NoVersion); let (b_loc, _pkg_dir) = mk_temp_workspace(&Path::init("foo"), &NoVersion);
let (a_loc, b_loc) = (a_loc.path(), b_loc.path()); let (a_loc, b_loc) = (a_loc.path(), b_loc.path());
debug!("Trying to install foo in {}", a_loc.display()); debug!("Trying to install foo in {}", a_loc.display());
command_line_test([~"install", ~"foo"], a_loc); command_line_test([~"install", ~"foo"], a_loc);
@ -1399,7 +1400,7 @@ fn rust_path_hack_test(hack_flag: bool) {
let p_id = PkgId::new("foo"); let p_id = PkgId::new("foo");
let workspace = create_local_package(&p_id); let workspace = create_local_package(&p_id);
let workspace = workspace.path(); let workspace = workspace.path();
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace"); let dest_workspace = mk_empty_workspace(&Path::init("bar"), &NoVersion, "dest_workspace");
let dest_workspace = dest_workspace.path(); let dest_workspace = dest_workspace.path();
let foo_path = workspace.join_many(["src", "foo-0.1"]); let foo_path = workspace.join_many(["src", "foo-0.1"]);
let rust_path = Some(~[(~"RUST_PATH", let rust_path = Some(~[(~"RUST_PATH",
@ -1408,11 +1409,11 @@ fn rust_path_hack_test(hack_flag: bool) {
foo_path.as_str().unwrap()))]); foo_path.as_str().unwrap()))]);
command_line_test_with_env(~[~"install"] + if hack_flag { ~[~"--rust-path-hack"] } else { ~[] } + command_line_test_with_env(~[~"install"] + if hack_flag { ~[~"--rust-path-hack"] } else { ~[] } +
~[~"foo"], dest_workspace, rust_path); ~[~"foo"], dest_workspace, rust_path);
assert_lib_exists(dest_workspace, &Path::new("foo"), NoVersion); assert_lib_exists(dest_workspace, &Path::init("foo"), NoVersion);
assert_executable_exists(dest_workspace, "foo"); assert_executable_exists(dest_workspace, "foo");
assert_built_library_exists(dest_workspace, "foo"); assert_built_library_exists(dest_workspace, "foo");
assert_built_executable_exists(dest_workspace, "foo"); assert_built_executable_exists(dest_workspace, "foo");
assert!(!lib_exists(workspace, &Path::new("foo"), NoVersion)); assert!(!lib_exists(workspace, &Path::init("foo"), NoVersion));
assert!(!executable_exists(workspace, "foo")); assert!(!executable_exists(workspace, "foo"));
assert!(!built_library_exists(workspace, "foo")); assert!(!built_library_exists(workspace, "foo"));
assert!(!built_executable_exists(workspace, "foo")); assert!(!built_executable_exists(workspace, "foo"));
@ -1447,15 +1448,15 @@ fn rust_path_hack_cwd() {
fs::mkdir_recursive(&cwd, io::UserRWX); fs::mkdir_recursive(&cwd, io::UserRWX);
writeFile(&cwd.join("lib.rs"), "pub fn f() { }"); writeFile(&cwd.join("lib.rs"), "pub fn f() { }");
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace"); let dest_workspace = mk_empty_workspace(&Path::init("bar"), &NoVersion, "dest_workspace");
let dest_workspace = dest_workspace.path(); let dest_workspace = dest_workspace.path();
// FIXME (#9639): This needs to handle non-utf8 paths // FIXME (#9639): This needs to handle non-utf8 paths
let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]); let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]);
command_line_test_with_env([~"install", ~"--rust-path-hack", ~"foo"], &cwd, rust_path); command_line_test_with_env([~"install", ~"--rust-path-hack", ~"foo"], &cwd, rust_path);
debug!("Checking that foo exists in {}", dest_workspace.display()); debug!("Checking that foo exists in {}", dest_workspace.display());
assert_lib_exists(dest_workspace, &Path::new("foo"), NoVersion); assert_lib_exists(dest_workspace, &Path::init("foo"), NoVersion);
assert_built_library_exists(dest_workspace, "foo"); assert_built_library_exists(dest_workspace, "foo");
assert!(!lib_exists(&cwd, &Path::new("foo"), NoVersion)); assert!(!lib_exists(&cwd, &Path::init("foo"), NoVersion));
assert!(!built_library_exists(&cwd, "foo")); assert!(!built_library_exists(&cwd, "foo"));
} }
@ -1468,15 +1469,15 @@ fn rust_path_hack_multi_path() {
writeFile(&subdir.join("lib.rs"), "pub fn f() { }"); writeFile(&subdir.join("lib.rs"), "pub fn f() { }");
let name = ~"foo/bar/quux"; let name = ~"foo/bar/quux";
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace"); let dest_workspace = mk_empty_workspace(&Path::init("bar"), &NoVersion, "dest_workspace");
let dest_workspace = dest_workspace.path(); let dest_workspace = dest_workspace.path();
// FIXME (#9639): This needs to handle non-utf8 paths // FIXME (#9639): This needs to handle non-utf8 paths
let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]); let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]);
command_line_test_with_env([~"install", ~"--rust-path-hack", name.clone()], &subdir, rust_path); command_line_test_with_env([~"install", ~"--rust-path-hack", name.clone()], &subdir, rust_path);
debug!("Checking that {} exists in {}", name, dest_workspace.display()); debug!("Checking that {} exists in {}", name, dest_workspace.display());
assert_lib_exists(dest_workspace, &Path::new("quux"), NoVersion); assert_lib_exists(dest_workspace, &Path::init("quux"), NoVersion);
assert_built_library_exists(dest_workspace, name); assert_built_library_exists(dest_workspace, name);
assert!(!lib_exists(&subdir, &Path::new("quux"), NoVersion)); assert!(!lib_exists(&subdir, &Path::init("quux"), NoVersion));
assert!(!built_library_exists(&subdir, name)); assert!(!built_library_exists(&subdir, name));
} }
@ -1489,15 +1490,15 @@ fn rust_path_hack_install_no_arg() {
assert!(make_dir_rwx(&source_dir)); assert!(make_dir_rwx(&source_dir));
writeFile(&source_dir.join("lib.rs"), "pub fn f() { }"); writeFile(&source_dir.join("lib.rs"), "pub fn f() { }");
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace"); let dest_workspace = mk_empty_workspace(&Path::init("bar"), &NoVersion, "dest_workspace");
let dest_workspace = dest_workspace.path(); let dest_workspace = dest_workspace.path();
// FIXME (#9639): This needs to handle non-utf8 paths // FIXME (#9639): This needs to handle non-utf8 paths
let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]); let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]);
command_line_test_with_env([~"install", ~"--rust-path-hack"], &source_dir, rust_path); command_line_test_with_env([~"install", ~"--rust-path-hack"], &source_dir, rust_path);
debug!("Checking that foo exists in {}", dest_workspace.display()); debug!("Checking that foo exists in {}", dest_workspace.display());
assert_lib_exists(dest_workspace, &Path::new("foo"), NoVersion); assert_lib_exists(dest_workspace, &Path::init("foo"), NoVersion);
assert_built_library_exists(dest_workspace, "foo"); assert_built_library_exists(dest_workspace, "foo");
assert!(!lib_exists(&source_dir, &Path::new("foo"), NoVersion)); assert!(!lib_exists(&source_dir, &Path::init("foo"), NoVersion));
assert!(!built_library_exists(cwd, "foo")); assert!(!built_library_exists(cwd, "foo"));
} }
@ -1509,7 +1510,7 @@ fn rust_path_hack_build_no_arg() {
assert!(make_dir_rwx(&source_dir)); assert!(make_dir_rwx(&source_dir));
writeFile(&source_dir.join("lib.rs"), "pub fn f() { }"); writeFile(&source_dir.join("lib.rs"), "pub fn f() { }");
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace"); let dest_workspace = mk_empty_workspace(&Path::init("bar"), &NoVersion, "dest_workspace");
let dest_workspace = dest_workspace.path(); let dest_workspace = dest_workspace.path();
// FIXME (#9639): This needs to handle non-utf8 paths // FIXME (#9639): This needs to handle non-utf8 paths
let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]); let rust_path = Some(~[(~"RUST_PATH", dest_workspace.as_str().unwrap().to_owned())]);
@ -1547,7 +1548,7 @@ fn rust_path_hack_build_with_dependency() {
fn rust_path_install_target() { fn rust_path_install_target() {
let dir_for_path = TempDir::new( let dir_for_path = TempDir::new(
"source_workspace").expect("rust_path_install_target failed"); "source_workspace").expect("rust_path_install_target failed");
let mut dir = mk_workspace(dir_for_path.path(), &Path::new("foo"), &NoVersion); let mut dir = mk_workspace(dir_for_path.path(), &Path::init("foo"), &NoVersion);
debug!("dir = {}", dir.display()); debug!("dir = {}", dir.display());
writeFile(&dir.join("main.rs"), "fn main() { let _x = (); }"); writeFile(&dir.join("main.rs"), "fn main() { let _x = (); }");
let dir_to_install_to = TempDir::new( let dir_to_install_to = TempDir::new(
@ -1659,7 +1660,7 @@ fn notrans_flag_fail() {
workspace, None, BAD_FLAG_CODE); workspace, None, BAD_FLAG_CODE);
assert!(!built_executable_exists(workspace, "foo")); assert!(!built_executable_exists(workspace, "foo"));
assert!(!object_file_exists(workspace, "foo")); assert!(!object_file_exists(workspace, "foo"));
assert!(!lib_exists(workspace, &Path::new("foo"), NoVersion)); assert!(!lib_exists(workspace, &Path::init("foo"), NoVersion));
} }
} }
@ -1926,9 +1927,9 @@ fn test_recursive_deps() {
command_line_test_with_env([~"install", ~"a"], command_line_test_with_env([~"install", ~"a"],
a_workspace, a_workspace,
environment); environment);
assert_lib_exists(a_workspace, &Path::new("a"), NoVersion); assert_lib_exists(a_workspace, &Path::init("a"), NoVersion);
assert_lib_exists(b_workspace, &Path::new("b"), NoVersion); assert_lib_exists(b_workspace, &Path::init("b"), NoVersion);
assert_lib_exists(b_workspace, &Path::new("c"), NoVersion); assert_lib_exists(b_workspace, &Path::init("c"), NoVersion);
} }
#[test] #[test]
@ -1936,7 +1937,7 @@ fn test_install_to_rust_path() {
let p_id = PkgId::new("foo"); let p_id = PkgId::new("foo");
let second_workspace = create_local_package(&p_id); let second_workspace = create_local_package(&p_id);
let second_workspace = second_workspace.path(); let second_workspace = second_workspace.path();
let first_workspace = mk_empty_workspace(&Path::new("p"), &NoVersion, "dest"); let first_workspace = mk_empty_workspace(&Path::init("p"), &NoVersion, "dest");
let first_workspace = first_workspace.path(); let first_workspace = first_workspace.path();
// FIXME (#9639): This needs to handle non-utf8 paths // FIXME (#9639): This needs to handle non-utf8 paths
let rust_path = Some(~[(~"RUST_PATH", let rust_path = Some(~[(~"RUST_PATH",
@ -1983,7 +1984,7 @@ fn test_target_specific_install_dir() {
~"foo"], ~"foo"],
workspace); workspace);
assert!(workspace.join_many([~"lib", host_triple()]).is_dir()); assert!(workspace.join_many([~"lib", host_triple()]).is_dir());
assert_lib_exists(workspace, &Path::new("foo"), NoVersion); assert_lib_exists(workspace, &Path::init("foo"), NoVersion);
assert!(fs::readdir(&workspace.join("lib")).len() == 1); assert!(fs::readdir(&workspace.join("lib")).len() == 1);
assert!(workspace.join("bin").is_dir()); assert!(workspace.join("bin").is_dir());
assert_executable_exists(workspace, "foo"); assert_executable_exists(workspace, "foo");
@ -2059,7 +2060,7 @@ fn correct_package_name_with_rust_path_hack() {
let bar_id = PkgId::new("bar"); let bar_id = PkgId::new("bar");
let foo_workspace = create_local_package(&foo_id); let foo_workspace = create_local_package(&foo_id);
let foo_workspace = foo_workspace.path(); let foo_workspace = foo_workspace.path();
let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace"); let dest_workspace = mk_empty_workspace(&Path::init("bar"), &NoVersion, "dest_workspace");
let dest_workspace = dest_workspace.path(); let dest_workspace = dest_workspace.path();
writeFile(&dest_workspace.join_many(["src", "bar-0.1", "main.rs"]), writeFile(&dest_workspace.join_many(["src", "bar-0.1", "main.rs"]),
@ -2315,6 +2316,7 @@ fn find_sources_in_cwd() {
} }
#[test] #[test]
#[ignore(reason="busted")]
fn test_c_dependency_ok() { fn test_c_dependency_ok() {
// Pkg has a custom build script that adds a single C file as a dependency, and // Pkg has a custom build script that adds a single C file as a dependency, and
// registers a hook to build it if it's not fresh // registers a hook to build it if it's not fresh
@ -2328,7 +2330,7 @@ fn test_c_dependency_ok() {
writeFile(&dir.join_many(["src", "cdep-0.1", "foo.c"]), "void f() {}"); writeFile(&dir.join_many(["src", "cdep-0.1", "foo.c"]), "void f() {}");
debug!("dir = {}", dir.display()); debug!("dir = {}", dir.display());
let source = Path::new(file!()).dir_path().join_many( let source = Path::init(file!()).dir_path().join_many(
[~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]); [~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]);
fs::copy(&source, &dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"])); fs::copy(&source, &dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"]));
command_line_test([~"build", ~"cdep"], dir); command_line_test([~"build", ~"cdep"], dir);
@ -2340,6 +2342,7 @@ fn test_c_dependency_ok() {
} }
#[test] #[test]
#[ignore(reason="busted")]
fn test_c_dependency_no_rebuilding() { fn test_c_dependency_no_rebuilding() {
let dir = create_local_package(&PkgId::new("cdep")); let dir = create_local_package(&PkgId::new("cdep"));
let dir = dir.path(); let dir = dir.path();
@ -2349,7 +2352,7 @@ fn test_c_dependency_no_rebuilding() {
writeFile(&dir.join_many(["src", "cdep-0.1", "foo.c"]), "void f() {}"); writeFile(&dir.join_many(["src", "cdep-0.1", "foo.c"]), "void f() {}");
debug!("dir = {}", dir.display()); debug!("dir = {}", dir.display());
let source = Path::new(file!()).dir_path().join_many( let source = Path::init(file!()).dir_path().join_many(
[~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]); [~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]);
fs::copy(&source, &dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"])); fs::copy(&source, &dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"]));
command_line_test([~"build", ~"cdep"], dir); command_line_test([~"build", ~"cdep"], dir);
@ -2373,6 +2376,7 @@ fn test_c_dependency_no_rebuilding() {
} }
#[test] #[test]
#[ignore(reason="busted")]
fn test_c_dependency_yes_rebuilding() { fn test_c_dependency_yes_rebuilding() {
let dir = create_local_package(&PkgId::new("cdep")); let dir = create_local_package(&PkgId::new("cdep"));
let dir = dir.path(); let dir = dir.path();
@ -2382,7 +2386,7 @@ fn test_c_dependency_yes_rebuilding() {
let c_file_name = dir.join_many(["src", "cdep-0.1", "foo.c"]); let c_file_name = dir.join_many(["src", "cdep-0.1", "foo.c"]);
writeFile(&c_file_name, "void f() {}"); writeFile(&c_file_name, "void f() {}");
let source = Path::new(file!()).dir_path().join_many( let source = Path::init(file!()).dir_path().join_many(
[~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]); [~"testsuite", ~"pass", ~"src", ~"c-dependencies", ~"pkg.rs"]);
let target = dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"]); let target = dir.join_many([~"src", ~"cdep-0.1", ~"pkg.rs"]);
debug!("Copying {} -> {}", source.display(), target.display()); debug!("Copying {} -> {}", source.display(), target.display());

6
src/librustpkg/util.rs
View file

@ -511,7 +511,7 @@ impl<'self> Visitor<()> for ViewItemVisitor<'self> {
self.context.install( self.context.install(
pkg_src, pkg_src,
&WhatToBuild::new(Inferred, &WhatToBuild::new(Inferred,
JustOne(Path::new(lib_crate_filename)))); JustOne(Path::init(lib_crate_filename))));
debug!("Installed {}, returned {:?} dependencies and \ debug!("Installed {}, returned {:?} dependencies and \
{:?} transitive dependencies", {:?} transitive dependencies",
lib_name, outputs_disc.len(), inputs_disc.len()); lib_name, outputs_disc.len(), inputs_disc.len());
@ -549,7 +549,7 @@ impl<'self> Visitor<()> for ViewItemVisitor<'self> {
self.exec.discover_input(*what, self.exec.discover_input(*what,
*dep, *dep,
digest_file_with_date( digest_file_with_date(
&Path::new(dep.as_slice()))); &Path::init(dep.as_slice())));
} else if *what == ~"binary" { } else if *what == ~"binary" {
add_dep(self.deps, add_dep(self.deps,
self.parent_crate.as_str().unwrap().to_owned(), self.parent_crate.as_str().unwrap().to_owned(),
@ -557,7 +557,7 @@ impl<'self> Visitor<()> for ViewItemVisitor<'self> {
self.exec.discover_input(*what, self.exec.discover_input(*what,
*dep, *dep,
digest_only_date( digest_only_date(
&Path::new(dep.as_slice()))); &Path::init(dep.as_slice())));
} else { } else {
fail!("Bad kind: {}", *what); fail!("Bad kind: {}", *what);
} }

6
src/librustuv/file.rs
View file

@ -141,7 +141,7 @@ impl FsRequest {
}).map(|req| unsafe { }).map(|req| unsafe {
let mut paths = ~[]; let mut paths = ~[];
let path = CString::new(path.with_ref(|p| p), false); let path = CString::new(path.with_ref(|p| p), false);
let parent = Path::new(path); let parent = Path::init(path);
c_str::from_c_multistring(req.get_ptr() as *libc::c_char, c_str::from_c_multistring(req.get_ptr() as *libc::c_char,
Some(req.get_result() as uint), Some(req.get_result() as uint),
|rel| { |rel| {
@ -157,7 +157,7 @@ impl FsRequest {
uvll::uv_fs_readlink(loop_.handle, req, uvll::uv_fs_readlink(loop_.handle, req,
path.with_ref(|p| p), cb) path.with_ref(|p| p), cb)
}).map(|req| { }).map(|req| {
Path::new(unsafe { Path::init(unsafe {
CString::new(req.get_ptr() as *libc::c_char, false) CString::new(req.get_ptr() as *libc::c_char, false)
}) })
}) })
@ -245,7 +245,7 @@ impl FsRequest {
pub fn mkstat(&self) -> FileStat { pub fn mkstat(&self) -> FileStat {
let path = unsafe { uvll::get_path_from_fs_req(self.req) }; let path = unsafe { uvll::get_path_from_fs_req(self.req) };
let path = unsafe { Path::new(CString::new(path, false)) }; let path = unsafe { Path::init(CString::new(path, false)) };
let stat = self.get_stat(); let stat = self.get_stat();
fn to_msec(stat: uvll::uv_timespec_t) -> u64 { fn to_msec(stat: uvll::uv_timespec_t) -> u64 {
// Be sure to cast to u64 first to prevent overflowing if the tv_sec // Be sure to cast to u64 first to prevent overflowing if the tv_sec

48
src/libstd/io/fs.rs
View file

@ -29,7 +29,7 @@ particular bits of it, etc.
use std::io::{File, fs}; use std::io::{File, fs};
let path = Path::new("foo.txt"); let path = Path::init("foo.txt");
// create the file, whether it exists or not // create the file, whether it exists or not
let mut file = File::create(&path); let mut file = File::create(&path);
@ -40,7 +40,7 @@ particular bits of it, etc.
file.read_to_end(); file.read_to_end();
println!("{}", path.stat().size); println!("{}", path.stat().size);
fs::symlink(&path, &Path::new("bar.txt")); fs::symlink(&path, &Path::init("bar.txt"));
fs::unlink(&path); fs::unlink(&path);
*/ */
@ -95,7 +95,7 @@ impl File {
/// ///
/// use std::io::{File, io_error, Open, ReadWrite}; /// use std::io::{File, io_error, Open, ReadWrite};
/// ///
/// let p = Path::new("/some/file/path.txt"); /// let p = Path::init("/some/file/path.txt");
/// ///
/// io_error::cond.trap(|_| { /// io_error::cond.trap(|_| {
/// // hoo-boy... /// // hoo-boy...
@ -157,7 +157,7 @@ impl File {
/// ///
/// use std::io::File; /// use std::io::File;
/// ///
/// let contents = File::open(&Path::new("foo.txt")).read_to_end(); /// let contents = File::open(&Path::init("foo.txt")).read_to_end();
pub fn open(path: &Path) -> Option<File> { pub fn open(path: &Path) -> Option<File> {
File::open_mode(path, Open, Read) File::open_mode(path, Open, Read)
} }
@ -172,7 +172,7 @@ impl File {
/// ///
/// use std::io::File; /// use std::io::File;
/// ///
/// let mut f = File::create(&Path::new("foo.txt")); /// let mut f = File::create(&Path::init("foo.txt"));
/// f.write(bytes!("This is a sample file")); /// f.write(bytes!("This is a sample file"));
pub fn create(path: &Path) -> Option<File> { pub fn create(path: &Path) -> Option<File> {
File::open_mode(path, Truncate, Write) File::open_mode(path, Truncate, Write)
@ -229,7 +229,7 @@ impl File {
/// ///
/// use std::io::fs; /// use std::io::fs;
/// ///
/// let p = Path::new("/some/file/path.txt"); /// let p = Path::init("/some/file/path.txt");
/// fs::unlink(&p); /// fs::unlink(&p);
/// // if we made it here without failing, then the /// // if we made it here without failing, then the
/// // unlink operation was successful /// // unlink operation was successful
@ -260,7 +260,7 @@ pub fn unlink(path: &Path) {
/// use std::io; /// use std::io;
/// use std::io::fs; /// use std::io::fs;
/// ///
/// let p = Path::new("/some/file/path.txt"); /// let p = Path::init("/some/file/path.txt");
/// match io::result(|| fs::stat(&p)) { /// match io::result(|| fs::stat(&p)) {
/// Ok(stat) => { /* ... */ } /// Ok(stat) => { /* ... */ }
/// Err(e) => { /* handle error */ } /// Err(e) => { /* handle error */ }
@ -277,7 +277,7 @@ pub fn stat(path: &Path) -> FileStat {
fn dummystat() -> FileStat { fn dummystat() -> FileStat {
FileStat { FileStat {
path: Path::new(""), path: Path::init(""),
size: 0, size: 0,
kind: io::TypeFile, kind: io::TypeFile,
perm: 0, perm: 0,
@ -317,7 +317,7 @@ pub fn lstat(path: &Path) -> FileStat {
/// ///
/// use std::io::fs; /// use std::io::fs;
/// ///
/// fs::rename(&Path::new("foo"), &Path::new("bar")); /// fs::rename(&Path::init("foo"), &Path::init("bar"));
/// // Oh boy, nothing was raised! /// // Oh boy, nothing was raised!
/// ///
/// # Errors /// # Errors
@ -339,7 +339,7 @@ pub fn rename(from: &Path, to: &Path) {
/// ///
/// use std::io::fs; /// use std::io::fs;
/// ///
/// fs::copy(&Path::new("foo.txt"), &Path::new("bar.txt")); /// fs::copy(&Path::init("foo.txt"), &Path::init("bar.txt"));
/// // Oh boy, nothing was raised! /// // Oh boy, nothing was raised!
/// ///
/// # Errors /// # Errors
@ -386,10 +386,10 @@ pub fn copy(from: &Path, to: &Path) {
/// use std::io; /// use std::io;
/// use std::io::fs; /// use std::io::fs;
/// ///
/// fs::chmod(&Path::new("file.txt"), io::UserFile); /// fs::chmod(&Path::init("file.txt"), io::UserFile);
/// fs::chmod(&Path::new("file.txt"), io::UserRead | io::UserWrite); /// fs::chmod(&Path::init("file.txt"), io::UserRead | io::UserWrite);
/// fs::chmod(&Path::new("dir"), io::UserDir); /// fs::chmod(&Path::init("dir"), io::UserDir);
/// fs::chmod(&Path::new("file.exe"), io::UserExec); /// fs::chmod(&Path::init("file.exe"), io::UserExec);
/// ///
/// # Errors /// # Errors
/// ///
@ -448,7 +448,7 @@ pub fn readlink(path: &Path) -> Option<Path> {
/// use std::libc::S_IRWXU; /// use std::libc::S_IRWXU;
/// use std::io::fs; /// use std::io::fs;
/// ///
/// let p = Path::new("/some/dir"); /// let p = Path::init("/some/dir");
/// fs::mkdir(&p, S_IRWXU as int); /// fs::mkdir(&p, S_IRWXU as int);
/// // If we got here, our directory exists! Horray! /// // If we got here, our directory exists! Horray!
/// ///
@ -467,7 +467,7 @@ pub fn mkdir(path: &Path, mode: FilePermission) {
/// ///
/// use std::io::fs; /// use std::io::fs;
/// ///
/// let p = Path::new("/some/dir"); /// let p = Path::init("/some/dir");
/// fs::rmdir(&p); /// fs::rmdir(&p);
/// // good riddance, you mean ol' directory /// // good riddance, you mean ol' directory
/// ///
@ -990,12 +990,12 @@ mod test {
}) })
test!(fn recursive_mkdir_slash() { test!(fn recursive_mkdir_slash() {
mkdir_recursive(&Path::new("/"), io::UserRWX); mkdir_recursive(&Path::init("/"), io::UserRWX);
}) })
test!(fn unicode_path_is_dir() { test!(fn unicode_path_is_dir() {
assert!(Path::new(".").is_dir()); assert!(Path::init(".").is_dir());
assert!(!Path::new("test/stdtest/fs.rs").is_dir()); assert!(!Path::init("test/stdtest/fs.rs").is_dir());
let tmpdir = tmpdir(); let tmpdir = tmpdir();
@ -1012,20 +1012,20 @@ mod test {
}) })
test!(fn unicode_path_exists() { test!(fn unicode_path_exists() {
assert!(Path::new(".").exists()); assert!(Path::init(".").exists());
assert!(!Path::new("test/nonexistent-bogus-path").exists()); assert!(!Path::init("test/nonexistent-bogus-path").exists());
let tmpdir = tmpdir(); let tmpdir = tmpdir();
let unicode = tmpdir.clone(); let unicode = tmpdir.clone();
let unicode = unicode.join(format!("test-각丁ー再见")); let unicode = unicode.join(format!("test-각丁ー再见"));
mkdir(&unicode, io::UserRWX); mkdir(&unicode, io::UserRWX);
assert!(unicode.exists()); assert!(unicode.exists());
assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists()); assert!(!Path::init("test/unicode-bogus-path-각丁ー再见").exists());
}) })
test!(fn copy_file_does_not_exist() { test!(fn copy_file_does_not_exist() {
let from = Path::new("test/nonexistent-bogus-path"); let from = Path::init("test/nonexistent-bogus-path");
let to = Path::new("test/other-bogus-path"); let to = Path::init("test/other-bogus-path");
match io::result(|| copy(&from, &to)) { match io::result(|| copy(&from, &to)) {
Ok(..) => fail!(), Ok(..) => fail!(),
Err(..) => { Err(..) => {

2
src/libstd/io/mod.rs
View file

@ -450,7 +450,7 @@ pub trait Reader {
/// ///
/// # Example /// # Example
/// ///
/// let reader = File::open(&Path::new("foo.txt")) /// let reader = File::open(&Path::init("foo.txt"))
/// while !reader.eof() { /// while !reader.eof() {
/// println(reader.read_line()); /// println(reader.read_line());
/// } /// }

17
src/libstd/io/native/file.rs
View file

@ -278,6 +278,7 @@ impl rtio::RtioFileStream for FileDesc {
self.seek(orig_pos as i64, io::SeekSet); self.seek(orig_pos as i64, io::SeekSet);
return ret; return ret;
} }
#[cfg(unix)] #[cfg(unix)]
fn truncate(&mut self, offset: i64) -> Result<(), IoError> { fn truncate(&mut self, offset: i64) -> Result<(), IoError> {
super::mkerr_libc(unsafe { super::mkerr_libc(unsafe {
@ -480,7 +481,7 @@ pub fn mkdir(p: &CString, mode: io::FilePermission) -> IoResult<()> {
pub fn readdir(p: &CString) -> IoResult<~[Path]> { pub fn readdir(p: &CString) -> IoResult<~[Path]> {
fn prune(root: &CString, dirs: ~[Path]) -> ~[Path] { fn prune(root: &CString, dirs: ~[Path]) -> ~[Path] {
let root = unsafe { CString::new(root.with_ref(|p| p), false) }; let root = unsafe { CString::new(root.with_ref(|p| p), false) };
let root = Path::new(root); let root = Path::init(root);
dirs.move_iter().filter(|path| { dirs.move_iter().filter(|path| {
path.as_vec() != bytes!(".") && path.as_vec() != bytes!("..") path.as_vec() != bytes!(".") && path.as_vec() != bytes!("..")
@ -505,7 +506,7 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> {
let mut entry_ptr = readdir(dir_ptr); let mut entry_ptr = readdir(dir_ptr);
while (entry_ptr as uint != 0) { while (entry_ptr as uint != 0) {
let cstr = CString::new(rust_list_dir_val(entry_ptr), false); let cstr = CString::new(rust_list_dir_val(entry_ptr), false);
paths.push(Path::new(cstr)); paths.push(Path::init(cstr));
entry_ptr = readdir(dir_ptr); entry_ptr = readdir(dir_ptr);
} }
closedir(dir_ptr); closedir(dir_ptr);
@ -536,7 +537,7 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> {
fn rust_list_dir_wfd_fp_buf(wfd: *libc::c_void) -> *u16; fn rust_list_dir_wfd_fp_buf(wfd: *libc::c_void) -> *u16;
} }
let p = CString::new(p.with_ref(|p| p), false); let p = CString::new(p.with_ref(|p| p), false);
let p = Path::new(p); let p = Path::init(p);
let star = p.join("*"); let star = p.join("*");
as_utf16_p(star.as_str().unwrap(), |path_ptr| { as_utf16_p(star.as_str().unwrap(), |path_ptr| {
let wfd_ptr = malloc_raw(rust_list_dir_wfd_size() as uint); let wfd_ptr = malloc_raw(rust_list_dir_wfd_size() as uint);
@ -553,7 +554,7 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> {
let fp_vec = vec::from_buf( let fp_vec = vec::from_buf(
fp_buf, wcslen(fp_buf) as uint); fp_buf, wcslen(fp_buf) as uint);
let fp_str = str::from_utf16(fp_vec); let fp_str = str::from_utf16(fp_vec);
paths.push(Path::new(fp_str)); paths.push(Path::init(fp_str));
} }
more_files = FindNextFileW(find_handle, wfd_ptr as HANDLE); more_files = FindNextFileW(find_handle, wfd_ptr as HANDLE);
} }
@ -683,7 +684,7 @@ pub fn readlink(p: &CString) -> IoResult<Path> {
} }
}); });
let ret = match ret { let ret = match ret {
Some(s) => Ok(Path::new(s)), Some(s) => Ok(Path::init(s)),
None => Err(super::last_error()), None => Err(super::last_error()),
}; };
unsafe { libc::CloseHandle(handle) }; unsafe { libc::CloseHandle(handle) };
@ -707,7 +708,7 @@ pub fn readlink(p: &CString) -> IoResult<Path> {
n => { n => {
assert!(n > 0); assert!(n > 0);
unsafe { vec::raw::set_len(&mut buf, n as uint); } unsafe { vec::raw::set_len(&mut buf, n as uint); }
Ok(Path::new(buf)) Ok(Path::init(buf))
} }
} }
} }
@ -770,7 +771,7 @@ fn mkstat(stat: &libc::stat, path: &CString) -> io::FileStat {
}; };
io::FileStat { io::FileStat {
path: Path::new(path), path: Path::init(path),
size: stat.st_size as u64, size: stat.st_size as u64,
kind: kind, kind: kind,
perm: (stat.st_mode) as io::FilePermission & io::AllPermissions, perm: (stat.st_mode) as io::FilePermission & io::AllPermissions,
@ -819,7 +820,7 @@ fn mkstat(stat: &libc::stat, path: &CString) -> io::FileStat {
fn gen(_stat: &libc::stat) -> u64 { 0 } fn gen(_stat: &libc::stat) -> u64 { 0 }
io::FileStat { io::FileStat {
path: Path::new(path), path: Path::init(path),
size: stat.st_size as u64, size: stat.st_size as u64,
kind: kind, kind: kind,
perm: (stat.st_mode) as io::FilePermission & io::AllPermissions, perm: (stat.st_mode) as io::FilePermission & io::AllPermissions,

2
src/libstd/io/native/process.rs
View file

@ -95,7 +95,7 @@ impl Process {
let (err_pipe, err_fd) = get_io(config.io, &mut ret_io, 2); let (err_pipe, err_fd) = get_io(config.io, &mut ret_io, 2);
let env = config.env.map(|a| a.to_owned()); let env = config.env.map(|a| a.to_owned());
let cwd = config.cwd.map(|a| Path::new(a)); let cwd = config.cwd.map(|a| Path::init(a));
let res = spawn_process_os(config.program, config.args, env, let res = spawn_process_os(config.program, config.args, env,
cwd.as_ref(), in_fd, out_fd, err_fd); cwd.as_ref(), in_fd, out_fd, err_fd);

34
src/libstd/os.rs
View file

@ -64,7 +64,7 @@ pub fn getcwd() -> Path {
fail!() fail!()
} }
Path::new(CString::new(buf as *c_char, false)) Path::init(CString::new(buf as *c_char, false))
} }
}) })
} }
@ -81,7 +81,7 @@ pub fn getcwd() -> Path {
} }
} }
}); });
Path::new(str::from_utf16(buf)) Path::init(str::from_utf16(buf))
} }
#[cfg(windows)] #[cfg(windows)]
@ -384,7 +384,7 @@ pub fn self_exe_path() -> Option<Path> {
fn load_self() -> Option<~[u8]> { fn load_self() -> Option<~[u8]> {
use std::io; use std::io;
match io::result(|| io::fs::readlink(&Path::new("/proc/self/exe"))) { match io::result(|| io::fs::readlink(&Path::init("/proc/self/exe"))) {
Ok(Some(path)) => Some(path.as_vec().to_owned()), Ok(Some(path)) => Some(path.as_vec().to_owned()),
Ok(None) | Err(..) => None Ok(None) | Err(..) => None
} }
@ -418,7 +418,7 @@ pub fn self_exe_path() -> Option<Path> {
} }
} }
load_self().and_then(|path| Path::new_opt(path).map(|mut p| { p.pop(); p })) load_self().and_then(|path| Path::init_opt(path).map(|mut p| { p.pop(); p }))
} }
/** /**
@ -437,7 +437,7 @@ pub fn self_exe_path() -> Option<Path> {
pub fn homedir() -> Option<Path> { pub fn homedir() -> Option<Path> {
// FIXME (#7188): getenv needs a ~[u8] variant // FIXME (#7188): getenv needs a ~[u8] variant
return match getenv("HOME") { return match getenv("HOME") {
Some(ref p) if !p.is_empty() => Path::new_opt(p.as_slice()), Some(ref p) if !p.is_empty() => Path::init_opt(p.as_slice()),
_ => secondary() _ => secondary()
}; };
@ -450,7 +450,7 @@ pub fn homedir() -> Option<Path> {
fn secondary() -> Option<Path> { fn secondary() -> Option<Path> {
getenv("USERPROFILE").and_then(|p| { getenv("USERPROFILE").and_then(|p| {
if !p.is_empty() { if !p.is_empty() {
Path::new_opt(p) Path::init_opt(p)
} else { } else {
None None
} }
@ -479,7 +479,7 @@ pub fn tmpdir() -> Path {
if x.is_empty() { if x.is_empty() {
None None
} else { } else {
Path::new_opt(x) Path::init_opt(x)
}, },
_ => None _ => None
} }
@ -488,9 +488,9 @@ pub fn tmpdir() -> Path {
#[cfg(unix)] #[cfg(unix)]
fn lookup() -> Path { fn lookup() -> Path {
if cfg!(target_os = "android") { if cfg!(target_os = "android") {
Path::new("/data/tmp") Path::init("/data/tmp")
} else { } else {
getenv_nonempty("TMPDIR").unwrap_or(Path::new("/tmp")) getenv_nonempty("TMPDIR").unwrap_or(Path::init("/tmp"))
} }
} }
@ -499,7 +499,7 @@ pub fn tmpdir() -> Path {
getenv_nonempty("TMP").or( getenv_nonempty("TMP").or(
getenv_nonempty("TEMP").or( getenv_nonempty("TEMP").or(
getenv_nonempty("USERPROFILE").or( getenv_nonempty("USERPROFILE").or(
getenv_nonempty("WINDIR")))).unwrap_or(Path::new("C:\\Windows")) getenv_nonempty("WINDIR")))).unwrap_or(Path::init("C:\\Windows"))
} }
} }
@ -1366,13 +1366,13 @@ mod tests {
#[test] #[test]
fn test() { fn test() {
assert!((!Path::new("test-path").is_absolute())); assert!((!Path::init("test-path").is_absolute()));
let cwd = getcwd(); let cwd = getcwd();
debug!("Current working directory: {}", cwd.display()); debug!("Current working directory: {}", cwd.display());
debug!("{:?}", make_absolute(&Path::new("test-path"))); debug!("{:?}", make_absolute(&Path::init("test-path")));
debug!("{:?}", make_absolute(&Path::new("/usr/bin"))); debug!("{:?}", make_absolute(&Path::init("/usr/bin")));
} }
#[test] #[test]
@ -1381,7 +1381,7 @@ mod tests {
let oldhome = getenv("HOME"); let oldhome = getenv("HOME");
setenv("HOME", "/home/MountainView"); setenv("HOME", "/home/MountainView");
assert_eq!(os::homedir(), Some(Path::new("/home/MountainView"))); assert_eq!(os::homedir(), Some(Path::init("/home/MountainView")));
setenv("HOME", ""); setenv("HOME", "");
assert!(os::homedir().is_none()); assert!(os::homedir().is_none());
@ -1402,16 +1402,16 @@ mod tests {
assert!(os::homedir().is_none()); assert!(os::homedir().is_none());
setenv("HOME", "/home/MountainView"); setenv("HOME", "/home/MountainView");
assert_eq!(os::homedir(), Some(Path::new("/home/MountainView"))); assert_eq!(os::homedir(), Some(Path::init("/home/MountainView")));
setenv("HOME", ""); setenv("HOME", "");
setenv("USERPROFILE", "/home/MountainView"); setenv("USERPROFILE", "/home/MountainView");
assert_eq!(os::homedir(), Some(Path::new("/home/MountainView"))); assert_eq!(os::homedir(), Some(Path::init("/home/MountainView")));
setenv("HOME", "/home/MountainView"); setenv("HOME", "/home/MountainView");
setenv("USERPROFILE", "/home/PaloAlto"); setenv("USERPROFILE", "/home/PaloAlto");
assert_eq!(os::homedir(), Some(Path::new("/home/MountainView"))); assert_eq!(os::homedir(), Some(Path::init("/home/MountainView")));
for s in oldhome.iter() { setenv("HOME", *s) } for s in oldhome.iter() { setenv("HOME", *s) }
for s in olduserprofile.iter() { setenv("USERPROFILE", *s) } for s in olduserprofile.iter() { setenv("USERPROFILE", *s) }

26
src/libstd/path/mod.rs
View file

@ -32,8 +32,8 @@ no restriction on paths beyond disallowing NUL).
Usage of this module is fairly straightforward. Unless writing platform-specific Usage of this module is fairly straightforward. Unless writing platform-specific
code, `Path` should be used to refer to the platform-native path. code, `Path` should be used to refer to the platform-native path.
Creation of a path is typically done with either `Path::new(some_str)` or Creation of a path is typically done with either `Path::init(some_str)` or
`Path::new(some_vec)`. This path can be modified with `.push()` and `Path::init(some_vec)`. This path can be modified with `.push()` and
`.pop()` (and other setters). The resulting Path can either be passed to another `.pop()` (and other setters). The resulting Path can either be passed to another
API that expects a path, or can be turned into a &[u8] with `.as_vec()` or a API that expects a path, or can be turned into a &[u8] with `.as_vec()` or a
Option<&str> with `.as_str()`. Similarly, attributes of the path can be queried Option<&str> with `.as_str()`. Similarly, attributes of the path can be queried
@ -41,7 +41,7 @@ with methods such as `.filename()`. There are also methods that return a new
path instead of modifying the receiver, such as `.join()` or `.dir_path()`. path instead of modifying the receiver, such as `.join()` or `.dir_path()`.
Paths are always kept in normalized form. This means that creating the path Paths are always kept in normalized form. This means that creating the path
`Path::new("a/b/../c")` will return the path `a/c`. Similarly any attempt `Path::init("a/b/../c")` will return the path `a/c`. Similarly any attempt
to mutate the path will always leave it in normalized form. to mutate the path will always leave it in normalized form.
When rendering a path to some form of output, there is a method `.display()` When rendering a path to some form of output, there is a method `.display()`
@ -53,7 +53,7 @@ actually operates on the path; it is only intended for display.
## Example ## Example
```rust ```rust
let mut path = Path::new("/tmp/path"); let mut path = Path::from_str("/tmp/path");
debug!("path: {}", path.display()); debug!("path: {}", path.display());
path.set_filename("foo"); path.set_filename("foo");
path.push("bar"); path.push("bar");
@ -151,24 +151,24 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
/// ///
/// See individual Path impls for additional restrictions. /// See individual Path impls for additional restrictions.
#[inline] #[inline]
fn new<T: BytesContainer>(path: T) -> Self { fn init<T: BytesContainer>(path: T) -> Self {
if contains_nul(path.container_as_bytes()) { if contains_nul(path.container_as_bytes()) {
let path = self::null_byte::cond.raise(path.container_into_owned_bytes()); let path = self::null_byte::cond.raise(path.container_into_owned_bytes());
assert!(!contains_nul(path)); assert!(!contains_nul(path));
unsafe { GenericPathUnsafe::new_unchecked(path) } unsafe { GenericPathUnsafe::init_unchecked(path) }
} else { } else {
unsafe { GenericPathUnsafe::new_unchecked(path) } unsafe { GenericPathUnsafe::init_unchecked(path) }
} }
} }
/// Creates a new Path from a byte vector or string, if possible. /// Creates a new Path from a byte vector or string, if possible.
/// The resulting Path will always be normalized. /// The resulting Path will always be normalized.
#[inline] #[inline]
fn new_opt<T: BytesContainer>(path: T) -> Option<Self> { fn init_opt<T: BytesContainer>(path: T) -> Option<Self> {
if contains_nul(path.container_as_bytes()) { if contains_nul(path.container_as_bytes()) {
None None
} else { } else {
Some(unsafe { GenericPathUnsafe::new_unchecked(path) }) Some(unsafe { GenericPathUnsafe::init_unchecked(path) })
} }
} }
@ -382,7 +382,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
/// If `self` represents the root of the filesystem hierarchy, returns `self`. /// If `self` represents the root of the filesystem hierarchy, returns `self`.
fn dir_path(&self) -> Self { fn dir_path(&self) -> Self {
// self.dirname() returns a NUL-free vector // self.dirname() returns a NUL-free vector
unsafe { GenericPathUnsafe::new_unchecked(self.dirname()) } unsafe { GenericPathUnsafe::init_unchecked(self.dirname()) }
} }
/// Returns a Path that represents the filesystem root that `self` is rooted in. /// Returns a Path that represents the filesystem root that `self` is rooted in.
@ -510,7 +510,7 @@ pub trait BytesContainer {
pub trait GenericPathUnsafe { pub trait GenericPathUnsafe {
/// Creates a new Path without checking for null bytes. /// Creates a new Path without checking for null bytes.
/// The resulting Path will always be normalized. /// The resulting Path will always be normalized.
unsafe fn new_unchecked<T: BytesContainer>(path: T) -> Self; unsafe fn init_unchecked<T: BytesContainer>(path: T) -> Self;
/// Replaces the filename portion of the path without checking for null /// Replaces the filename portion of the path without checking for null
/// bytes. /// bytes.
@ -694,11 +694,11 @@ mod tests {
#[test] #[test]
fn test_cstring() { fn test_cstring() {
let input = "/foo/bar/baz"; let input = "/foo/bar/baz";
let path: PosixPath = PosixPath::new(input.to_c_str()); let path: PosixPath = PosixPath::init(input.to_c_str());
assert_eq!(path.as_vec(), input.as_bytes()); assert_eq!(path.as_vec(), input.as_bytes());
let input = r"\foo\bar\baz"; let input = r"\foo\bar\baz";
let path: WindowsPath = WindowsPath::new(input.to_c_str()); let path: WindowsPath = WindowsPath::init(input.to_c_str());
assert_eq!(path.as_str().unwrap(), input.as_slice()); assert_eq!(path.as_str().unwrap(), input.as_slice());
} }
} }

336
src/libstd/path/posix.rs
View file

@ -68,7 +68,7 @@ impl Eq for Path {
impl FromStr for Path { impl FromStr for Path {
fn from_str(s: &str) -> Option<Path> { fn from_str(s: &str) -> Option<Path> {
Path::new_opt(s) Path::init_opt(s)
} }
} }
@ -111,7 +111,7 @@ impl<'self> BytesContainer for &'self Path {
} }
impl GenericPathUnsafe for Path { impl GenericPathUnsafe for Path {
unsafe fn new_unchecked<T: BytesContainer>(path: T) -> Path { unsafe fn init_unchecked<T: BytesContainer>(path: T) -> Path {
let path = Path::normalize(path.container_as_bytes()); let path = Path::normalize(path.container_as_bytes());
assert!(!path.is_empty()); assert!(!path.is_empty());
let idx = path.rposition_elem(&sep_byte); let idx = path.rposition_elem(&sep_byte);
@ -218,7 +218,7 @@ impl GenericPath for Path {
fn root_path(&self) -> Option<Path> { fn root_path(&self) -> Option<Path> {
if self.is_absolute() { if self.is_absolute() {
Some(Path::new("/")) Some(Path::init("/"))
} else { } else {
None None
} }
@ -287,7 +287,7 @@ impl GenericPath for Path {
} }
} }
} }
Some(Path::new(comps.connect_vec(&sep_byte))) Some(Path::init(comps.connect_vec(&sep_byte)))
} }
} }
@ -314,14 +314,14 @@ impl Path {
/// ///
/// Raises the `null_byte` condition if the vector contains a NUL. /// Raises the `null_byte` condition if the vector contains a NUL.
#[inline] #[inline]
pub fn new<T: BytesContainer>(path: T) -> Path { pub fn init<T: BytesContainer>(path: T) -> Path {
GenericPath::new(path) GenericPath::init(path)
} }
/// Returns a new Path from a byte vector or string, if possible /// Returns a new Path from a byte vector or string, if possible
#[inline] #[inline]
pub fn new_opt<T: BytesContainer>(path: T) -> Option<Path> { pub fn init_opt<T: BytesContainer>(path: T) -> Option<Path> {
GenericPath::new_opt(path) GenericPath::init_opt(path)
} }
/// Returns a normalized byte vector representation of a path, by removing all empty /// Returns a normalized byte vector representation of a path, by removing all empty
@ -471,51 +471,51 @@ mod tests {
#[test] #[test]
fn test_paths() { fn test_paths() {
let empty: &[u8] = []; let empty: &[u8] = [];
t!(v: Path::new(empty), b!(".")); t!(v: Path::init(empty), b!("."));
t!(v: Path::new(b!("/")), b!("/")); t!(v: Path::init(b!("/")), b!("/"));
t!(v: Path::new(b!("a/b/c")), b!("a/b/c")); t!(v: Path::init(b!("a/b/c")), b!("a/b/c"));
t!(v: Path::new(b!("a/b/c", 0xff)), b!("a/b/c", 0xff)); t!(v: Path::init(b!("a/b/c", 0xff)), b!("a/b/c", 0xff));
t!(v: Path::new(b!(0xff, "/../foo", 0x80)), b!("foo", 0x80)); t!(v: Path::init(b!(0xff, "/../foo", 0x80)), b!("foo", 0x80));
let p = Path::new(b!("a/b/c", 0xff)); let p = Path::init(b!("a/b/c", 0xff));
assert_eq!(p.as_str(), None); assert_eq!(p.as_str(), None);
t!(s: Path::new(""), "."); t!(s: Path::init(""), ".");
t!(s: Path::new("/"), "/"); t!(s: Path::init("/"), "/");
t!(s: Path::new("hi"), "hi"); t!(s: Path::init("hi"), "hi");
t!(s: Path::new("hi/"), "hi"); t!(s: Path::init("hi/"), "hi");
t!(s: Path::new("/lib"), "/lib"); t!(s: Path::init("/lib"), "/lib");
t!(s: Path::new("/lib/"), "/lib"); t!(s: Path::init("/lib/"), "/lib");
t!(s: Path::new("hi/there"), "hi/there"); t!(s: Path::init("hi/there"), "hi/there");
t!(s: Path::new("hi/there.txt"), "hi/there.txt"); t!(s: Path::init("hi/there.txt"), "hi/there.txt");
t!(s: Path::new("hi/there/"), "hi/there"); t!(s: Path::init("hi/there/"), "hi/there");
t!(s: Path::new("hi/../there"), "there"); t!(s: Path::init("hi/../there"), "there");
t!(s: Path::new("../hi/there"), "../hi/there"); t!(s: Path::init("../hi/there"), "../hi/there");
t!(s: Path::new("/../hi/there"), "/hi/there"); t!(s: Path::init("/../hi/there"), "/hi/there");
t!(s: Path::new("foo/.."), "."); t!(s: Path::init("foo/.."), ".");
t!(s: Path::new("/foo/.."), "/"); t!(s: Path::init("/foo/.."), "/");
t!(s: Path::new("/foo/../.."), "/"); t!(s: Path::init("/foo/../.."), "/");
t!(s: Path::new("/foo/../../bar"), "/bar"); t!(s: Path::init("/foo/../../bar"), "/bar");
t!(s: Path::new("/./hi/./there/."), "/hi/there"); t!(s: Path::init("/./hi/./there/."), "/hi/there");
t!(s: Path::new("/./hi/./there/./.."), "/hi"); t!(s: Path::init("/./hi/./there/./.."), "/hi");
t!(s: Path::new("foo/../.."), ".."); t!(s: Path::init("foo/../.."), "..");
t!(s: Path::new("foo/../../.."), "../.."); t!(s: Path::init("foo/../../.."), "../..");
t!(s: Path::new("foo/../../bar"), "../bar"); t!(s: Path::init("foo/../../bar"), "../bar");
assert_eq!(Path::new(b!("foo/bar")).into_vec(), b!("foo/bar").to_owned()); assert_eq!(Path::init(b!("foo/bar")).into_vec(), b!("foo/bar").to_owned());
assert_eq!(Path::new(b!("/foo/../../bar")).into_vec(), assert_eq!(Path::init(b!("/foo/../../bar")).into_vec(),
b!("/bar").to_owned()); b!("/bar").to_owned());
let p = Path::new(b!("foo/bar", 0x80)); let p = Path::init(b!("foo/bar", 0x80));
assert_eq!(p.as_str(), None); assert_eq!(p.as_str(), None);
} }
#[test] #[test]
fn test_opt_paths() { fn test_opt_paths() {
assert_eq!(Path::new_opt(b!("foo/bar", 0)), None); assert_eq!(Path::init_opt(b!("foo/bar", 0)), None);
t!(v: Path::new_opt(b!("foo/bar")).unwrap(), b!("foo/bar")); t!(v: Path::init_opt(b!("foo/bar")).unwrap(), b!("foo/bar"));
assert_eq!(Path::new_opt("foo/bar\0"), None); assert_eq!(Path::init_opt("foo/bar\0"), None);
t!(s: Path::new_opt("foo/bar").unwrap(), "foo/bar"); t!(s: Path::init_opt("foo/bar").unwrap(), "foo/bar");
} }
#[test] #[test]
@ -528,7 +528,7 @@ mod tests {
assert_eq!(v.as_slice(), b!("foo/bar", 0)); assert_eq!(v.as_slice(), b!("foo/bar", 0));
(b!("/bar").to_owned()) (b!("/bar").to_owned())
}).inside(|| { }).inside(|| {
Path::new(b!("foo/bar", 0)) Path::init(b!("foo/bar", 0))
}); });
assert!(handled); assert!(handled);
assert_eq!(p.as_vec(), b!("/bar")); assert_eq!(p.as_vec(), b!("/bar"));
@ -576,12 +576,12 @@ mod tests {
cond.trap(|_| { cond.trap(|_| {
(b!("null", 0).to_owned()) (b!("null", 0).to_owned())
}).inside(|| { }).inside(|| {
Path::new(b!("foo/bar", 0)) Path::init(b!("foo/bar", 0))
}); });
}) })
t!(~"set_filename w/nul" => { t!(~"set_filename w/nul" => {
let mut p = Path::new(b!("foo/bar")); let mut p = Path::init(b!("foo/bar"));
cond.trap(|_| { cond.trap(|_| {
(b!("null", 0).to_owned()) (b!("null", 0).to_owned())
}).inside(|| { }).inside(|| {
@ -590,7 +590,7 @@ mod tests {
}) })
t!(~"push w/nul" => { t!(~"push w/nul" => {
let mut p = Path::new(b!("foo/bar")); let mut p = Path::init(b!("foo/bar"));
cond.trap(|_| { cond.trap(|_| {
(b!("null", 0).to_owned()) (b!("null", 0).to_owned())
}).inside(|| { }).inside(|| {
@ -604,7 +604,7 @@ mod tests {
macro_rules! t( macro_rules! t(
($path:expr, $disp:ident, $exp:expr) => ( ($path:expr, $disp:ident, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
assert_eq!(path.$disp().to_str(), ~$exp); assert_eq!(path.$disp().to_str(), ~$exp);
} }
) )
@ -620,7 +620,7 @@ mod tests {
($path:expr, $exp:expr) => ( ($path:expr, $exp:expr) => (
{ {
let mut called = false; let mut called = false;
let path = Path::new($path); let path = Path::init($path);
path.display().with_str(|s| { path.display().with_str(|s| {
assert_eq!(s, $exp); assert_eq!(s, $exp);
called = true; called = true;
@ -631,7 +631,7 @@ mod tests {
($path:expr, $exp:expr, filename) => ( ($path:expr, $exp:expr, filename) => (
{ {
let mut called = false; let mut called = false;
let path = Path::new($path); let path = Path::init($path);
path.filename_display().with_str(|s| { path.filename_display().with_str(|s| {
assert_eq!(s, $exp); assert_eq!(s, $exp);
called = true; called = true;
@ -654,7 +654,7 @@ mod tests {
macro_rules! t( macro_rules! t(
($path:expr, $exp:expr, $expf:expr) => ( ($path:expr, $exp:expr, $expf:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let f = format!("{}", path.display()); let f = format!("{}", path.display());
assert_eq!(f.as_slice(), $exp); assert_eq!(f.as_slice(), $exp);
let f = format!("{}", path.filename_display()); let f = format!("{}", path.filename_display());
@ -677,20 +677,20 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $op:ident, $exp:expr) => ( (s: $path:expr, $op:ident, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
assert_eq!(path.$op(), ($exp).as_bytes()); assert_eq!(path.$op(), ($exp).as_bytes());
} }
); );
(s: $path:expr, $op:ident, $exp:expr, opt) => ( (s: $path:expr, $op:ident, $exp:expr, opt) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let left = path.$op().map(|x| str::from_utf8_slice(x)); let left = path.$op().map(|x| str::from_utf8_slice(x));
assert_eq!(left, $exp); assert_eq!(left, $exp);
} }
); );
(v: $path:expr, $op:ident, $exp:expr) => ( (v: $path:expr, $op:ident, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
assert_eq!(path.$op(), $exp); assert_eq!(path.$op(), $exp);
} }
); );
@ -762,7 +762,7 @@ mod tests {
{ {
let path = ($path); let path = ($path);
let join = ($join); let join = ($join);
let mut p1 = Path::new(path); let mut p1 = Path::init(path);
let p2 = p1.clone(); let p2 = p1.clone();
p1.push(join); p1.push(join);
assert_eq!(p1, p2.join(join)); assert_eq!(p1, p2.join(join));
@ -781,8 +781,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $push:expr, $exp:expr) => ( (s: $path:expr, $push:expr, $exp:expr) => (
{ {
let mut p = Path::new($path); let mut p = Path::init($path);
let push = Path::new($push); let push = Path::init($push);
p.push(&push); p.push(&push);
assert_eq!(p.as_str(), Some($exp)); assert_eq!(p.as_str(), Some($exp));
} }
@ -804,14 +804,14 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $push:expr, $exp:expr) => ( (s: $path:expr, $push:expr, $exp:expr) => (
{ {
let mut p = Path::new($path); let mut p = Path::init($path);
p.push_many($push); p.push_many($push);
assert_eq!(p.as_str(), Some($exp)); assert_eq!(p.as_str(), Some($exp));
} }
); );
(v: $path:expr, $push:expr, $exp:expr) => ( (v: $path:expr, $push:expr, $exp:expr) => (
{ {
let mut p = Path::new($path); let mut p = Path::init($path);
p.push_many($push); p.push_many($push);
assert_eq!(p.as_vec(), $exp); assert_eq!(p.as_vec(), $exp);
} }
@ -835,7 +835,7 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $left:expr, $right:expr) => ( (s: $path:expr, $left:expr, $right:expr) => (
{ {
let mut p = Path::new($path); let mut p = Path::init($path);
let result = p.pop(); let result = p.pop();
assert_eq!(p.as_str(), Some($left)); assert_eq!(p.as_str(), Some($left));
assert_eq!(result, $right); assert_eq!(result, $right);
@ -843,7 +843,7 @@ mod tests {
); );
(v: [$($path:expr),+], [$($left:expr),+], $right:expr) => ( (v: [$($path:expr),+], [$($left:expr),+], $right:expr) => (
{ {
let mut p = Path::new(b!($($path),+)); let mut p = Path::init(b!($($path),+));
let result = p.pop(); let result = p.pop();
assert_eq!(p.as_vec(), b!($($left),+)); assert_eq!(p.as_vec(), b!($($left),+));
assert_eq!(result, $right); assert_eq!(result, $right);
@ -869,21 +869,21 @@ mod tests {
#[test] #[test]
fn test_root_path() { fn test_root_path() {
assert_eq!(Path::new(b!("a/b/c")).root_path(), None); assert_eq!(Path::init(b!("a/b/c")).root_path(), None);
assert_eq!(Path::new(b!("/a/b/c")).root_path(), Some(Path::new("/"))); assert_eq!(Path::init(b!("/a/b/c")).root_path(), Some(Path::init("/")));
} }
#[test] #[test]
fn test_join() { fn test_join() {
t!(v: Path::new(b!("a/b/c")).join(b!("..")), b!("a/b")); t!(v: Path::init(b!("a/b/c")).join(b!("..")), b!("a/b"));
t!(v: Path::new(b!("/a/b/c")).join(b!("d")), b!("/a/b/c/d")); t!(v: Path::init(b!("/a/b/c")).join(b!("d")), b!("/a/b/c/d"));
t!(v: Path::new(b!("a/", 0x80, "/c")).join(b!(0xff)), b!("a/", 0x80, "/c/", 0xff)); t!(v: Path::init(b!("a/", 0x80, "/c")).join(b!(0xff)), b!("a/", 0x80, "/c/", 0xff));
t!(s: Path::new("a/b/c").join(".."), "a/b"); t!(s: Path::init("a/b/c").join(".."), "a/b");
t!(s: Path::new("/a/b/c").join("d"), "/a/b/c/d"); t!(s: Path::init("/a/b/c").join("d"), "/a/b/c/d");
t!(s: Path::new("a/b").join("c/d"), "a/b/c/d"); t!(s: Path::init("a/b").join("c/d"), "a/b/c/d");
t!(s: Path::new("a/b").join("/c/d"), "/c/d"); t!(s: Path::init("a/b").join("/c/d"), "/c/d");
t!(s: Path::new(".").join("a/b"), "a/b"); t!(s: Path::init(".").join("a/b"), "a/b");
t!(s: Path::new("/").join("a/b"), "/a/b"); t!(s: Path::init("/").join("a/b"), "/a/b");
} }
#[test] #[test]
@ -891,8 +891,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $join:expr, $exp:expr) => ( (s: $path:expr, $join:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let join = Path::new($join); let join = Path::init($join);
let res = path.join(&join); let res = path.join(&join);
assert_eq!(res.as_str(), Some($exp)); assert_eq!(res.as_str(), Some($exp));
} }
@ -914,14 +914,14 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $join:expr, $exp:expr) => ( (s: $path:expr, $join:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let res = path.join_many($join); let res = path.join_many($join);
assert_eq!(res.as_str(), Some($exp)); assert_eq!(res.as_str(), Some($exp));
} }
); );
(v: $path:expr, $join:expr, $exp:expr) => ( (v: $path:expr, $join:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let res = path.join_many($join); let res = path.join_many($join);
assert_eq!(res.as_vec(), $exp); assert_eq!(res.as_vec(), $exp);
} }
@ -943,51 +943,51 @@ mod tests {
fn test_with_helpers() { fn test_with_helpers() {
let empty: &[u8] = []; let empty: &[u8] = [];
t!(v: Path::new(b!("a/b/c")).with_filename(b!("d")), b!("a/b/d")); t!(v: Path::init(b!("a/b/c")).with_filename(b!("d")), b!("a/b/d"));
t!(v: Path::new(b!("a/b/c", 0xff)).with_filename(b!(0x80)), b!("a/b/", 0x80)); t!(v: Path::init(b!("a/b/c", 0xff)).with_filename(b!(0x80)), b!("a/b/", 0x80));
t!(v: Path::new(b!("/", 0xff, "/foo")).with_filename(b!(0xcd)), t!(v: Path::init(b!("/", 0xff, "/foo")).with_filename(b!(0xcd)),
b!("/", 0xff, "/", 0xcd)); b!("/", 0xff, "/", 0xcd));
t!(s: Path::new("a/b/c").with_filename("d"), "a/b/d"); t!(s: Path::init("a/b/c").with_filename("d"), "a/b/d");
t!(s: Path::new(".").with_filename("foo"), "foo"); t!(s: Path::init(".").with_filename("foo"), "foo");
t!(s: Path::new("/a/b/c").with_filename("d"), "/a/b/d"); t!(s: Path::init("/a/b/c").with_filename("d"), "/a/b/d");
t!(s: Path::new("/").with_filename("foo"), "/foo"); t!(s: Path::init("/").with_filename("foo"), "/foo");
t!(s: Path::new("/a").with_filename("foo"), "/foo"); t!(s: Path::init("/a").with_filename("foo"), "/foo");
t!(s: Path::new("foo").with_filename("bar"), "bar"); t!(s: Path::init("foo").with_filename("bar"), "bar");
t!(s: Path::new("/").with_filename("foo/"), "/foo"); t!(s: Path::init("/").with_filename("foo/"), "/foo");
t!(s: Path::new("/a").with_filename("foo/"), "/foo"); t!(s: Path::init("/a").with_filename("foo/"), "/foo");
t!(s: Path::new("a/b/c").with_filename(""), "a/b"); t!(s: Path::init("a/b/c").with_filename(""), "a/b");
t!(s: Path::new("a/b/c").with_filename("."), "a/b"); t!(s: Path::init("a/b/c").with_filename("."), "a/b");
t!(s: Path::new("a/b/c").with_filename(".."), "a"); t!(s: Path::init("a/b/c").with_filename(".."), "a");
t!(s: Path::new("/a").with_filename(""), "/"); t!(s: Path::init("/a").with_filename(""), "/");
t!(s: Path::new("foo").with_filename(""), "."); t!(s: Path::init("foo").with_filename(""), ".");
t!(s: Path::new("a/b/c").with_filename("d/e"), "a/b/d/e"); t!(s: Path::init("a/b/c").with_filename("d/e"), "a/b/d/e");
t!(s: Path::new("a/b/c").with_filename("/d"), "a/b/d"); t!(s: Path::init("a/b/c").with_filename("/d"), "a/b/d");
t!(s: Path::new("..").with_filename("foo"), "../foo"); t!(s: Path::init("..").with_filename("foo"), "../foo");
t!(s: Path::new("../..").with_filename("foo"), "../../foo"); t!(s: Path::init("../..").with_filename("foo"), "../../foo");
t!(s: Path::new("..").with_filename(""), ".."); t!(s: Path::init("..").with_filename(""), "..");
t!(s: Path::new("../..").with_filename(""), "../.."); t!(s: Path::init("../..").with_filename(""), "../..");
t!(v: Path::new(b!("hi/there", 0x80, ".txt")).with_extension(b!("exe")), t!(v: Path::init(b!("hi/there", 0x80, ".txt")).with_extension(b!("exe")),
b!("hi/there", 0x80, ".exe")); b!("hi/there", 0x80, ".exe"));
t!(v: Path::new(b!("hi/there.txt", 0x80)).with_extension(b!(0xff)), t!(v: Path::init(b!("hi/there.txt", 0x80)).with_extension(b!(0xff)),
b!("hi/there.", 0xff)); b!("hi/there.", 0xff));
t!(v: Path::new(b!("hi/there", 0x80)).with_extension(b!(0xff)), t!(v: Path::init(b!("hi/there", 0x80)).with_extension(b!(0xff)),
b!("hi/there", 0x80, ".", 0xff)); b!("hi/there", 0x80, ".", 0xff));
t!(v: Path::new(b!("hi/there.", 0xff)).with_extension(empty), b!("hi/there")); t!(v: Path::init(b!("hi/there.", 0xff)).with_extension(empty), b!("hi/there"));
t!(s: Path::new("hi/there.txt").with_extension("exe"), "hi/there.exe"); t!(s: Path::init("hi/there.txt").with_extension("exe"), "hi/there.exe");
t!(s: Path::new("hi/there.txt").with_extension(""), "hi/there"); t!(s: Path::init("hi/there.txt").with_extension(""), "hi/there");
t!(s: Path::new("hi/there.txt").with_extension("."), "hi/there.."); t!(s: Path::init("hi/there.txt").with_extension("."), "hi/there..");
t!(s: Path::new("hi/there.txt").with_extension(".."), "hi/there..."); t!(s: Path::init("hi/there.txt").with_extension(".."), "hi/there...");
t!(s: Path::new("hi/there").with_extension("txt"), "hi/there.txt"); t!(s: Path::init("hi/there").with_extension("txt"), "hi/there.txt");
t!(s: Path::new("hi/there").with_extension("."), "hi/there.."); t!(s: Path::init("hi/there").with_extension("."), "hi/there..");
t!(s: Path::new("hi/there").with_extension(".."), "hi/there..."); t!(s: Path::init("hi/there").with_extension(".."), "hi/there...");
t!(s: Path::new("hi/there.").with_extension("txt"), "hi/there.txt"); t!(s: Path::init("hi/there.").with_extension("txt"), "hi/there.txt");
t!(s: Path::new("hi/.foo").with_extension("txt"), "hi/.foo.txt"); t!(s: Path::init("hi/.foo").with_extension("txt"), "hi/.foo.txt");
t!(s: Path::new("hi/there.txt").with_extension(".foo"), "hi/there..foo"); t!(s: Path::init("hi/there.txt").with_extension(".foo"), "hi/there..foo");
t!(s: Path::new("/").with_extension("txt"), "/"); t!(s: Path::init("/").with_extension("txt"), "/");
t!(s: Path::new("/").with_extension("."), "/"); t!(s: Path::init("/").with_extension("."), "/");
t!(s: Path::new("/").with_extension(".."), "/"); t!(s: Path::init("/").with_extension(".."), "/");
t!(s: Path::new(".").with_extension("txt"), "."); t!(s: Path::init(".").with_extension("txt"), ".");
} }
#[test] #[test]
@ -997,9 +997,9 @@ mod tests {
{ {
let path = $path; let path = $path;
let arg = $arg; let arg = $arg;
let mut p1 = Path::new(path); let mut p1 = Path::init(path);
p1.$set(arg); p1.$set(arg);
let p2 = Path::new(path); let p2 = Path::init(path);
assert_eq!(p1, p2.$with(arg)); assert_eq!(p1, p2.$with(arg));
} }
); );
@ -1007,9 +1007,9 @@ mod tests {
{ {
let path = $path; let path = $path;
let arg = $arg; let arg = $arg;
let mut p1 = Path::new(path); let mut p1 = Path::init(path);
p1.$set(arg); p1.$set(arg);
let p2 = Path::new(path); let p2 = Path::init(path);
assert_eq!(p1, p2.$with(arg)); assert_eq!(p1, p2.$with(arg));
} }
) )
@ -1069,39 +1069,39 @@ mod tests {
) )
) )
t!(v: Path::new(b!("a/b/c")), Some(b!("c")), b!("a/b"), Some(b!("c")), None); t!(v: Path::init(b!("a/b/c")), Some(b!("c")), b!("a/b"), Some(b!("c")), None);
t!(v: Path::new(b!("a/b/", 0xff)), Some(b!(0xff)), b!("a/b"), Some(b!(0xff)), None); t!(v: Path::init(b!("a/b/", 0xff)), Some(b!(0xff)), b!("a/b"), Some(b!(0xff)), None);
t!(v: Path::new(b!("hi/there.", 0xff)), Some(b!("there.", 0xff)), b!("hi"), t!(v: Path::init(b!("hi/there.", 0xff)), Some(b!("there.", 0xff)), b!("hi"),
Some(b!("there")), Some(b!(0xff))); Some(b!("there")), Some(b!(0xff)));
t!(s: Path::new("a/b/c"), Some("c"), Some("a/b"), Some("c"), None); t!(s: Path::init("a/b/c"), Some("c"), Some("a/b"), Some("c"), None);
t!(s: Path::new("."), None, Some("."), None, None); t!(s: Path::init("."), None, Some("."), None, None);
t!(s: Path::new("/"), None, Some("/"), None, None); t!(s: Path::init("/"), None, Some("/"), None, None);
t!(s: Path::new(".."), None, Some(".."), None, None); t!(s: Path::init(".."), None, Some(".."), None, None);
t!(s: Path::new("../.."), None, Some("../.."), None, None); t!(s: Path::init("../.."), None, Some("../.."), None, None);
t!(s: Path::new("hi/there.txt"), Some("there.txt"), Some("hi"), t!(s: Path::init("hi/there.txt"), Some("there.txt"), Some("hi"),
Some("there"), Some("txt")); Some("there"), Some("txt"));
t!(s: Path::new("hi/there"), Some("there"), Some("hi"), Some("there"), None); t!(s: Path::init("hi/there"), Some("there"), Some("hi"), Some("there"), None);
t!(s: Path::new("hi/there."), Some("there."), Some("hi"), t!(s: Path::init("hi/there."), Some("there."), Some("hi"),
Some("there"), Some("")); Some("there"), Some(""));
t!(s: Path::new("hi/.there"), Some(".there"), Some("hi"), Some(".there"), None); t!(s: Path::init("hi/.there"), Some(".there"), Some("hi"), Some(".there"), None);
t!(s: Path::new("hi/..there"), Some("..there"), Some("hi"), t!(s: Path::init("hi/..there"), Some("..there"), Some("hi"),
Some("."), Some("there")); Some("."), Some("there"));
t!(s: Path::new(b!("a/b/", 0xff)), None, Some("a/b"), None, None); t!(s: Path::init(b!("a/b/", 0xff)), None, Some("a/b"), None, None);
t!(s: Path::new(b!("a/b/", 0xff, ".txt")), None, Some("a/b"), None, Some("txt")); t!(s: Path::init(b!("a/b/", 0xff, ".txt")), None, Some("a/b"), None, Some("txt"));
t!(s: Path::new(b!("a/b/c.", 0x80)), None, Some("a/b"), Some("c"), None); t!(s: Path::init(b!("a/b/c.", 0x80)), None, Some("a/b"), Some("c"), None);
t!(s: Path::new(b!(0xff, "/b")), Some("b"), None, Some("b"), None); t!(s: Path::init(b!(0xff, "/b")), Some("b"), None, Some("b"), None);
} }
#[test] #[test]
fn test_dir_path() { fn test_dir_path() {
t!(v: Path::new(b!("hi/there", 0x80)).dir_path(), b!("hi")); t!(v: Path::init(b!("hi/there", 0x80)).dir_path(), b!("hi"));
t!(v: Path::new(b!("hi", 0xff, "/there")).dir_path(), b!("hi", 0xff)); t!(v: Path::init(b!("hi", 0xff, "/there")).dir_path(), b!("hi", 0xff));
t!(s: Path::new("hi/there").dir_path(), "hi"); t!(s: Path::init("hi/there").dir_path(), "hi");
t!(s: Path::new("hi").dir_path(), "."); t!(s: Path::init("hi").dir_path(), ".");
t!(s: Path::new("/hi").dir_path(), "/"); t!(s: Path::init("/hi").dir_path(), "/");
t!(s: Path::new("/").dir_path(), "/"); t!(s: Path::init("/").dir_path(), "/");
t!(s: Path::new("..").dir_path(), ".."); t!(s: Path::init("..").dir_path(), "..");
t!(s: Path::new("../..").dir_path(), "../.."); t!(s: Path::init("../..").dir_path(), "../..");
} }
#[test] #[test]
@ -1109,7 +1109,7 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $abs:expr, $rel:expr) => ( (s: $path:expr, $abs:expr, $rel:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
assert_eq!(path.is_absolute(), $abs); assert_eq!(path.is_absolute(), $abs);
assert_eq!(path.is_relative(), $rel); assert_eq!(path.is_relative(), $rel);
} }
@ -1130,8 +1130,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $dest:expr, $exp:expr) => ( (s: $path:expr, $dest:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let dest = Path::new($dest); let dest = Path::init($dest);
assert_eq!(path.is_ancestor_of(&dest), $exp); assert_eq!(path.is_ancestor_of(&dest), $exp);
} }
) )
@ -1164,15 +1164,15 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $child:expr, $exp:expr) => ( (s: $path:expr, $child:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let child = Path::new($child); let child = Path::init($child);
assert_eq!(path.ends_with_path(&child), $exp); assert_eq!(path.ends_with_path(&child), $exp);
} }
); );
(v: $path:expr, $child:expr, $exp:expr) => ( (v: $path:expr, $child:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let child = Path::new($child); let child = Path::init($child);
assert_eq!(path.ends_with_path(&child), $exp); assert_eq!(path.ends_with_path(&child), $exp);
} }
) )
@ -1203,8 +1203,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $other:expr, $exp:expr) => ( (s: $path:expr, $other:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let other = Path::new($other); let other = Path::init($other);
let res = path.path_relative_from(&other); let res = path.path_relative_from(&other);
assert_eq!(res.as_ref().and_then(|x| x.as_str()), $exp); assert_eq!(res.as_ref().and_then(|x| x.as_str()), $exp);
} }
@ -1248,7 +1248,7 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $exp:expr) => ( (s: $path:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let comps = path.components().to_owned_vec(); let comps = path.components().to_owned_vec();
let exp: &[&str] = $exp; let exp: &[&str] = $exp;
let exps = exp.iter().map(|x| x.as_bytes()).to_owned_vec(); let exps = exp.iter().map(|x| x.as_bytes()).to_owned_vec();
@ -1262,7 +1262,7 @@ mod tests {
); );
(v: [$($arg:expr),+], [$([$($exp:expr),*]),*]) => ( (v: [$($arg:expr),+], [$([$($exp:expr),*]),*]) => (
{ {
let path = Path::new(b!($($arg),+)); let path = Path::init(b!($($arg),+));
let comps = path.components().to_owned_vec(); let comps = path.components().to_owned_vec();
let exp: &[&[u8]] = [$(b!($($exp),*)),*]; let exp: &[&[u8]] = [$(b!($($exp),*)),*];
assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}", assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}",
@ -1297,7 +1297,7 @@ mod tests {
macro_rules! t( macro_rules! t(
(v: [$($arg:expr),+], $exp:expr) => ( (v: [$($arg:expr),+], $exp:expr) => (
{ {
let path = Path::new(b!($($arg),+)); let path = Path::init(b!($($arg),+));
let comps = path.str_components().to_owned_vec(); let comps = path.str_components().to_owned_vec();
let exp: &[Option<&str>] = $exp; let exp: &[Option<&str>] = $exp;
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
@ -1327,7 +1327,7 @@ mod bench {
#[bench] #[bench]
fn join_home_dir(bh: &mut BenchHarness) { fn join_home_dir(bh: &mut BenchHarness) {
let posix_path = Path::new("/"); let posix_path = Path::init("/");
bh.iter(|| { bh.iter(|| {
posix_path.join("home"); posix_path.join("home");
}); });
@ -1335,7 +1335,7 @@ mod bench {
#[bench] #[bench]
fn join_abs_path_home_dir(bh: &mut BenchHarness) { fn join_abs_path_home_dir(bh: &mut BenchHarness) {
let posix_path = Path::new("/"); let posix_path = Path::init("/");
bh.iter(|| { bh.iter(|| {
posix_path.join("/home"); posix_path.join("/home");
}); });
@ -1343,7 +1343,7 @@ mod bench {
#[bench] #[bench]
fn join_many_home_dir(bh: &mut BenchHarness) { fn join_many_home_dir(bh: &mut BenchHarness) {
let posix_path = Path::new("/"); let posix_path = Path::init("/");
bh.iter(|| { bh.iter(|| {
posix_path.join_many(&["home"]); posix_path.join_many(&["home"]);
}); });
@ -1351,7 +1351,7 @@ mod bench {
#[bench] #[bench]
fn join_many_abs_path_home_dir(bh: &mut BenchHarness) { fn join_many_abs_path_home_dir(bh: &mut BenchHarness) {
let posix_path = Path::new("/"); let posix_path = Path::init("/");
bh.iter(|| { bh.iter(|| {
posix_path.join_many(&["/home"]); posix_path.join_many(&["/home"]);
}); });
@ -1359,7 +1359,7 @@ mod bench {
#[bench] #[bench]
fn push_home_dir(bh: &mut BenchHarness) { fn push_home_dir(bh: &mut BenchHarness) {
let mut posix_path = Path::new("/"); let mut posix_path = Path::init("/");
bh.iter(|| { bh.iter(|| {
posix_path.push("home"); posix_path.push("home");
}); });
@ -1367,7 +1367,7 @@ mod bench {
#[bench] #[bench]
fn push_abs_path_home_dir(bh: &mut BenchHarness) { fn push_abs_path_home_dir(bh: &mut BenchHarness) {
let mut posix_path = Path::new("/"); let mut posix_path = Path::init("/");
bh.iter(|| { bh.iter(|| {
posix_path.push("/home"); posix_path.push("/home");
}); });
@ -1375,7 +1375,7 @@ mod bench {
#[bench] #[bench]
fn push_many_home_dir(bh: &mut BenchHarness) { fn push_many_home_dir(bh: &mut BenchHarness) {
let mut posix_path = Path::new("/"); let mut posix_path = Path::init("/");
bh.iter(|| { bh.iter(|| {
posix_path.push_many(&["home"]); posix_path.push_many(&["home"]);
}); });
@ -1383,7 +1383,7 @@ mod bench {
#[bench] #[bench]
fn push_many_abs_path_home_dir(bh: &mut BenchHarness) { fn push_many_abs_path_home_dir(bh: &mut BenchHarness) {
let mut posix_path = Path::new("/"); let mut posix_path = Path::init("/");
bh.iter(|| { bh.iter(|| {
posix_path.push_many(&["/home"]); posix_path.push_many(&["/home"]);
}); });
@ -1391,17 +1391,17 @@ mod bench {
#[bench] #[bench]
fn ends_with_path_home_dir(bh: &mut BenchHarness) { fn ends_with_path_home_dir(bh: &mut BenchHarness) {
let posix_home_path = Path::new("/home"); let posix_home_path = Path::init("/home");
bh.iter(|| { bh.iter(|| {
posix_home_path.ends_with_path(&Path::new("home")); posix_home_path.ends_with_path(&Path::init("home"));
}); });
} }
#[bench] #[bench]
fn ends_with_path_missmatch_jome_home(bh: &mut BenchHarness) { fn ends_with_path_missmatch_jome_home(bh: &mut BenchHarness) {
let posix_home_path = Path::new("/home"); let posix_home_path = Path::init("/home");
bh.iter(|| { bh.iter(|| {
posix_home_path.ends_with_path(&Path::new("jome")); posix_home_path.ends_with_path(&Path::init("jome"));
}); });
} }
} }

338
src/libstd/path/windows.rs
View file

@ -93,7 +93,7 @@ impl Eq for Path {
impl FromStr for Path { impl FromStr for Path {
fn from_str(s: &str) -> Option<Path> { fn from_str(s: &str) -> Option<Path> {
Path::new_opt(s) Path::init_opt(s)
} }
} }
@ -162,7 +162,7 @@ impl GenericPathUnsafe for Path {
/// ///
/// Raises the `str::not_utf8` condition if not valid UTF-8. /// Raises the `str::not_utf8` condition if not valid UTF-8.
#[inline] #[inline]
unsafe fn new_unchecked<T: BytesContainer>(path: T) -> Path { unsafe fn init_unchecked<T: BytesContainer>(path: T) -> Path {
let (prefix, path) = Path::normalize_(path.container_as_str()); let (prefix, path) = Path::normalize_(path.container_as_str());
assert!(!path.is_empty()); assert!(!path.is_empty());
let mut ret = Path{ repr: path, prefix: prefix, sepidx: None }; let mut ret = Path{ repr: path, prefix: prefix, sepidx: None };
@ -303,7 +303,7 @@ impl GenericPathUnsafe for Path {
impl GenericPath for Path { impl GenericPath for Path {
#[inline] #[inline]
fn new_opt<T: BytesContainer>(path: T) -> Option<Path> { fn init_opt<T: BytesContainer>(path: T) -> Option<Path> {
let s = path.container_as_str_opt(); let s = path.container_as_str_opt();
match s { match s {
None => None, None => None,
@ -311,7 +311,7 @@ impl GenericPath for Path {
if contains_nul(s.as_bytes()) { if contains_nul(s.as_bytes()) {
None None
} else { } else {
Some(unsafe { GenericPathUnsafe::new_unchecked(s) }) Some(unsafe { GenericPathUnsafe::init_unchecked(s) })
} }
} }
} }
@ -395,7 +395,7 @@ impl GenericPath for Path {
} }
fn dir_path(&self) -> Path { fn dir_path(&self) -> Path {
unsafe { GenericPathUnsafe::new_unchecked(self.dirname_str().unwrap()) } unsafe { GenericPathUnsafe::init_unchecked(self.dirname_str().unwrap()) }
} }
#[inline] #[inline]
@ -426,14 +426,14 @@ impl GenericPath for Path {
fn root_path(&self) -> Option<Path> { fn root_path(&self) -> Option<Path> {
if self.is_absolute() { if self.is_absolute() {
Some(Path::new(match self.prefix { Some(Path::init(match self.prefix {
Some(VerbatimDiskPrefix)|Some(DiskPrefix) => { Some(VerbatimDiskPrefix)|Some(DiskPrefix) => {
self.repr.slice_to(self.prefix_len()+1) self.repr.slice_to(self.prefix_len()+1)
} }
_ => self.repr.slice_to(self.prefix_len()) _ => self.repr.slice_to(self.prefix_len())
})) }))
} else if is_vol_relative(self) { } else if is_vol_relative(self) {
Some(Path::new(self.repr.slice_to(1))) Some(Path::init(self.repr.slice_to(1)))
} else { } else {
None None
} }
@ -563,7 +563,7 @@ impl GenericPath for Path {
} }
} }
} }
Some(Path::new(comps.connect("\\"))) Some(Path::init(comps.connect("\\")))
} }
} }
@ -591,14 +591,14 @@ impl Path {
/// Raises the `null_byte` condition if the vector contains a NUL. /// Raises the `null_byte` condition if the vector contains a NUL.
/// Raises the `str::not_utf8` condition if invalid UTF-8. /// Raises the `str::not_utf8` condition if invalid UTF-8.
#[inline] #[inline]
pub fn new<T: BytesContainer>(path: T) -> Path { pub fn init<T: BytesContainer>(path: T) -> Path {
GenericPath::new(path) GenericPath::init(path)
} }
/// Returns a new Path from a byte vector or string, if possible /// Returns a new Path from a byte vector or string, if possible
#[inline] #[inline]
pub fn new_opt<T: BytesContainer>(path: T) -> Option<Path> { pub fn init_opt<T: BytesContainer>(path: T) -> Option<Path> {
GenericPath::new_opt(path) GenericPath::init_opt(path)
} }
/// Returns an iterator that yields each component of the path in turn as a Option<&str>. /// Returns an iterator that yields each component of the path in turn as a Option<&str>.
@ -1147,100 +1147,100 @@ mod tests {
#[test] #[test]
fn test_paths() { fn test_paths() {
let empty: &[u8] = []; let empty: &[u8] = [];
t!(v: Path::new(empty), b!(".")); t!(v: Path::init(empty), b!("."));
t!(v: Path::new(b!("\\")), b!("\\")); t!(v: Path::init(b!("\\")), b!("\\"));
t!(v: Path::new(b!("a\\b\\c")), b!("a\\b\\c")); t!(v: Path::init(b!("a\\b\\c")), b!("a\\b\\c"));
t!(s: Path::new(""), "."); t!(s: Path::init(""), ".");
t!(s: Path::new("\\"), "\\"); t!(s: Path::init("\\"), "\\");
t!(s: Path::new("hi"), "hi"); t!(s: Path::init("hi"), "hi");
t!(s: Path::new("hi\\"), "hi"); t!(s: Path::init("hi\\"), "hi");
t!(s: Path::new("\\lib"), "\\lib"); t!(s: Path::init("\\lib"), "\\lib");
t!(s: Path::new("\\lib\\"), "\\lib"); t!(s: Path::init("\\lib\\"), "\\lib");
t!(s: Path::new("hi\\there"), "hi\\there"); t!(s: Path::init("hi\\there"), "hi\\there");
t!(s: Path::new("hi\\there.txt"), "hi\\there.txt"); t!(s: Path::init("hi\\there.txt"), "hi\\there.txt");
t!(s: Path::new("/"), "\\"); t!(s: Path::init("/"), "\\");
t!(s: Path::new("hi/"), "hi"); t!(s: Path::init("hi/"), "hi");
t!(s: Path::new("/lib"), "\\lib"); t!(s: Path::init("/lib"), "\\lib");
t!(s: Path::new("/lib/"), "\\lib"); t!(s: Path::init("/lib/"), "\\lib");
t!(s: Path::new("hi/there"), "hi\\there"); t!(s: Path::init("hi/there"), "hi\\there");
t!(s: Path::new("hi\\there\\"), "hi\\there"); t!(s: Path::init("hi\\there\\"), "hi\\there");
t!(s: Path::new("hi\\..\\there"), "there"); t!(s: Path::init("hi\\..\\there"), "there");
t!(s: Path::new("hi/../there"), "there"); t!(s: Path::init("hi/../there"), "there");
t!(s: Path::new("..\\hi\\there"), "..\\hi\\there"); t!(s: Path::init("..\\hi\\there"), "..\\hi\\there");
t!(s: Path::new("\\..\\hi\\there"), "\\hi\\there"); t!(s: Path::init("\\..\\hi\\there"), "\\hi\\there");
t!(s: Path::new("/../hi/there"), "\\hi\\there"); t!(s: Path::init("/../hi/there"), "\\hi\\there");
t!(s: Path::new("foo\\.."), "."); t!(s: Path::init("foo\\.."), ".");
t!(s: Path::new("\\foo\\.."), "\\"); t!(s: Path::init("\\foo\\.."), "\\");
t!(s: Path::new("\\foo\\..\\.."), "\\"); t!(s: Path::init("\\foo\\..\\.."), "\\");
t!(s: Path::new("\\foo\\..\\..\\bar"), "\\bar"); t!(s: Path::init("\\foo\\..\\..\\bar"), "\\bar");
t!(s: Path::new("\\.\\hi\\.\\there\\."), "\\hi\\there"); t!(s: Path::init("\\.\\hi\\.\\there\\."), "\\hi\\there");
t!(s: Path::new("\\.\\hi\\.\\there\\.\\.."), "\\hi"); t!(s: Path::init("\\.\\hi\\.\\there\\.\\.."), "\\hi");
t!(s: Path::new("foo\\..\\.."), ".."); t!(s: Path::init("foo\\..\\.."), "..");
t!(s: Path::new("foo\\..\\..\\.."), "..\\.."); t!(s: Path::init("foo\\..\\..\\.."), "..\\..");
t!(s: Path::new("foo\\..\\..\\bar"), "..\\bar"); t!(s: Path::init("foo\\..\\..\\bar"), "..\\bar");
assert_eq!(Path::new(b!("foo\\bar")).into_vec(), b!("foo\\bar").to_owned()); assert_eq!(Path::init(b!("foo\\bar")).into_vec(), b!("foo\\bar").to_owned());
assert_eq!(Path::new(b!("\\foo\\..\\..\\bar")).into_vec(), assert_eq!(Path::init(b!("\\foo\\..\\..\\bar")).into_vec(),
b!("\\bar").to_owned()); b!("\\bar").to_owned());
t!(s: Path::new("\\\\a"), "\\a"); t!(s: Path::init("\\\\a"), "\\a");
t!(s: Path::new("\\\\a\\"), "\\a"); t!(s: Path::init("\\\\a\\"), "\\a");
t!(s: Path::new("\\\\a\\b"), "\\\\a\\b"); t!(s: Path::init("\\\\a\\b"), "\\\\a\\b");
t!(s: Path::new("\\\\a\\b\\"), "\\\\a\\b"); t!(s: Path::init("\\\\a\\b\\"), "\\\\a\\b");
t!(s: Path::new("\\\\a\\b/"), "\\\\a\\b"); t!(s: Path::init("\\\\a\\b/"), "\\\\a\\b");
t!(s: Path::new("\\\\\\b"), "\\b"); t!(s: Path::init("\\\\\\b"), "\\b");
t!(s: Path::new("\\\\a\\\\b"), "\\a\\b"); t!(s: Path::init("\\\\a\\\\b"), "\\a\\b");
t!(s: Path::new("\\\\a\\b\\c"), "\\\\a\\b\\c"); t!(s: Path::init("\\\\a\\b\\c"), "\\\\a\\b\\c");
t!(s: Path::new("\\\\server\\share/path"), "\\\\server\\share\\path"); t!(s: Path::init("\\\\server\\share/path"), "\\\\server\\share\\path");
t!(s: Path::new("\\\\server/share/path"), "\\\\server\\share\\path"); t!(s: Path::init("\\\\server/share/path"), "\\\\server\\share\\path");
t!(s: Path::new("C:a\\b.txt"), "C:a\\b.txt"); t!(s: Path::init("C:a\\b.txt"), "C:a\\b.txt");
t!(s: Path::new("C:a/b.txt"), "C:a\\b.txt"); t!(s: Path::init("C:a/b.txt"), "C:a\\b.txt");
t!(s: Path::new("z:\\a\\b.txt"), "Z:\\a\\b.txt"); t!(s: Path::init("z:\\a\\b.txt"), "Z:\\a\\b.txt");
t!(s: Path::new("z:/a/b.txt"), "Z:\\a\\b.txt"); t!(s: Path::init("z:/a/b.txt"), "Z:\\a\\b.txt");
t!(s: Path::new("ab:/a/b.txt"), "ab:\\a\\b.txt"); t!(s: Path::init("ab:/a/b.txt"), "ab:\\a\\b.txt");
t!(s: Path::new("C:\\"), "C:\\"); t!(s: Path::init("C:\\"), "C:\\");
t!(s: Path::new("C:"), "C:"); t!(s: Path::init("C:"), "C:");
t!(s: Path::new("q:"), "Q:"); t!(s: Path::init("q:"), "Q:");
t!(s: Path::new("C:/"), "C:\\"); t!(s: Path::init("C:/"), "C:\\");
t!(s: Path::new("C:\\foo\\.."), "C:\\"); t!(s: Path::init("C:\\foo\\.."), "C:\\");
t!(s: Path::new("C:foo\\.."), "C:"); t!(s: Path::init("C:foo\\.."), "C:");
t!(s: Path::new("C:\\a\\"), "C:\\a"); t!(s: Path::init("C:\\a\\"), "C:\\a");
t!(s: Path::new("C:\\a/"), "C:\\a"); t!(s: Path::init("C:\\a/"), "C:\\a");
t!(s: Path::new("C:\\a\\b\\"), "C:\\a\\b"); t!(s: Path::init("C:\\a\\b\\"), "C:\\a\\b");
t!(s: Path::new("C:\\a\\b/"), "C:\\a\\b"); t!(s: Path::init("C:\\a\\b/"), "C:\\a\\b");
t!(s: Path::new("C:a\\"), "C:a"); t!(s: Path::init("C:a\\"), "C:a");
t!(s: Path::new("C:a/"), "C:a"); t!(s: Path::init("C:a/"), "C:a");
t!(s: Path::new("C:a\\b\\"), "C:a\\b"); t!(s: Path::init("C:a\\b\\"), "C:a\\b");
t!(s: Path::new("C:a\\b/"), "C:a\\b"); t!(s: Path::init("C:a\\b/"), "C:a\\b");
t!(s: Path::new("\\\\?\\z:\\a\\b.txt"), "\\\\?\\z:\\a\\b.txt"); t!(s: Path::init("\\\\?\\z:\\a\\b.txt"), "\\\\?\\z:\\a\\b.txt");
t!(s: Path::new("\\\\?\\C:/a/b.txt"), "\\\\?\\C:/a/b.txt"); t!(s: Path::init("\\\\?\\C:/a/b.txt"), "\\\\?\\C:/a/b.txt");
t!(s: Path::new("\\\\?\\C:\\a/b.txt"), "\\\\?\\C:\\a/b.txt"); t!(s: Path::init("\\\\?\\C:\\a/b.txt"), "\\\\?\\C:\\a/b.txt");
t!(s: Path::new("\\\\?\\test\\a\\b.txt"), "\\\\?\\test\\a\\b.txt"); t!(s: Path::init("\\\\?\\test\\a\\b.txt"), "\\\\?\\test\\a\\b.txt");
t!(s: Path::new("\\\\?\\foo\\bar\\"), "\\\\?\\foo\\bar\\"); t!(s: Path::init("\\\\?\\foo\\bar\\"), "\\\\?\\foo\\bar\\");
t!(s: Path::new("\\\\.\\foo\\bar"), "\\\\.\\foo\\bar"); t!(s: Path::init("\\\\.\\foo\\bar"), "\\\\.\\foo\\bar");
t!(s: Path::new("\\\\.\\"), "\\\\.\\"); t!(s: Path::init("\\\\.\\"), "\\\\.\\");
t!(s: Path::new("\\\\?\\UNC\\server\\share\\foo"), "\\\\?\\UNC\\server\\share\\foo"); t!(s: Path::init("\\\\?\\UNC\\server\\share\\foo"), "\\\\?\\UNC\\server\\share\\foo");
t!(s: Path::new("\\\\?\\UNC\\server/share"), "\\\\?\\UNC\\server/share\\"); t!(s: Path::init("\\\\?\\UNC\\server/share"), "\\\\?\\UNC\\server/share\\");
t!(s: Path::new("\\\\?\\UNC\\server"), "\\\\?\\UNC\\server\\"); t!(s: Path::init("\\\\?\\UNC\\server"), "\\\\?\\UNC\\server\\");
t!(s: Path::new("\\\\?\\UNC\\"), "\\\\?\\UNC\\\\"); t!(s: Path::init("\\\\?\\UNC\\"), "\\\\?\\UNC\\\\");
t!(s: Path::new("\\\\?\\UNC"), "\\\\?\\UNC"); t!(s: Path::init("\\\\?\\UNC"), "\\\\?\\UNC");
// I'm not sure whether \\.\foo/bar should normalize to \\.\foo\bar // I'm not sure whether \\.\foo/bar should normalize to \\.\foo\bar
// as information is sparse and this isn't really googleable. // as information is sparse and this isn't really googleable.
// I'm going to err on the side of not normalizing it, as this skips the filesystem // I'm going to err on the side of not normalizing it, as this skips the filesystem
t!(s: Path::new("\\\\.\\foo/bar"), "\\\\.\\foo/bar"); t!(s: Path::init("\\\\.\\foo/bar"), "\\\\.\\foo/bar");
t!(s: Path::new("\\\\.\\foo\\bar"), "\\\\.\\foo\\bar"); t!(s: Path::init("\\\\.\\foo\\bar"), "\\\\.\\foo\\bar");
} }
#[test] #[test]
fn test_opt_paths() { fn test_opt_paths() {
assert_eq!(Path::new_opt(b!("foo\\bar", 0)), None); assert_eq!(Path::init_opt(b!("foo\\bar", 0)), None);
assert_eq!(Path::new_opt(b!("foo\\bar", 0x80)), None); assert_eq!(Path::init_opt(b!("foo\\bar", 0x80)), None);
t!(v: Path::new_opt(b!("foo\\bar")).unwrap(), b!("foo\\bar")); t!(v: Path::init_opt(b!("foo\\bar")).unwrap(), b!("foo\\bar"));
assert_eq!(Path::new_opt("foo\\bar\0"), None); assert_eq!(Path::init_opt("foo\\bar\0"), None);
t!(s: Path::new_opt("foo\\bar").unwrap(), "foo\\bar"); t!(s: Path::init_opt("foo\\bar").unwrap(), "foo\\bar");
} }
#[test] #[test]
@ -1253,7 +1253,7 @@ mod tests {
assert_eq!(v.as_slice(), b!("foo\\bar", 0)); assert_eq!(v.as_slice(), b!("foo\\bar", 0));
(b!("\\bar").to_owned()) (b!("\\bar").to_owned())
}).inside(|| { }).inside(|| {
Path::new(b!("foo\\bar", 0)) Path::init(b!("foo\\bar", 0))
}); });
assert!(handled); assert!(handled);
assert_eq!(p.as_vec(), b!("\\bar")); assert_eq!(p.as_vec(), b!("\\bar"));
@ -1301,12 +1301,12 @@ mod tests {
cond.trap(|_| { cond.trap(|_| {
(b!("null", 0).to_owned()) (b!("null", 0).to_owned())
}).inside(|| { }).inside(|| {
Path::new(b!("foo\\bar", 0)) Path::init(b!("foo\\bar", 0))
}); });
}) })
t!(~"set_filename w\\nul" => { t!(~"set_filename w\\nul" => {
let mut p = Path::new(b!("foo\\bar")); let mut p = Path::init(b!("foo\\bar"));
cond.trap(|_| { cond.trap(|_| {
(b!("null", 0).to_owned()) (b!("null", 0).to_owned())
}).inside(|| { }).inside(|| {
@ -1315,7 +1315,7 @@ mod tests {
}) })
t!(~"push w\\nul" => { t!(~"push w\\nul" => {
let mut p = Path::new(b!("foo\\bar")); let mut p = Path::init(b!("foo\\bar"));
cond.trap(|_| { cond.trap(|_| {
(b!("null", 0).to_owned()) (b!("null", 0).to_owned())
}).inside(|| { }).inside(|| {
@ -1327,25 +1327,25 @@ mod tests {
#[test] #[test]
#[should_fail] #[should_fail]
fn test_not_utf8_fail() { fn test_not_utf8_fail() {
Path::new(b!("hello", 0x80, ".txt")); Path::init(b!("hello", 0x80, ".txt"));
} }
#[test] #[test]
fn test_display_str() { fn test_display_str() {
let path = Path::new("foo"); let path = Path::init("foo");
assert_eq!(path.display().to_str(), ~"foo"); assert_eq!(path.display().to_str(), ~"foo");
let path = Path::new(b!("\\")); let path = Path::init(b!("\\"));
assert_eq!(path.filename_display().to_str(), ~""); assert_eq!(path.filename_display().to_str(), ~"");
let mut called = false; let mut called = false;
let path = Path::new("foo"); let path = Path::init("foo");
path.display().with_str(|s| { path.display().with_str(|s| {
assert_eq!(s, "foo"); assert_eq!(s, "foo");
called = true; called = true;
}); });
assert!(called); assert!(called);
called = false; called = false;
let path = Path::new(b!("\\")); let path = Path::init(b!("\\"));
path.filename_display().with_str(|s| { path.filename_display().with_str(|s| {
assert_eq!(s, ""); assert_eq!(s, "");
called = true; called = true;
@ -1358,7 +1358,7 @@ mod tests {
macro_rules! t( macro_rules! t(
($path:expr, $exp:expr, $expf:expr) => ( ($path:expr, $exp:expr, $expf:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let f = format!("{}", path.display()); let f = format!("{}", path.display());
assert_eq!(f.as_slice(), $exp); assert_eq!(f.as_slice(), $exp);
let f = format!("{}", path.filename_display()); let f = format!("{}", path.filename_display());
@ -1377,20 +1377,20 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $op:ident, $exp:expr) => ( (s: $path:expr, $op:ident, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
assert_eq!(path.$op(), Some($exp)); assert_eq!(path.$op(), Some($exp));
} }
); );
(s: $path:expr, $op:ident, $exp:expr, opt) => ( (s: $path:expr, $op:ident, $exp:expr, opt) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let left = path.$op(); let left = path.$op();
assert_eq!(left, $exp); assert_eq!(left, $exp);
} }
); );
(v: $path:expr, $op:ident, $exp:expr) => ( (v: $path:expr, $op:ident, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
assert_eq!(path.$op(), $exp); assert_eq!(path.$op(), $exp);
} }
) )
@ -1499,7 +1499,7 @@ mod tests {
{ {
let path = ($path); let path = ($path);
let join = ($join); let join = ($join);
let mut p1 = Path::new(path); let mut p1 = Path::init(path);
let p2 = p1.clone(); let p2 = p1.clone();
p1.push(join); p1.push(join);
assert_eq!(p1, p2.join(join)); assert_eq!(p1, p2.join(join));
@ -1515,14 +1515,14 @@ mod tests {
// so there's no need for the full set of prefix tests // so there's no need for the full set of prefix tests
// we do want to check one odd case though to ensure the prefix is re-parsed // we do want to check one odd case though to ensure the prefix is re-parsed
let mut p = Path::new("\\\\?\\C:"); let mut p = Path::init("\\\\?\\C:");
assert_eq!(prefix(&p), Some(VerbatimPrefix(2))); assert_eq!(prefix(&p), Some(VerbatimPrefix(2)));
p.push("foo"); p.push("foo");
assert_eq!(prefix(&p), Some(VerbatimDiskPrefix)); assert_eq!(prefix(&p), Some(VerbatimDiskPrefix));
assert_eq!(p.as_str(), Some("\\\\?\\C:\\foo")); assert_eq!(p.as_str(), Some("\\\\?\\C:\\foo"));
// and another with verbatim non-normalized paths // and another with verbatim non-normalized paths
let mut p = Path::new("\\\\?\\C:\\a\\"); let mut p = Path::init("\\\\?\\C:\\a\\");
p.push("foo"); p.push("foo");
assert_eq!(p.as_str(), Some("\\\\?\\C:\\a\\foo")); assert_eq!(p.as_str(), Some("\\\\?\\C:\\a\\foo"));
} }
@ -1532,8 +1532,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $push:expr, $exp:expr) => ( (s: $path:expr, $push:expr, $exp:expr) => (
{ {
let mut p = Path::new($path); let mut p = Path::init($path);
let push = Path::new($push); let push = Path::init($push);
p.push(&push); p.push(&push);
assert_eq!(p.as_str(), Some($exp)); assert_eq!(p.as_str(), Some($exp));
} }
@ -1584,14 +1584,14 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $push:expr, $exp:expr) => ( (s: $path:expr, $push:expr, $exp:expr) => (
{ {
let mut p = Path::new($path); let mut p = Path::init($path);
p.push_many($push); p.push_many($push);
assert_eq!(p.as_str(), Some($exp)); assert_eq!(p.as_str(), Some($exp));
} }
); );
(v: $path:expr, $push:expr, $exp:expr) => ( (v: $path:expr, $push:expr, $exp:expr) => (
{ {
let mut p = Path::new($path); let mut p = Path::init($path);
p.push_many($push); p.push_many($push);
assert_eq!(p.as_vec(), $exp); assert_eq!(p.as_vec(), $exp);
} }
@ -1616,7 +1616,7 @@ mod tests {
(s: $path:expr, $left:expr, $right:expr) => ( (s: $path:expr, $left:expr, $right:expr) => (
{ {
let pstr = $path; let pstr = $path;
let mut p = Path::new(pstr); let mut p = Path::init(pstr);
let result = p.pop(); let result = p.pop();
let left = $left; let left = $left;
assert!(p.as_str() == Some(left), assert!(p.as_str() == Some(left),
@ -1627,7 +1627,7 @@ mod tests {
); );
(v: [$($path:expr),+], [$($left:expr),+], $right:expr) => ( (v: [$($path:expr),+], [$($left:expr),+], $right:expr) => (
{ {
let mut p = Path::new(b!($($path),+)); let mut p = Path::init(b!($($path),+));
let result = p.pop(); let result = p.pop();
assert_eq!(p.as_vec(), b!($($left),+)); assert_eq!(p.as_vec(), b!($($left),+));
assert_eq!(result, $right); assert_eq!(result, $right);
@ -1673,28 +1673,28 @@ mod tests {
#[test] #[test]
fn test_root_path() { fn test_root_path() {
assert_eq!(Path::new("a\\b\\c").root_path(), None); assert_eq!(Path::init("a\\b\\c").root_path(), None);
assert_eq!(Path::new("\\a\\b\\c").root_path(), Some(Path::new("\\"))); assert_eq!(Path::init("\\a\\b\\c").root_path(), Some(Path::init("\\")));
assert_eq!(Path::new("C:a").root_path(), None); assert_eq!(Path::init("C:a").root_path(), None);
assert_eq!(Path::new("C:\\a").root_path(), Some(Path::new("C:\\"))); assert_eq!(Path::init("C:\\a").root_path(), Some(Path::init("C:\\")));
assert_eq!(Path::new("\\\\a\\b\\c").root_path(), Some(Path::new("\\\\a\\b"))); assert_eq!(Path::init("\\\\a\\b\\c").root_path(), Some(Path::init("\\\\a\\b")));
assert_eq!(Path::new("\\\\?\\a\\b").root_path(), Some(Path::new("\\\\?\\a"))); assert_eq!(Path::init("\\\\?\\a\\b").root_path(), Some(Path::init("\\\\?\\a")));
assert_eq!(Path::new("\\\\?\\C:\\a").root_path(), Some(Path::new("\\\\?\\C:\\"))); assert_eq!(Path::init("\\\\?\\C:\\a").root_path(), Some(Path::init("\\\\?\\C:\\")));
assert_eq!(Path::new("\\\\?\\UNC\\a\\b\\c").root_path(), assert_eq!(Path::init("\\\\?\\UNC\\a\\b\\c").root_path(),
Some(Path::new("\\\\?\\UNC\\a\\b"))); Some(Path::init("\\\\?\\UNC\\a\\b")));
assert_eq!(Path::new("\\\\.\\a\\b").root_path(), Some(Path::new("\\\\.\\a"))); assert_eq!(Path::init("\\\\.\\a\\b").root_path(), Some(Path::init("\\\\.\\a")));
} }
#[test] #[test]
fn test_join() { fn test_join() {
t!(s: Path::new("a\\b\\c").join(".."), "a\\b"); t!(s: Path::init("a\\b\\c").join(".."), "a\\b");
t!(s: Path::new("\\a\\b\\c").join("d"), "\\a\\b\\c\\d"); t!(s: Path::init("\\a\\b\\c").join("d"), "\\a\\b\\c\\d");
t!(s: Path::new("a\\b").join("c\\d"), "a\\b\\c\\d"); t!(s: Path::init("a\\b").join("c\\d"), "a\\b\\c\\d");
t!(s: Path::new("a\\b").join("\\c\\d"), "\\c\\d"); t!(s: Path::init("a\\b").join("\\c\\d"), "\\c\\d");
t!(s: Path::new(".").join("a\\b"), "a\\b"); t!(s: Path::init(".").join("a\\b"), "a\\b");
t!(s: Path::new("\\").join("a\\b"), "\\a\\b"); t!(s: Path::init("\\").join("a\\b"), "\\a\\b");
t!(v: Path::new(b!("a\\b\\c")).join(b!("..")), b!("a\\b")); t!(v: Path::init(b!("a\\b\\c")).join(b!("..")), b!("a\\b"));
t!(v: Path::new(b!("\\a\\b\\c")).join(b!("d")), b!("\\a\\b\\c\\d")); t!(v: Path::init(b!("\\a\\b\\c")).join(b!("d")), b!("\\a\\b\\c\\d"));
// full join testing is covered under test_push_path, so no need for // full join testing is covered under test_push_path, so no need for
// the full set of prefix tests // the full set of prefix tests
} }
@ -1704,8 +1704,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $join:expr, $exp:expr) => ( (s: $path:expr, $join:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let join = Path::new($join); let join = Path::init($join);
let res = path.join(&join); let res = path.join(&join);
assert_eq!(res.as_str(), Some($exp)); assert_eq!(res.as_str(), Some($exp));
} }
@ -1729,14 +1729,14 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $join:expr, $exp:expr) => ( (s: $path:expr, $join:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let res = path.join_many($join); let res = path.join_many($join);
assert_eq!(res.as_str(), Some($exp)); assert_eq!(res.as_str(), Some($exp));
} }
); );
(v: $path:expr, $join:expr, $exp:expr) => ( (v: $path:expr, $join:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let res = path.join_many($join); let res = path.join_many($join);
assert_eq!(res.as_vec(), $exp); assert_eq!(res.as_vec(), $exp);
} }
@ -1760,7 +1760,7 @@ mod tests {
(s: $path:expr, $op:ident, $arg:expr, $res:expr) => ( (s: $path:expr, $op:ident, $arg:expr, $res:expr) => (
{ {
let pstr = $path; let pstr = $path;
let path = Path::new(pstr); let path = Path::init(pstr);
let arg = $arg; let arg = $arg;
let res = path.$op(arg); let res = path.$op(arg);
let exp = $res; let exp = $res;
@ -1846,9 +1846,9 @@ mod tests {
{ {
let path = $path; let path = $path;
let arg = $arg; let arg = $arg;
let mut p1 = Path::new(path); let mut p1 = Path::init(path);
p1.$set(arg); p1.$set(arg);
let p2 = Path::new(path); let p2 = Path::init(path);
assert_eq!(p1, p2.$with(arg)); assert_eq!(p1, p2.$with(arg));
} }
); );
@ -1856,9 +1856,9 @@ mod tests {
{ {
let path = $path; let path = $path;
let arg = $arg; let arg = $arg;
let mut p1 = Path::new(path); let mut p1 = Path::init(path);
p1.$set(arg); p1.$set(arg);
let p2 = Path::new(path); let p2 = Path::init(path);
assert_eq!(p1, p2.$with(arg)); assert_eq!(p1, p2.$with(arg));
} }
) )
@ -1919,19 +1919,19 @@ mod tests {
) )
) )
t!(v: Path::new(b!("a\\b\\c")), Some(b!("c")), b!("a\\b"), Some(b!("c")), None); t!(v: Path::init(b!("a\\b\\c")), Some(b!("c")), b!("a\\b"), Some(b!("c")), None);
t!(s: Path::new("a\\b\\c"), Some("c"), Some("a\\b"), Some("c"), None); t!(s: Path::init("a\\b\\c"), Some("c"), Some("a\\b"), Some("c"), None);
t!(s: Path::new("."), None, Some("."), None, None); t!(s: Path::init("."), None, Some("."), None, None);
t!(s: Path::new("\\"), None, Some("\\"), None, None); t!(s: Path::init("\\"), None, Some("\\"), None, None);
t!(s: Path::new(".."), None, Some(".."), None, None); t!(s: Path::init(".."), None, Some(".."), None, None);
t!(s: Path::new("..\\.."), None, Some("..\\.."), None, None); t!(s: Path::init("..\\.."), None, Some("..\\.."), None, None);
t!(s: Path::new("hi\\there.txt"), Some("there.txt"), Some("hi"), t!(s: Path::init("hi\\there.txt"), Some("there.txt"), Some("hi"),
Some("there"), Some("txt")); Some("there"), Some("txt"));
t!(s: Path::new("hi\\there"), Some("there"), Some("hi"), Some("there"), None); t!(s: Path::init("hi\\there"), Some("there"), Some("hi"), Some("there"), None);
t!(s: Path::new("hi\\there."), Some("there."), Some("hi"), t!(s: Path::init("hi\\there."), Some("there."), Some("hi"),
Some("there"), Some("")); Some("there"), Some(""));
t!(s: Path::new("hi\\.there"), Some(".there"), Some("hi"), Some(".there"), None); t!(s: Path::init("hi\\.there"), Some(".there"), Some("hi"), Some(".there"), None);
t!(s: Path::new("hi\\..there"), Some("..there"), Some("hi"), t!(s: Path::init("hi\\..there"), Some("..there"), Some("hi"),
Some("."), Some("there")); Some("."), Some("there"));
// these are already tested in test_components, so no need for extended tests // these are already tested in test_components, so no need for extended tests
@ -1939,12 +1939,12 @@ mod tests {
#[test] #[test]
fn test_dir_path() { fn test_dir_path() {
t!(s: Path::new("hi\\there").dir_path(), "hi"); t!(s: Path::init("hi\\there").dir_path(), "hi");
t!(s: Path::new("hi").dir_path(), "."); t!(s: Path::init("hi").dir_path(), ".");
t!(s: Path::new("\\hi").dir_path(), "\\"); t!(s: Path::init("\\hi").dir_path(), "\\");
t!(s: Path::new("\\").dir_path(), "\\"); t!(s: Path::init("\\").dir_path(), "\\");
t!(s: Path::new("..").dir_path(), ".."); t!(s: Path::init("..").dir_path(), "..");
t!(s: Path::new("..\\..").dir_path(), "..\\.."); t!(s: Path::init("..\\..").dir_path(), "..\\..");
// dir_path is just dirname interpreted as a path. // dir_path is just dirname interpreted as a path.
// No need for extended tests // No need for extended tests
@ -1955,7 +1955,7 @@ mod tests {
macro_rules! t( macro_rules! t(
($path:expr, $abs:expr, $vol:expr, $cwd:expr, $rel:expr) => ( ($path:expr, $abs:expr, $vol:expr, $cwd:expr, $rel:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let (abs, vol, cwd, rel) = ($abs, $vol, $cwd, $rel); let (abs, vol, cwd, rel) = ($abs, $vol, $cwd, $rel);
let b = path.is_absolute(); let b = path.is_absolute();
assert!(b == abs, "Path '{}'.is_absolute(): expected {:?}, found {:?}", assert!(b == abs, "Path '{}'.is_absolute(): expected {:?}, found {:?}",
@ -1995,8 +1995,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $dest:expr, $exp:expr) => ( (s: $path:expr, $dest:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let dest = Path::new($dest); let dest = Path::init($dest);
let exp = $exp; let exp = $exp;
let res = path.is_ancestor_of(&dest); let res = path.is_ancestor_of(&dest);
assert!(res == exp, assert!(res == exp,
@ -2098,8 +2098,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $child:expr, $exp:expr) => ( (s: $path:expr, $child:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let child = Path::new($child); let child = Path::init($child);
assert_eq!(path.ends_with_path(&child), $exp); assert_eq!(path.ends_with_path(&child), $exp);
} }
); );
@ -2130,8 +2130,8 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $other:expr, $exp:expr) => ( (s: $path:expr, $other:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let other = Path::new($other); let other = Path::init($other);
let res = path.path_relative_from(&other); let res = path.path_relative_from(&other);
let exp = $exp; let exp = $exp;
assert!(res.as_ref().and_then(|x| x.as_str()) == exp, assert!(res.as_ref().and_then(|x| x.as_str()) == exp,
@ -2264,7 +2264,7 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $exp:expr) => ( (s: $path:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let comps = path.str_components().map(|x|x.unwrap()).to_owned_vec(); let comps = path.str_components().map(|x|x.unwrap()).to_owned_vec();
let exp: &[&str] = $exp; let exp: &[&str] = $exp;
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
@ -2279,7 +2279,7 @@ mod tests {
); );
(v: [$($arg:expr),+], $exp:expr) => ( (v: [$($arg:expr),+], $exp:expr) => (
{ {
let path = Path::new(b!($($arg),+)); let path = Path::init(b!($($arg),+));
let comps = path.str_components().map(|x|x.unwrap()).to_owned_vec(); let comps = path.str_components().map(|x|x.unwrap()).to_owned_vec();
let exp: &[&str] = $exp; let exp: &[&str] = $exp;
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
@ -2339,7 +2339,7 @@ mod tests {
macro_rules! t( macro_rules! t(
(s: $path:expr, $exp:expr) => ( (s: $path:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::init($path);
let comps = path.components().to_owned_vec(); let comps = path.components().to_owned_vec();
let exp: &[&[u8]] = $exp; let exp: &[&[u8]] = $exp;
assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}", assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}",

2
src/libstd/rand/os.rs
View file

@ -61,7 +61,7 @@ impl OSRng {
#[cfg(unix)] #[cfg(unix)]
pub fn new() -> OSRng { pub fn new() -> OSRng {
use path::Path; use path::Path;
let reader = File::open(&Path::new("/dev/urandom")); let reader = File::open(&Path::init("/dev/urandom"));
let reader = reader.expect("Error opening /dev/urandom"); let reader = reader.expect("Error opening /dev/urandom");
let reader_rng = ReaderRng::new(reader); let reader_rng = ReaderRng::new(reader);

2
src/libstd/rt/test.rs
View file

@ -383,7 +383,7 @@ pub fn next_test_unix() -> Path {
if cfg!(unix) { if cfg!(unix) {
os::tmpdir().join(rand::task_rng().gen_ascii_str(20)) os::tmpdir().join(rand::task_rng().gen_ascii_str(20))
} else { } else {
Path::new(r"\\.\pipe\" + rand::task_rng().gen_ascii_str(20)) Path::init(r"\\.\pipe\" + rand::task_rng().gen_ascii_str(20))
} }
} }

4
src/libstd/run.rs
View file

@ -506,7 +506,7 @@ mod tests {
let output = str::from_utf8(prog.finish_with_output().output); let output = str::from_utf8(prog.finish_with_output().output);
let parent_dir = os::getcwd(); let parent_dir = os::getcwd();
let child_dir = Path::new(output.trim()); let child_dir = Path::init(output.trim());
let parent_stat = parent_dir.stat(); let parent_stat = parent_dir.stat();
let child_stat = child_dir.stat(); let child_stat = child_dir.stat();
@ -523,7 +523,7 @@ mod tests {
let mut prog = run_pwd(Some(&parent_dir)); let mut prog = run_pwd(Some(&parent_dir));
let output = str::from_utf8(prog.finish_with_output().output); let output = str::from_utf8(prog.finish_with_output().output);
let child_dir = Path::new(output.trim()); let child_dir = Path::init(output.trim());
let parent_stat = parent_dir.stat(); let parent_stat = parent_dir.stat();
let child_stat = child_dir.stat(); let child_stat = child_dir.stat();

2
src/libstd/unstable/dynamic_lib.rs
View file

@ -122,7 +122,7 @@ mod test {
fn test_errors_do_not_crash() { fn test_errors_do_not_crash() {
// Open /dev/null as a library to get an error, and make sure // Open /dev/null as a library to get an error, and make sure
// that only causes an error, and not a crash. // that only causes an error, and not a crash.
let path = GenericPath::new("/dev/null"); let path = GenericPath::init("/dev/null");
match DynamicLibrary::open(Some(&path)) { match DynamicLibrary::open(Some(&path)) {
Err(_) => {} Err(_) => {}
Ok(_) => fail!("Successfully opened the empty library.") Ok(_) => fail!("Successfully opened the empty library.")

8
src/libsyntax/ext/source_util.rs
View file

@ -82,7 +82,7 @@ pub fn expand_include(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
let file = get_single_str_from_tts(cx, sp, tts, "include!"); let file = get_single_str_from_tts(cx, sp, tts, "include!");
let p = parse::new_sub_parser_from_file( let p = parse::new_sub_parser_from_file(
cx.parse_sess(), cx.cfg(), cx.parse_sess(), cx.cfg(),
&res_rel_file(cx, sp, &Path::new(file)), sp); &res_rel_file(cx, sp, &Path::init(file)), sp);
base::MRExpr(p.parse_expr()) base::MRExpr(p.parse_expr())
} }
@ -90,7 +90,7 @@ pub fn expand_include(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
pub fn expand_include_str(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree]) pub fn expand_include_str(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
-> base::MacResult { -> base::MacResult {
let file = get_single_str_from_tts(cx, sp, tts, "include_str!"); let file = get_single_str_from_tts(cx, sp, tts, "include_str!");
let file = res_rel_file(cx, sp, &Path::new(file)); let file = res_rel_file(cx, sp, &Path::init(file));
let bytes = match io::result(|| File::open(&file).read_to_end()) { let bytes = match io::result(|| File::open(&file).read_to_end()) {
Err(e) => { Err(e) => {
cx.span_fatal(sp, format!("couldn't read {}: {}", cx.span_fatal(sp, format!("couldn't read {}: {}",
@ -112,7 +112,7 @@ pub fn expand_include_bin(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree])
use std::at_vec; use std::at_vec;
let file = get_single_str_from_tts(cx, sp, tts, "include_bin!"); let file = get_single_str_from_tts(cx, sp, tts, "include_bin!");
let file = res_rel_file(cx, sp, &Path::new(file)); let file = res_rel_file(cx, sp, &Path::init(file));
match io::result(|| File::open(&file).read_to_end()) { match io::result(|| File::open(&file).read_to_end()) {
Err(e) => { Err(e) => {
cx.span_fatal(sp, format!("couldn't read {}: {}", cx.span_fatal(sp, format!("couldn't read {}: {}",
@ -156,7 +156,7 @@ fn topmost_expn_info(expn_info: @codemap::ExpnInfo) -> @codemap::ExpnInfo {
fn res_rel_file(cx: @ExtCtxt, sp: codemap::Span, arg: &Path) -> Path { fn res_rel_file(cx: @ExtCtxt, sp: codemap::Span, arg: &Path) -> Path {
// NB: relative paths are resolved relative to the compilation unit // NB: relative paths are resolved relative to the compilation unit
if !arg.is_absolute() { if !arg.is_absolute() {
let mut cu = Path::new(cx.codemap().span_to_filename(sp)); let mut cu = Path::init(cx.codemap().span_to_filename(sp));
cu.pop(); cu.pop();
cu.push(arg); cu.push(arg);
cu cu

4
src/libsyntax/parse/parser.rs
View file

@ -4216,10 +4216,10 @@ impl Parser {
outer_attrs: &[ast::Attribute], outer_attrs: &[ast::Attribute],
id_sp: Span) id_sp: Span)
-> (ast::item_, ~[ast::Attribute]) { -> (ast::item_, ~[ast::Attribute]) {
let mut prefix = Path::new(self.sess.cm.span_to_filename(*self.span)); let mut prefix = Path::init(self.sess.cm.span_to_filename(*self.span));
prefix.pop(); prefix.pop();
let mod_path_stack = &*self.mod_path_stack; let mod_path_stack = &*self.mod_path_stack;
let mod_path = Path::new(".").join_many(*mod_path_stack); let mod_path = Path::init(".").join_many(*mod_path_stack);
let dir_path = prefix.join(&mod_path); let dir_path = prefix.join(&mod_path);
let file_path = match ::attr::first_attr_value_str_by_name( let file_path = match ::attr::first_attr_value_str_by_name(
outer_attrs, "path") { outer_attrs, "path") {

2
src/test/bench/core-std.rs
View file

@ -72,7 +72,7 @@ fn shift_push() {
fn read_line() { fn read_line() {
use std::io::buffered::BufferedReader; use std::io::buffered::BufferedReader;
let mut path = Path::new(env!("CFG_SRC_DIR")); let mut path = Path::init(env!("CFG_SRC_DIR"));
path.push("src/test/bench/shootout-k-nucleotide.data"); path.push("src/test/bench/shootout-k-nucleotide.data");
for _ in range(0, 3) { for _ in range(0, 3) {

2
src/test/bench/shootout-fasta.rs
View file

@ -123,7 +123,7 @@ fn main() {
}; };
let writer = if os::getenv("RUST_BENCH").is_some() { let writer = if os::getenv("RUST_BENCH").is_some() {
let file = File::create(&Path::new("./shootout-fasta.data")); let file = File::create(&Path::init("./shootout-fasta.data"));
@mut file as @mut io::Writer @mut file as @mut io::Writer
} else { } else {
@mut io::stdout() as @mut io::Writer @mut io::stdout() as @mut io::Writer

6
src/test/run-pass/glob-std.rs
View file

@ -22,14 +22,14 @@ use std::io;
pub fn main() { pub fn main() {
fn mk_file(path: &str, directory: bool) { fn mk_file(path: &str, directory: bool) {
if directory { if directory {
io::fs::mkdir(&Path::new(path), io::UserRWX); io::fs::mkdir(&Path::init(path), io::UserRWX);
} else { } else {
io::File::create(&Path::new(path)); io::File::create(&Path::init(path));
} }
} }
fn abs_path(path: &str) -> Path { fn abs_path(path: &str) -> Path {
os::getcwd().join(&Path::new(path)) os::getcwd().join(&Path::init(path))
} }
fn glob_vec(pattern: &str) -> ~[Path] { fn glob_vec(pattern: &str) -> ~[Path] {

2
src/test/run-pass/issue-3424.rs
View file

@ -23,7 +23,7 @@ fn tester()
{ {
let loader: rsrc_loader = proc(_path) {result::Ok(~"more blah")}; let loader: rsrc_loader = proc(_path) {result::Ok(~"more blah")};
let path = path::Path::new("blah"); let path = path::Path::init("blah");
assert!(loader(&path).is_ok()); assert!(loader(&path).is_ok());
} }

2
src/test/run-pass/stat.rs
View file

@ -16,7 +16,7 @@ use extra::tempfile;
use std::io::File; use std::io::File;
pub fn main() { pub fn main() {
let dir = tempfile::TempDir::new_in(&Path::new("."), "").unwrap(); let dir = tempfile::TempDir::new_in(&Path::init("."), "").unwrap();
let path = dir.path().join("file"); let path = dir.path().join("file");
{ {

12
src/test/run-pass/tempfile.rs
View file

@ -30,7 +30,7 @@ use std::io::fs;
fn test_tempdir() { fn test_tempdir() {
let path = { let path = {
let p = TempDir::new_in(&Path::new("."), "foobar").unwrap(); let p = TempDir::new_in(&Path::init("."), "foobar").unwrap();
let p = p.path(); let p = p.path();
assert!(p.as_vec().ends_with(bytes!("foobar"))); assert!(p.as_vec().ends_with(bytes!("foobar")));
p.clone() p.clone()
@ -83,7 +83,7 @@ fn test_rm_tempdir() {
// Ideally these would be in std::os but then core would need // Ideally these would be in std::os but then core would need
// to depend on std // to depend on std
fn recursive_mkdir_rel() { fn recursive_mkdir_rel() {
let path = Path::new("frob"); let path = Path::init("frob");
let cwd = os::getcwd(); let cwd = os::getcwd();
debug!("recursive_mkdir_rel: Making: {} in cwd {} [{:?}]", path.display(), debug!("recursive_mkdir_rel: Making: {} in cwd {} [{:?}]", path.display(),
cwd.display(), path.exists()); cwd.display(), path.exists());
@ -94,21 +94,21 @@ fn recursive_mkdir_rel() {
} }
fn recursive_mkdir_dot() { fn recursive_mkdir_dot() {
let dot = Path::new("."); let dot = Path::init(".");
fs::mkdir_recursive(&dot, io::UserRWX); fs::mkdir_recursive(&dot, io::UserRWX);
let dotdot = Path::new(".."); let dotdot = Path::init("..");
fs::mkdir_recursive(&dotdot, io::UserRWX); fs::mkdir_recursive(&dotdot, io::UserRWX);
} }
fn recursive_mkdir_rel_2() { fn recursive_mkdir_rel_2() {
let path = Path::new("./frob/baz"); let path = Path::init("./frob/baz");
let cwd = os::getcwd(); let cwd = os::getcwd();
debug!("recursive_mkdir_rel_2: Making: {} in cwd {} [{:?}]", path.display(), debug!("recursive_mkdir_rel_2: Making: {} in cwd {} [{:?}]", path.display(),
cwd.display(), path.exists()); cwd.display(), path.exists());
fs::mkdir_recursive(&path, io::UserRWX); fs::mkdir_recursive(&path, io::UserRWX);
assert!(path.is_dir()); assert!(path.is_dir());
assert!(path.dir_path().is_dir()); assert!(path.dir_path().is_dir());
let path2 = Path::new("quux/blat"); let path2 = Path::init("quux/blat");
debug!("recursive_mkdir_rel_2: Making: {} in cwd {}", path2.display(), debug!("recursive_mkdir_rel_2: Making: {} in cwd {}", path2.display(),
cwd.display()); cwd.display());
fs::mkdir_recursive(&path2, io::UserRWX); fs::mkdir_recursive(&path2, io::UserRWX);