---

yaml
---
r: 145945
b: refs/heads/try2
c: 6741241
h: refs/heads/master
i:
  145943: c3e8823
v: v3

Author: lilyball

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 3a2735cb11efc997aa02646c13c008a883de6792
+refs/heads/try2: 6741241f4046aea4014b1a23618593fb481c8606
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/path2/mod.rs

@@ -13,6 +13,7 @@
 use container::Container;
 use c_str::CString;
 use clone::Clone;
+use fmt;
 use iter::Iterator;
 use option::{Option, None, Some};
 use str;
@@ -185,6 +186,21 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
         s
     }
 
+    /// 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.
+    fn display<'a>(&'a self) -> Display<'a, Self> {
+        Display{ path: self }
+    }
+
+    /// Returns an object that implements `fmt::Default` for printing filenames
+    ///
+    /// This will print the equivalent of `to_filename_display_str()` when used with a {}
+    /// format parameter. If there is no filename, nothing will be printed.
+    fn filename_display<'a>(&'a self) -> FilenameDisplay<'a, Self> {
+        FilenameDisplay{ path: self }
+    }
+
     /// Returns the directory component of `self`, as a byte vector (with no trailing separator).
     /// If `self` has no directory component, returns ['.'].
     fn dirname<'a>(&'a self) -> &'a [u8];
@@ -661,6 +677,31 @@ pub trait GenericPathUnsafe {
     }
 }
 
+/// Helper struct for printing paths with format!()
+pub struct Display<'self, P> {
+    priv path: &'self P
+}
+/// Helper struct for printing filenames with format!()
+pub struct FilenameDisplay<'self, P> {
+    priv path: &'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| {
+            f.pad(s)
+        }
+    }
+}
+
+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(""))
+        }
+    }
+}
+
 #[inline(always)]
 fn contains_nul(v: &[u8]) -> bool {
     v.iter().any(|&x| x == 0)

branches/try2/src/libstd/path2/posix.rs

@@ -730,6 +730,29 @@ mod tests {
         assert!(called);
     }
 
+    #[test]
+    fn test_display() {
+        macro_rules! t(
+            ($path:expr, $exp:expr, $expf:expr) => (
+                {
+                    let path = Path::from_vec($path);
+                    let f = format!("{}", path.display());
+                    assert_eq!(f.as_slice(), $exp);
+                    let f = format!("{}", path.filename_display());
+                    assert_eq!(f.as_slice(), $expf);
+                }
+            )
+        )
+
+        t!(b!("foo"), "foo", "foo");
+        t!(b!("foo/bar"), "foo/bar", "bar");
+        t!(b!("/"), "/", "");
+        t!(b!("foo", 0xff), "foo\uFFFD", "foo\uFFFD");
+        t!(b!("foo", 0xff, "/bar"), "foo\uFFFD/bar", "bar");
+        t!(b!("foo/", 0xff, "bar"), "foo/\uFFFDbar", "\uFFFDbar");
+        t!(b!(0xff, "foo/bar", 0xff), "\uFFFDfoo/bar\uFFFD", "bar\uFFFD");
+    }
+
     #[test]
     fn test_components() {
         macro_rules! t(

branches/try2/src/libstd/path2/windows.rs

@@ -1457,6 +1457,25 @@ mod tests {
         assert!(called);
     }
 
+    #[test]
+    fn test_display() {
+        macro_rules! t(
+            ($path:expr, $exp:expr, $expf:expr) => (
+                {
+                    let path = Path::from_str($path);
+                    let f = format!("{}", path.display());
+                    assert_eq!(f.as_slice(), $exp);
+                    let f = format!("{}", path.filename_display());
+                    assert_eq!(f.as_slice(), $expf);
+                }
+            )
+        )
+
+        t!("foo", "foo", "foo");
+        t!("foo\\bar", "foo\\bar", "bar");
+        t!("\\", "\\", "");
+    }
+
     #[test]
     fn test_components() {
         macro_rules! t(