user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

path2: Remove .with_display_str and friends

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

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

into

  do path.display().with_str |s| { ... }
This commit is contained in:
Kevin Ballard 2013-10-06 18:51:49 -07:00
parent d6d9b92683
commit c01a97b7a9
12 changed files with 131 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/libstd/io.rs
View file

@ -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")
}
}
}

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

@ -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())
}
}
}
}

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

@ -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);
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, "");
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, $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]

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

@ -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);