faster_path 0.3.10 → 0.4.0

data/src/basename.rs

@@ -1,146 +1,243 @@
-extern crate memchr;
-
-use self::memchr::memrchr;
-
-use path_parsing::{find_last_sep_pos, find_last_non_sep_pos};
-
-pub fn basename<'a>(path: &'a str, ext: &str) -> &'a str {
-  let bytes: &[u8] = path.as_bytes();
-  let mut left: usize = 0;
-  let mut right: usize = bytes.len();
-  if let Some(last_slash_pos) = find_last_sep_pos(bytes) {
-    if last_slash_pos == right - 1 {
-      if let Some(pos) = find_last_non_sep_pos(&bytes[..last_slash_pos]) {
-        right = pos + 1;
-      } else {
-        return "/";
-      }
-      if let Some(pos) = find_last_sep_pos(&bytes[..right]) {
-        left = pos + 1;
-      }
-    } else {
-      left = last_slash_pos + 1;
-    }
+use memchr::memrchr;
+
+use crate::path_parsing::{Rules, SEP_BYTES};
+
+// Ruby's `File.basename(path, ext)`.
+pub fn basename<'a>(rules: Rules, path: &'a [u8], ext: &[u8]) -> &'a [u8] {
+  let (name, base_len) = last_component(rules, path);
+  match base_len {
+    Some(base_len) => &name[..ext_end(rules, name, base_len, ext)],
+    None => name,
   }
-  &path[left..left + ext_end(&bytes[left..right], ext)]
 }
 
-fn ext_end(slice: &[u8], ext: &str) -> usize {
-  if ext.len() >= slice.len() || slice == b"." || slice == b".." {
-    return slice.len();
+// Ruby's `ruby_enc_find_basename`: the last component of the path, without
+// trailing separators (and on Windows, trailing dots, spaces and `:stream`),
+// and where that component ends without its extension. A path that is only
+// separators and prefixes has no extension: its "component" is a separator,
+// or "" for a drive letter.
+pub fn last_component(rules: Rules, path: &[u8]) -> (&[u8], Option<usize>) {
+  if path.is_empty() {
+    return (path, None);
   }
-  let ext_bytes = ext.as_bytes();
-  if ext_bytes.len() == 2 && *ext_bytes.get(1).unwrap() == b'*' {
-    match memrchr(*ext_bytes.get(0).unwrap(), slice) {
-      Some(end) if end != 0 => return end,
-      _ => {}
+  if !rules.is_dosish() {
+    // On Unix this is just the last name, or the last separator.
+    let end = match rules.last_non_sep_pos(path) {
+      Some(pos) => pos + 1,
+      None => return (&path[path.len() - 1..], None),
     };
-  } else if slice.ends_with(ext_bytes) {
-    return slice.len() - ext_bytes.len();
+    // Paths are short: a plain scan beats `memrchr`'s setup here.
+    let start = path[..end].iter().rposition(|&c| c == b'/').map_or(0, |pos| pos + 1);
+    let component = &path[start..end];
+    return (component, Some(base_len(component)));
+  }
+  let root = rules.skip_prefix(path);
+  let mut name = root;
+  while name < path.len() && rules.is_sep(path[name]) {
+    name += 1;
+  }
+  if name == path.len() {
+    if name != root {
+      // The last separator
+      return (&path[name - 1..name], None);
+    }
+    if path[name - 1] == b':' {
+      // A drive letter
+      return (&path[name..], None);
+    }
+    // A UNC prefix
+    return (SEP_BYTES, None);
   }
-  slice.len()
+  let start = match rules.last_separator(&path[name..]) {
+    Some(pos) => {
+      let mut start = name + pos;
+      while rules.is_sep(path[start]) {
+        start += 1;
+      }
+      start
+    }
+    None => name,
+  };
+  let rest = &path[start..];
+  let component = &rest[..rules.ntfs_tail(rest)];
+  (component, Some(base_len(component)))
+}
+
+// Where the name ends without its extension: at its last dot, unless that
+// is one of its leading dots.
+fn base_len(component: &[u8]) -> usize {
+  let dots = component.iter().take_while(|&&c| c == b'.').count();
+  component[dots..].iter().rposition(|&c| c == b'.').map_or(component.len(), |pos| dots + pos)
+}
+
+// Ruby's `rmext`: where `component` ends without the extension `ext`, or
+// its length if `ext` isn't there. `ext` is an extension to remove, ".*"
+// for any extension, or a character followed by `*` to remove everything
+// from the last occurrence of that character.
+pub fn ext_end(rules: Rules, component: &[u8], base_len: usize, ext: &[u8]) -> usize {
+  let len = component.len();
+  let end = match *ext {
+    [] => 0,
+    [b'.', b'*'] => base_len,
+    [c, b'*'] => memrchr(c, component).unwrap_or(len),
+    _ if len < ext.len() => len,
+    _ => {
+      let start = len - ext.len();
+      if rules.same_path(&component[start..], ext) { start } else { 0 }
+    }
+  };
+  if end == 0 { len } else { end }
+}
+
+#[cfg(test)]
+fn basename_str<'a>(path: &'a str, ext: &str) -> &'a str {
+  std::str::from_utf8(basename(Rules::UNIX, path.as_bytes(), ext.as_bytes())).unwrap()
+}
+
+#[cfg(test)]
+fn windows_basename<'a>(path: &'a str, ext: &str) -> &'a str {
+  std::str::from_utf8(basename(Rules::WINDOWS, path.as_bytes(), ext.as_bytes())).unwrap()
 }
 
 #[test]
 fn non_dot_asterisk_ext() {
   // This is undocumented Ruby functionality. We match it in case some code out there relies on it.
-  assert_eq!(basename("abc", "b*"), "a");
-  assert_eq!(basename("abc", "abc"), "abc");
-  assert_eq!(basename("abc", "a*"), "abc");
-  assert_eq!(basename("playlist", "l*"), "play");
+  assert_eq!(basename_str("abc", "b*"), "a");
+  assert_eq!(basename_str("abc", "abc"), "abc");
+  assert_eq!(basename_str("abc", "a*"), "abc");
+  assert_eq!(basename_str("playlist", "l*"), "play");
   // Treated as literal "*":
-  assert_eq!(basename("playlist", "yl*"), "playlist");
-  assert_eq!(basename("playl*", "yl*"), "pla");
+  assert_eq!(basename_str("playlist", "yl*"), "playlist");
+  assert_eq!(basename_str("playl*", "yl*"), "pla");
 }
 
 #[test]
 fn empty() {
-  assert_eq!(basename("", ""), "");
-  assert_eq!(basename("", ".*"), "");
-  assert_eq!(basename("", ".a"), "");
+  assert_eq!(basename_str("", ""), "");
+  assert_eq!(basename_str("", ".*"), "");
+  assert_eq!(basename_str("", ".a"), "");
 }
 
 #[test]
 fn sep() {
-  assert_eq!(basename("/", ""), "/");
-  assert_eq!(basename("//", ""), "/");
+  assert_eq!(basename_str("/", ""), "/");
+  assert_eq!(basename_str("//", ""), "/");
 }
 
 #[test]
 fn trailing_dot() {
-  assert_eq!(basename("file.test.", ""), "file.test.");
-  assert_eq!(basename("file.test.", "."), "file.test");
-  assert_eq!(basename("file.test.", ".*"), "file.test");
+  assert_eq!(basename_str("file.test.", ""), "file.test.");
+  assert_eq!(basename_str("file.test.", "."), "file.test");
+  assert_eq!(basename_str("file.test.", ".*"), "file.test");
 }
 
 #[test]
 fn trailing_dot_dot() {
-  assert_eq!(basename("a..", ".."), "a");
-  assert_eq!(basename("a..", ".*"), "a.");
+  assert_eq!(basename_str("a..", ".."), "a");
+  assert_eq!(basename_str("a..", ".*"), "a.");
 }
 
 #[test]
 fn dot() {
-  assert_eq!(basename(".", ""), ".");
-  assert_eq!(basename(".", "."), ".");
-  assert_eq!(basename(".", ".*"), ".");
+  assert_eq!(basename_str(".", ""), ".");
+  assert_eq!(basename_str(".", "."), ".");
+  assert_eq!(basename_str(".", ".*"), ".");
 }
 
 #[test]
 fn dot_dot() {
-  assert_eq!(basename("..", ""), "..");
-  assert_eq!(basename("..", ".*"), "..");
-  assert_eq!(basename("..", ".."), "..");
-  assert_eq!(basename("..", "..."), "..");
+  assert_eq!(basename_str("..", ""), "..");
+  assert_eq!(basename_str("..", ".*"), "..");
+  assert_eq!(basename_str("..", ".."), "..");
+  assert_eq!(basename_str("..", "..."), "..");
 }
 
 #[test]
 fn non_dot_ext() {
-  assert_eq!(basename("abc", "bc"), "a");
+  assert_eq!(basename_str("abc", "bc"), "a");
 }
 
 #[test]
 fn basename_eq_ext() {
-  assert_eq!(basename(".x", ".x"), ".x");
-  assert_eq!(basename(".x", ".*"), ".x");
+  assert_eq!(basename_str(".x", ".x"), ".x");
+  assert_eq!(basename_str(".x", ".*"), ".x");
 }
 
 #[test]
 fn absolute() {
-  assert_eq!(basename("/a/b///c", ""), "c");
+  assert_eq!(basename_str("/a/b///c", ""), "c");
 }
 
 #[test]
 fn trailing_slashes_absolute() {
-  assert_eq!(basename("/a/b///c//////", ""), "c");
+  assert_eq!(basename_str("/a/b///c//////", ""), "c");
 }
 
 #[test]
 fn relative() {
-  assert_eq!(basename("b///c", ""), "c");
+  assert_eq!(basename_str("b///c", ""), "c");
 }
 
 #[test]
 fn trailing_slashes_relative() {
-  assert_eq!(basename("b/c//", ""), "c");
+  assert_eq!(basename_str("b/c//", ""), "c");
 }
 
 #[test]
 fn root() {
-  assert_eq!(basename("//c", ""), "c");
+  assert_eq!(basename_str("//c", ""), "c");
 }
 
 #[test]
 fn trailing_slashes_root() {
-  assert_eq!(basename("//c//", ""), "c");
+  assert_eq!(basename_str("//c//", ""), "c");
 }
 
 #[test]
 fn trailing_slashes_relative_root() {
-  assert_eq!(basename("c//", ""), "c");
+  assert_eq!(basename_str("c//", ""), "c");
 }
 
 #[test]
 fn edge_case_all_seps() {
-  assert_eq!("/", basename("///", ".*"));
+  assert_eq!("/", basename_str("///", ".*"));
+}
+
+#[test]
+fn ext_compared_like_ruby() {
+  assert_eq!(basename_str("..", "."), ".");
+  assert_eq!(basename_str("a.rb", ".RB"), "a.rb");
+  assert_eq!(windows_basename("a.rb", ".RB"), "a");
+}
+
+#[test]
+fn windows_separators() {
+  assert_eq!(windows_basename("a\\b", ""), "b");
+  assert_eq!(windows_basename("a\\b\\", ""), "b");
+  assert_eq!(windows_basename("a/b\\c", ""), "c");
+  assert_eq!(windows_basename("\\", ""), "\\");
+  assert_eq!(basename_str("a\\b", ""), "a\\b");
+}
+
+#[test]
+fn windows_prefixes() {
+  assert_eq!(windows_basename("C:", ""), "");
+  assert_eq!(windows_basename("C:/", ""), "/");
+  assert_eq!(windows_basename("C:/a", ""), "a");
+  assert_eq!(windows_basename("C:a", ""), "a");
+  assert_eq!(windows_basename("//a/b", ""), "/");
+  assert_eq!(windows_basename("//a/b/", ""), "/");
+  assert_eq!(windows_basename("//a/b/c", ""), "c");
+  assert_eq!(basename_str("//a/b", ""), "b");
+}
+
+#[test]
+fn windows_ntfs_names() {
+  assert_eq!(windows_basename("foo.test ", ""), "foo.test");
+  assert_eq!(windows_basename("foo.test.", ""), "foo.test");
+  assert_eq!(windows_basename("foo.test::$DATA", ""), "foo.test");
+  assert_eq!(windows_basename("foo.test ", ".test"), "foo");
+  assert_eq!(windows_basename("foo.test.", ".*"), "foo");
+  assert_eq!(windows_basename("foo.test::$DATA", ".*"), "foo");
+  assert_eq!(windows_basename("...", ""), "...");
 }

data/src/chop_basename.rs

@@ -1,30 +1,93 @@
-use path_parsing::{find_last_non_sep_pos, find_last_sep_pos};
-use std::str;
-
-pub fn chop_basename<'a>(input: &'a str) -> Option<(&'a str, &'a str)> {
-  let bytes = input.as_bytes();
-  let len = find_last_non_sep_pos(&bytes)? + 1;
-  let base_start = find_last_sep_pos(&bytes[..len]).map_or(0, |pos| pos + 1);
-  if base_start == len {
+use memchr::memmem;
+
+use crate::basename::basename;
+use crate::path_parsing::{offset_in, Rules};
+
+// Pathname's `chop_basename`: the path split before its basename, unless
+// the basename is empty or a separator.
+pub fn chop_basename(rules: Rules, path: &[u8]) -> Option<(&[u8], &[u8])> {
+  let base = basename(rules, path, b"");
+  if base.is_empty() || (base.len() == 1 && rules.is_sep(base[0])) {
     return None;
   }
-  Some((&input[0..base_start], &input[base_start..len]))
+  // `path.rindex(base)`. On Unix, nothing after the basename can contain it.
+  let start = if rules.is_dosish() { memmem::rfind(path, base)? } else { offset_in(path, base) };
+  Some((&path[..start], &path[start..start + base.len()]))
+}
+
+// Pathname's `relative?`: whether chopping every basename off leaves nothing.
+pub fn is_relative(rules: Rules, path: &[u8]) -> bool {
+  if !rules.is_dosish() {
+    return path.first() != Some(&b'/');
+  }
+  let mut prefix = path;
+  while let Some((rest, _)) = chop_basename(rules, prefix) {
+    prefix = rest;
+  }
+  prefix.is_empty()
+}
+
+#[cfg(test)]
+fn chop_basename_str(input: &str) -> Option<(&str, &str)> {
+  chop_basename(Rules::UNIX, input.as_bytes()).map(|(dirname, basename)| {
+    (std::str::from_utf8(dirname).unwrap(), std::str::from_utf8(basename).unwrap())
+  })
 }
 
 #[test]
 fn it_chops_the_basename_and_dirname() {
-  assert_eq!(chop_basename(""),           None );
-  assert_eq!(chop_basename("/"),          None );
-  assert_eq!(chop_basename("."),          Some(("", ".")) );
-  assert_eq!(chop_basename("asdf/asdf"),  Some(("asdf/",     "asdf")) );
-  assert_eq!(chop_basename("asdf.txt"),   Some(("",      "asdf.txt")) );
-  assert_eq!(chop_basename("asdf/"),      Some(("",          "asdf")) );
-  assert_eq!(chop_basename("/asdf/"),     Some(("/",         "asdf")) );
-  assert_eq!(chop_basename("a///b"),      Some(("a///",         "b")) );
-  assert_eq!(chop_basename("a///b//"),    Some(("a///",         "b")) );
-  assert_eq!(chop_basename("/a///b//"),   Some(("/a///",        "b")) );
-  assert_eq!(chop_basename("/a///b//"),   Some(("/a///",        "b")) );
+  assert_eq!(chop_basename_str(""),           None );
+  assert_eq!(chop_basename_str("/"),          None );
+  assert_eq!(chop_basename_str("."),          Some(("", ".")) );
+  assert_eq!(chop_basename_str("asdf/asdf"),  Some(("asdf/",     "asdf")) );
+  assert_eq!(chop_basename_str("asdf.txt"),   Some(("",      "asdf.txt")) );
+  assert_eq!(chop_basename_str("asdf/"),      Some(("",          "asdf")) );
+  assert_eq!(chop_basename_str("/asdf/"),     Some(("/",         "asdf")) );
+  assert_eq!(chop_basename_str("a///b"),      Some(("a///",         "b")) );
+  assert_eq!(chop_basename_str("a///b//"),    Some(("a///",         "b")) );
+  assert_eq!(chop_basename_str("/a///b//"),   Some(("/a///",        "b")) );
+  assert_eq!(chop_basename_str("/a///b//"),   Some(("/a///",        "b")) );
+
+  assert_eq!(chop_basename_str("./../..///.../..//"), Some(("./../..///.../", "..")));
+}
 
-  assert_eq!(chop_basename("./../..///.../..//"), Some(("./../..///.../", "..")));
+#[test]
+fn it_chops_non_utf8_paths() {
+  assert_eq!(chop_basename(Rules::UNIX, b"\xff/\xfe\xfd/"), Some((&b"\xff/"[..], &b"\xfe\xfd"[..])));
+}
+
+#[cfg(test)]
+fn windows_chop(input: &str) -> Option<(&str, &str)> {
+  chop_basename(Rules::WINDOWS, input.as_bytes()).map(|(dirname, basename)| {
+    (std::str::from_utf8(dirname).unwrap(), std::str::from_utf8(basename).unwrap())
+  })
+}
+
+#[test]
+fn it_chops_windows_paths() {
+  assert_eq!(windows_chop("a\\b"), Some(("a\\", "b")));
+  assert_eq!(windows_chop("a\\b\\"), Some(("a\\", "b")));
+  assert_eq!(windows_chop("C:"), None);
+  assert_eq!(windows_chop("C:/"), None);
+  assert_eq!(windows_chop("C:/a"), Some(("C:/", "a")));
+  assert_eq!(windows_chop("C:a"), Some(("C:", "a")));
+  assert_eq!(windows_chop("//a/b"), None);
+  assert_eq!(windows_chop("//a/b/c"), Some(("//a/b/", "c")));
+  assert_eq!(windows_chop("a."), Some(("", "a")));
 }
 
+#[test]
+fn it_knows_relative_paths() {
+  for &rules in &[Rules::UNIX, Rules::WINDOWS] {
+    assert!(is_relative(rules, b""));
+    assert!(is_relative(rules, b"a"));
+    assert!(is_relative(rules, b"a/b"));
+    assert!(!is_relative(rules, b"/"));
+    assert!(!is_relative(rules, b"/a"));
+  }
+  assert!(is_relative(Rules::UNIX, b"C:/a"));
+  assert!(is_relative(Rules::UNIX, b"\\a"));
+  for path in &["A:", "A:/", "A:/a", "//", "//a", "//a/", "//a/b", "//a/b/", "//a/b/c", "\\a"] {
+    assert!(!is_relative(Rules::WINDOWS, path.as_bytes()), "{}", path);
+  }
+}

data/src/cleanpath_aggressive.rs

@@ -1,19 +1,21 @@
 use std::borrow::Cow;
-use prepend_prefix::prepend_prefix;
-use basename::basename;
-use chop_basename::chop_basename;
-use path_parsing::{SEP_STR, contains_sep};
 
-pub fn cleanpath_aggressive(path: &str) -> Cow<str> {
-  let mut names: Vec<&str> = vec![];
+use crate::basename::basename;
+use crate::chop_basename::chop_basename;
+use crate::path_parsing::{Rules, SEP_BYTES};
+use crate::prepend_prefix::prepend_prefix;
+
+// Pathname's `cleanpath_aggressive`
+pub fn cleanpath_aggressive(rules: Rules, path: &[u8]) -> Cow<'_, [u8]> {
+  let mut names: Vec<&[u8]> = vec![];
   let mut prefix = path;
-  while let Some((ref p, ref base)) = chop_basename(&prefix) {
+  while let Some((p, base)) = chop_basename(rules, prefix) {
     prefix = p;
-    match base.as_ref() {
-      "." => {}
-      ".." => names.push(base),
+    match base {
+      b"." => {}
+      b".." => names.push(base),
       _ => {
-        if names.last() == Some(&"..") {
+        if names.last() == Some(&&b".."[..]) {
           names.pop();
         } else {
           names.push(base);
@@ -21,72 +23,86 @@ pub fn cleanpath_aggressive(path: &str) -> Cow<str> {
       }
     }
   }
-  // // Windows Feature
-  //
-  // ```ruby
-  // pre.tr!(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
-  // ```
-  //
-  if contains_sep(basename(&prefix, "").as_bytes()) {
-    let len = names.iter().rposition(|&c| c != "..").map_or(0, |pos| pos + 1);
+  let prefix = with_separators(rules, prefix);
+  if rules.contains_sep(basename(rules, &prefix, b"")) {
+    let len = names.iter().rposition(|&c| c != b"..").map_or(0, |pos| pos + 1);
     names.truncate(len);
   }
   names.reverse();
-  prepend_prefix(&prefix, &names.join(&SEP_STR))
+  let path = prepend_prefix(rules, &prefix, &names.join(SEP_BYTES));
+  Cow::Owned(path.into_owned())
+}
+
+// `pre.tr!(File::ALT_SEPARATOR, File::SEPARATOR)`
+pub fn with_separators(rules: Rules, prefix: &[u8]) -> Cow<'_, [u8]> {
+  if rules.is_dosish() && prefix.contains(&b'\\') {
+    Cow::Owned(prefix.iter().map(|&c| if c == b'\\' { b'/' } else { c }).collect())
+  } else {
+    Cow::Borrowed(prefix)
+  }
+}
+
+#[cfg(test)]
+fn cleanpath_aggressive_str(path: &str) -> String {
+  String::from_utf8(cleanpath_aggressive(Rules::UNIX, path.as_bytes()).into_owned()).unwrap()
+}
+
+#[cfg(test)]
+fn windows_cleanpath_aggressive(path: &str) -> String {
+  String::from_utf8(cleanpath_aggressive(Rules::WINDOWS, path.as_bytes()).into_owned()).unwrap()
 }
 
 #[test]
 fn it_aggressively_cleans_the_path() {
-  assert_eq!(cleanpath_aggressive("/")                     ,       "/");
-  assert_eq!(cleanpath_aggressive("")                      ,       ".");
-  assert_eq!(cleanpath_aggressive(".")                     ,       ".");
-  assert_eq!(cleanpath_aggressive("..")                    ,      "..");
-  assert_eq!(cleanpath_aggressive("a")                     ,       "a");
-  assert_eq!(cleanpath_aggressive("/.")                    ,       "/");
-  assert_eq!(cleanpath_aggressive("/..")                   ,       "/");
-  assert_eq!(cleanpath_aggressive("/a")                    ,      "/a");
-  assert_eq!(cleanpath_aggressive("./")                    ,       ".");
-  assert_eq!(cleanpath_aggressive("../")                   ,      "..");
-  assert_eq!(cleanpath_aggressive("a/")                    ,       "a");
-  assert_eq!(cleanpath_aggressive("a//b")                  ,     "a/b");
-  assert_eq!(cleanpath_aggressive("a/.")                   ,       "a");
-  assert_eq!(cleanpath_aggressive("a/./")                  ,       "a");
-  assert_eq!(cleanpath_aggressive("a/..")                  ,       ".");
-  assert_eq!(cleanpath_aggressive("a/../")                 ,       ".");
-  assert_eq!(cleanpath_aggressive("/a/.")                  ,      "/a");
-  assert_eq!(cleanpath_aggressive("./..")                  ,      "..");
-  assert_eq!(cleanpath_aggressive("../.")                  ,      "..");
-  assert_eq!(cleanpath_aggressive("./../")                 ,      "..");
-  assert_eq!(cleanpath_aggressive(".././")                 ,      "..");
-  assert_eq!(cleanpath_aggressive("/./..")                 ,       "/");
-  assert_eq!(cleanpath_aggressive("/../.")                 ,       "/");
-  assert_eq!(cleanpath_aggressive("/./../")                ,       "/");
-  assert_eq!(cleanpath_aggressive("/.././")                ,       "/");
-  assert_eq!(cleanpath_aggressive("a/b/c")                 ,   "a/b/c");
-  assert_eq!(cleanpath_aggressive("./b/c")                 ,     "b/c");
-  assert_eq!(cleanpath_aggressive("a/./c")                 ,     "a/c");
-  assert_eq!(cleanpath_aggressive("a/b/.")                 ,     "a/b");
-  assert_eq!(cleanpath_aggressive("a/../.")                ,       ".");
-  assert_eq!(cleanpath_aggressive("/../.././../a")         ,      "/a");
-  assert_eq!(cleanpath_aggressive("a/b/../../../../c/../d"), "../../d");
+  assert_eq!(cleanpath_aggressive_str("/")                     ,       "/");
+  assert_eq!(cleanpath_aggressive_str("")                      ,       ".");
+  assert_eq!(cleanpath_aggressive_str(".")                     ,       ".");
+  assert_eq!(cleanpath_aggressive_str("..")                    ,      "..");
+  assert_eq!(cleanpath_aggressive_str("a")                     ,       "a");
+  assert_eq!(cleanpath_aggressive_str("/.")                    ,       "/");
+  assert_eq!(cleanpath_aggressive_str("/..")                   ,       "/");
+  assert_eq!(cleanpath_aggressive_str("/a")                    ,      "/a");
+  assert_eq!(cleanpath_aggressive_str("./")                    ,       ".");
+  assert_eq!(cleanpath_aggressive_str("../")                   ,      "..");
+  assert_eq!(cleanpath_aggressive_str("a/")                    ,       "a");
+  assert_eq!(cleanpath_aggressive_str("a//b")                  ,     "a/b");
+  assert_eq!(cleanpath_aggressive_str("a/.")                   ,       "a");
+  assert_eq!(cleanpath_aggressive_str("a/./")                  ,       "a");
+  assert_eq!(cleanpath_aggressive_str("a/..")                  ,       ".");
+  assert_eq!(cleanpath_aggressive_str("a/../")                 ,       ".");
+  assert_eq!(cleanpath_aggressive_str("/a/.")                  ,      "/a");
+  assert_eq!(cleanpath_aggressive_str("./..")                  ,      "..");
+  assert_eq!(cleanpath_aggressive_str("../.")                  ,      "..");
+  assert_eq!(cleanpath_aggressive_str("./../")                 ,      "..");
+  assert_eq!(cleanpath_aggressive_str(".././")                 ,      "..");
+  assert_eq!(cleanpath_aggressive_str("/./..")                 ,       "/");
+  assert_eq!(cleanpath_aggressive_str("/../.")                 ,       "/");
+  assert_eq!(cleanpath_aggressive_str("/./../")                ,       "/");
+  assert_eq!(cleanpath_aggressive_str("/.././")                ,       "/");
+  assert_eq!(cleanpath_aggressive_str("a/b/c")                 ,   "a/b/c");
+  assert_eq!(cleanpath_aggressive_str("./b/c")                 ,     "b/c");
+  assert_eq!(cleanpath_aggressive_str("a/./c")                 ,     "a/c");
+  assert_eq!(cleanpath_aggressive_str("a/b/.")                 ,     "a/b");
+  assert_eq!(cleanpath_aggressive_str("a/../.")                ,       ".");
+  assert_eq!(cleanpath_aggressive_str("/../.././../a")         ,      "/a");
+  assert_eq!(cleanpath_aggressive_str("a/b/../../../../c/../d"), "../../d");
+}
+
+#[test]
+fn it_cleans_like_ruby_on_unix() {
+  assert_eq!(cleanpath_aggressive_str("///"),        "/");
+  assert_eq!(cleanpath_aggressive_str("///a"),       "/a");
+  assert_eq!(cleanpath_aggressive_str("///.."),      "/");
+  assert_eq!(cleanpath_aggressive_str("///."),       "/");
+  assert_eq!(cleanpath_aggressive_str("///a/../.."), "/");
 }
 
-// Future Windows Support
-//
-// DOSISH = File::ALT_SEPARATOR != nil
-// DOSISH_DRIVE_LETTER = File.dirname("A:") == "A:."
-// DOSISH_UNC = File.dirname("//") == "//"
-//
-// if DOSISH_UNC
-//   defassert(:cleanpath_aggressive, '//a/b/c', '//a/b/c/')
-// else
-//   defassert(:cleanpath_aggressive, '/',       '///')
-//   defassert(:cleanpath_aggressive, '/a',      '///a')
-//   defassert(:cleanpath_aggressive, '/',       '///..')
-//   defassert(:cleanpath_aggressive, '/',       '///.')
-//   defassert(:cleanpath_aggressive, '/',       '///a/../..')
-// end
-//
-// if DOSISH
-//   defassert(:cleanpath_aggressive, 'c:/foo/bar', 'c:\\foo\\bar')
-// end
+#[test]
+fn it_cleans_like_ruby_on_windows() {
+  assert_eq!(windows_cleanpath_aggressive("//a/b/c/"),     "//a/b/c");
+  assert_eq!(windows_cleanpath_aggressive("c:\\foo\\bar"), "c:/foo/bar");
+  assert_eq!(windows_cleanpath_aggressive("c:\\foo\\..\\..\\bar"), "c:/bar");
+  assert_eq!(windows_cleanpath_aggressive("a\\.\\b"), "a/b");
+  assert_eq!(windows_cleanpath_aggressive("C:"), "C:.");
+  assert_eq!(windows_cleanpath_aggressive("C:a/../b"), "C:b");
+}