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| { ... }

3 files changed, 119 insertions, 115 deletions

diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 561155f2258..ff370e9d7c1 100644
--- a/src/libstd/path/mod.rs
+++ b/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())
+            }
         }
     }
 }
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 3400b673c30..8acc1346bcc 100644
--- a/src/libstd/path/posix.rs
+++ b/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]
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index cc04261ec66..86c4bb6f8a3 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -351,16 +351,6 @@ impl GenericPath for Path {
     }
 
     #[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);