path2: Remove .with_display_str and friends

Rewrite these methods as methods on Display and FilenameDisplay. This
turns

  do path.with_display_str |s| { ... }

into

  do path.display().with_str |s| { ... }

Author: lilyball

src/compiletest/runtest.rs

@@ -334,7 +334,7 @@ fn check_error_patterns(props: &TestProps,
                         testfile: &Path,
                         ProcRes: &ProcRes) {
     if props.error_patterns.is_empty() {
-        do testfile.with_display_str |s| {
+        do testfile.display().with_str |s| {
             fatal(~"no error pattern specified in " + s);
         }
     }

src/librustdoc/html/render.rs

@@ -454,7 +454,7 @@ impl<'self> SourceCollector<'self> {
         let w = cur.open_writer(io::CreateOrTruncate);
         let mut w = BufferedWriter::new(w);
 
-        let title = cur.with_filename_display_str(|s| format!("{} -- source", s.unwrap()));
+        let title = cur.filename_display().with_str(|s| format!("{} -- source", s));
         let page = layout::Page {
             title: title,
             ty: "source",

src/librustpkg/installed_packages.rs

@@ -40,7 +40,7 @@ pub fn list_installed_packages(f: &fn(&PkgId) -> bool) -> bool  {
                     let rel_p = lib.path_relative_from(&parent).unwrap();
                     debug2!("Rel: {}", rel_p.display());
                     let rel_path = rel_p.join(basename);
-                    do rel_path.with_display_str |s| {
+                    do rel_path.display().with_str |s| {
                         debug2!("Rel name: {}", s);
                         f(&PkgId::new(s));
                     }

src/librustpkg/package_id.rs

@@ -88,7 +88,7 @@ impl PkgId {
 
     pub fn hash(&self) -> ~str {
         // FIXME (#9639): hash should take a &[u8] so we can hash the real path
-        do self.path.with_display_str |s| {
+        do self.path.display().with_str |s| {
             let vers = self.version.to_str();
             format!("{}-{}-{}", s, hash(s + vers), vers)
         }

src/librustpkg/package_source.rs

@@ -114,7 +114,7 @@ impl PkgSrc {
 
         }
 
-        debug2!("Checking dirs: {:?}", to_try.map(|p| p.to_display_str()).connect(":"));
+        debug2!("Checking dirs: {:?}", to_try.map(|p| p.display().to_str()).connect(":"));
 
         let path = to_try.iter().find(|&d| os::path_exists(d));
 

src/librustpkg/rustpkg.rs

@@ -337,7 +337,7 @@ impl CtxMethods for BuildContext {
             "list" => {
                 io::println("Installed packages:");
                 do installed_packages::list_installed_packages |pkg_id| {
-                    do pkg_id.path.with_display_str |s| {
+                    do pkg_id.path.display().with_str |s| {
                         println(s);
                     }
                     true
@@ -564,7 +564,7 @@ impl CtxMethods for BuildContext {
                                            &pkg_src.destination_workspace,
                                            &id).map(|s| Path::new(*s));
         debug2!("install: id = {}, about to call discover_outputs, {:?}",
-               id.to_str(), result.map(|p| p.to_display_str()));
+               id.to_str(), result.map(|p| p.display().to_str()));
         installed_files = installed_files + result;
         note(format!("Installed package {} to {}",
                      id.to_str(),

src/librustpkg/workspace.rs

@@ -27,7 +27,7 @@ pub fn each_pkg_parent_workspace(cx: &Context, pkgid: &PkgId, action: &fn(&Path)
         fail2!("Package {} not found in any of \
                     the following workspaces: {}",
                    pkgid.path.display(),
-                   rust_path().map(|p| p.to_display_str()).to_str());
+                   rust_path().map(|p| p.display().to_str()).to_str());
     }
     for ws in workspaces.iter() {
         if action(ws) {

src/libstd/io.rs

@@ -65,6 +65,7 @@ use ptr;
 use result::{Result, Ok, Err};
 use str::{StrSlice, OwnedStr};
 use str;
+use to_str::ToStr;
 use uint;
 use vec::{MutableVector, ImmutableVector, OwnedVector, OwnedCopyableVector, CopyableVector};
 use vec;
@@ -1068,7 +1069,7 @@ pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
     };
 
     if f as uint == 0u {
-        do path.with_display_str |p| {
+        do path.display().with_str |p| {
             Err(~"error opening " + p)
         }
     } else {
@@ -1753,7 +1754,7 @@ pub fn read_whole_file_str(file: &Path) -> Result<~str, ~str> {
         if str::is_utf8(bytes) {
             Ok(str::from_utf8(bytes))
         } else {
-            Err(file.to_display_str() + " is not UTF-8")
+            Err(file.display().to_str() + " is not UTF-8")
         }
     }
 }

src/libstd/path/mod.rs

@@ -75,6 +75,7 @@ use iter::Iterator;
 use option::{Option, None, Some};
 use str;
 use str::{OwnedStr, Str, StrSlice};
+use to_str::ToStr;
 use vec;
 use vec::{CopyableVector, OwnedCopyableVector, OwnedVector, Vector};
 use vec::{ImmutableEqVector, ImmutableVector};
@@ -190,59 +191,6 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
     /// Converts the Path into an owned byte vector
     fn into_vec(self) -> ~[u8];
 
-    /// Provides the path as a string
-    ///
-    /// If the path is not UTF-8, invalid sequences will be replaced with the unicode
-    /// replacement char. This involves allocation.
-    #[inline]
-    fn with_display_str<T>(&self, f: &fn(&str) -> T) -> T {
-        match self.as_str() {
-            Some(s) => f(s),
-            None => {
-                let s = self.to_display_str();
-                f(s.as_slice())
-            }
-        }
-    }
-
-    /// Returns the path as a string
-    ///
-    /// If the path is not UTF-8, invalid sequences will be replaced with the unicode
-    /// replacement char. This involves allocation.
-    ///
-    /// This is similar to `with_display_str()` except it will always allocate a new ~str.
-    fn to_display_str(&self) -> ~str {
-        from_utf8_with_replacement(self.as_vec())
-    }
-
-    /// Provides the filename as a string
-    ///
-    /// If the filename is not UTF-8, invalid sequences will be replaced with the unicode
-    /// replacement char. This involves allocation.
-    #[inline]
-    fn with_filename_display_str<T>(&self, f: &fn(Option<&str>) -> T) -> T {
-        match self.filename_str() {
-            s@Some(_) => f(s),
-            None => {
-                let o = self.to_filename_display_str();
-                f(o.map(|s|s.as_slice()))
-            }
-        }
-    }
-
-    /// Returns the filename as a string
-    ///
-    /// If the filename is not UTF-8, invalid sequences will be replaced with the unicode
-    /// replacement char. This involves allocation.
-    ///
-    /// This is similar to `to_filename_display_str` except it will always allocate a new ~str.
-    fn to_filename_display_str(&self) -> Option<~str> {
-        match self.filename() {
-            None => None,
-            Some(v) => Some(from_utf8_with_replacement(v))
-        }
-    }
-
     /// Returns an object that implements `fmt::Default` for printing paths
     ///
     /// This will print the equivalent of `to_display_str()` when used with a {} format parameter.
@@ -764,16 +712,75 @@ pub struct FilenameDisplay<'self, P> {
 
 impl<'self, P: GenericPath> fmt::Default for Display<'self, P> {
     fn fmt(d: &Display<P>, f: &mut fmt::Formatter) {
-        do d.path.with_display_str |s| {
+        do d.with_str |s| {
             f.pad(s)
         }
     }
 }
 
+impl<'self, P: GenericPath> ToStr for Display<'self, P> {
+    /// Returns the path as a string
+    ///
+    /// If the path is not UTF-8, invalid sequences with be replaced with the
+    /// unicode replacement char. This involves allocation.
+    fn to_str(&self) -> ~str {
+        from_utf8_with_replacement(self.path.as_vec())
+    }
+}
+
+impl<'self, P: GenericPath> Display<'self, P> {
+    /// Provides the path as a string to a closure
+    ///
+    /// If the path is not UTF-8, invalid sequences will be replaced with the
+    /// unicode replacement char. This involves allocation.
+    #[inline]
+    pub fn with_str<T>(&self, f: &fn(&str) -> T) -> T {
+        match self.path.as_str() {
+            Some(s) => f(s),
+            None => {
+                let s = self.to_str();
+                f(s.as_slice())
+            }
+        }
+    }
+}
+
 impl<'self, P: GenericPath> fmt::Default for FilenameDisplay<'self, P> {
     fn fmt(d: &FilenameDisplay<P>, f: &mut fmt::Formatter) {
-        do d.path.with_filename_display_str |s| {
-            f.pad(s.unwrap_or(""))
+        do d.with_str |s| {
+            f.pad(s)
+        }
+    }
+}
+
+impl<'self, P: GenericPath> ToStr for FilenameDisplay<'self, P> {
+    /// Returns the filename as a string. If there is no filename, ~"" will be
+    /// returned.
+    ///
+    /// If the filename is not UTF-8, invalid sequences will be replaced with
+    /// the unicode replacement char. This involves allocation.
+    fn to_str(&self) -> ~str {
+        match self.path.filename() {
+            None => ~"",
+            Some(v) => from_utf8_with_replacement(v)
+        }
+    }
+}
+
+impl<'self, P: GenericPath> FilenameDisplay<'self, P> {
+    /// Provides the filename as a string to a closure. If there is no
+    /// filename, "" will be provided.
+    ///
+    /// If the filename is not UTF-8, invalid sequences will be replaced with
+    /// the unicode replacement char. This involves allocation.
+    #[inline]
+    pub fn with_str<T>(&self, f: &fn(&str) -> T) -> T {
+        match self.path.filename_str() {
+            Some(s) => f(s),
+            None => {
+                let s = self.to_str();
+                f(s.as_slice())
+            }
         }
     }
 }

src/libstd/path/posix.rs

@@ -745,50 +745,53 @@ mod tests {
 
     #[test]
     fn test_display_str() {
-        assert_eq!(Path::new("foo").to_display_str(), ~"foo");
-        assert_eq!(Path::new(b!("foo", 0x80)).to_display_str(), ~"foo\uFFFD");
-        assert_eq!(Path::new(b!("foo", 0xff, "bar")).to_display_str(), ~"foo\uFFFDbar");
-        assert_eq!(Path::new(b!("foo", 0xff, "/bar")).to_filename_display_str(), Some(~"bar"));
-        assert_eq!(Path::new(b!("foo/", 0xff, "bar")).to_filename_display_str(),
-                   Some(~"\uFFFDbar"));
-        assert_eq!(Path::new(b!("/")).to_filename_display_str(), None);
-
-        let mut called = false;
-        do Path::new("foo").with_display_str |s| {
-            assert_eq!(s, "foo");
-            called = true;
-        };
-        assert!(called);
-        called = false;
-        do Path::new(b!("foo", 0x80)).with_display_str |s| {
-            assert_eq!(s, "foo\uFFFD");
-            called = true;
-        };
-        assert!(called);
-        called = false;
-        do Path::new(b!("foo", 0xff, "bar")).with_display_str |s| {
-            assert_eq!(s, "foo\uFFFDbar");
-            called = true;
-        };
-        assert!(called);
-        called = false;
-        do Path::new(b!("foo", 0xff, "/bar")).with_filename_display_str |s| {
-            assert_eq!(s, Some("bar"));
-            called = true;
-        }
-        assert!(called);
-        called = false;
-        do Path::new(b!("foo/", 0xff, "bar")).with_filename_display_str |s| {
-            assert_eq!(s, Some("\uFFFDbar"));
-            called = true;
-        }
-        assert!(called);
-        called = false;
-        do Path::new(b!("/")).with_filename_display_str |s| {
-            assert!(s.is_none());
-            called = true;
-        }
-        assert!(called);
+        macro_rules! t(
+            ($path:expr, $disp:ident, $exp:expr) => (
+                {
+                    let path = Path::new($path);
+                    assert_eq!(path.$disp().to_str(), ~$exp);
+                }
+            )
+        )
+        t!("foo", display, "foo");
+        t!(b!("foo", 0x80), display, "foo\uFFFD");
+        t!(b!("foo", 0xff, "bar"), display, "foo\uFFFDbar");
+        t!(b!("foo", 0xff, "/bar"), filename_display, "bar");
+        t!(b!("foo/", 0xff, "bar"), filename_display, "\uFFFDbar");
+        t!(b!("/"), filename_display, "");
+
+        macro_rules! t(
+            ($path:expr, $exp:expr) => (
+                {
+                    let mut called = false;
+                    let path = Path::new($path);
+                    do path.display().with_str |s| {
+                        assert_eq!(s, $exp);
+                        called = true;
+                    };
+                    assert!(called);
+                }
+            );
+            ($path:expr, $exp:expr, filename) => (
+                {
+                    let mut called = false;
+                    let path = Path::new($path);
+                    do path.filename_display().with_str |s| {
+                        assert_eq!(s, $exp);
+                        called = true;
+
+                    };
+                    assert!(called);
+                }
+            )
+        )
+
+        t!("foo", "foo");
+        t!(b!("foo", 0x80), "foo\uFFFD");
+        t!(b!("foo", 0xff, "bar"), "foo\uFFFDbar");
+        t!(b!("foo", 0xff, "/bar"), "bar", filename);
+        t!(b!("foo/", 0xff, "bar"), "\uFFFDbar", filename);
+        t!(b!("/"), "", filename);
     }
 
     #[test]

src/libstd/path/windows.rs

@@ -350,16 +350,6 @@ impl GenericPath for Path {
         self.repr.into_bytes()
     }
 
-    #[inline]
-    fn with_display_str<T>(&self, f: &fn(&str) -> T) -> T {
-        f(self.repr.as_slice())
-    }
-
-    #[inline]
-    fn to_display_str(&self) -> ~str {
-        self.repr.clone()
-    }
-
     #[inline]
     fn dirname<'a>(&'a self) -> &'a [u8] {
         self.dirname_str().unwrap().as_bytes()
@@ -1462,18 +1452,22 @@ mod tests {
 
     #[test]
     fn test_display_str() {
-        assert_eq!(Path::new("foo").to_display_str(), ~"foo");
-        assert_eq!(Path::new(b!("\\")).to_filename_display_str(), None);
+        let path = Path::new("foo");
+        assert_eq!(path.display().to_str(), ~"foo");
+        let path = Path::new(b!("\\"));
+        assert_eq!(path.filename_display().to_str(), ~"");
 
         let mut called = false;
-        do Path::new("foo").with_display_str |s| {
+        let path = Path::new("foo");
+        do path.display().with_str |s| {
             assert_eq!(s, "foo");
             called = true;
         };
         assert!(called);
         called = false;
-        do Path::new(b!("\\")).with_filename_display_str |s| {
-            assert!(s.is_none());
+        let path = Path::new(b!("\\"));
+        do path.filename_display().with_str |s| {
+            assert_eq!(s, "");
             called = true;
         }
         assert!(called);