faster_path 0.3.9 → 0.4.0

data/src/plus.rs

@@ -1,104 +1,118 @@
-extern crate array_tool;
-use std::path::Path;
-use std::str;
-use chop_basename::chop_basename;
-use basename::basename;
-use dirname::dirname;
-use self::array_tool::vec::Shift;
-use std::ops::Index;
+use std::borrow::Cow;
 
-pub fn plus_paths(path1: &str, path2: &str) -> String {
-  let mut prefix2 = path2.to_string();
-  let mut index_list2: Vec<usize> = vec![];
-  let mut basename_list2: Vec<String> = vec![];
+use crate::basename::basename;
+use crate::chop_basename::chop_basename;
+use crate::dirname::dirname;
+use crate::path_parsing::Rules;
 
-  loop {
-    match chop_basename(&prefix2.clone()[..]) {
-      None => { break },
-      Some((pfx2, basename2)) => {
-        prefix2 = pfx2.to_string();
-        index_list2.unshift(pfx2.len());
-        basename_list2.unshift(basename2.to_owned());
-      },
-    }
+// Pathname's `plus`, which `Pathname#+` and `Pathname#join` use.
+pub fn plus_paths<'a>(rules: Rules, path1: &'a [u8], path2: &[u8]) -> Cow<'a, [u8]> {
+  // The names in path2, and where each starts
+  let mut prefix2 = path2;
+  let mut index_list2: Vec<usize> = vec![];
+  let mut basename_list2: Vec<&[u8]> = vec![];
+  while let Some((prefix, basename)) = chop_basename(rules, prefix2) {
+    prefix2 = prefix;
+    index_list2.push(prefix.len());
+    basename_list2.push(basename);
   }
   if !prefix2.is_empty() {
-    return path2.to_string()
-  };
-
-  let mut prefix1 = path1.to_string();
+    return Cow::Owned(path2.to_vec());
+  }
+  index_list2.reverse();
+  basename_list2.reverse();
+  // The names before `first` have been shifted off
+  let mut first = 0;
 
+  let mut prefix1 = path1;
   loop {
-    while !basename_list2.is_empty() && basename_list2.first().unwrap() == "." {
-      index_list2.shift();
-      basename_list2.shift();
+    while basename_list2.get(first) == Some(&&b"."[..]) {
+      first += 1;
+    }
+    let (prefix, basename1) = match chop_basename(rules, prefix1) {
+      Some(chopped) => chopped,
+      None => break,
+    };
+    prefix1 = prefix;
+    if basename1 == b"." {
+      continue;
     }
-    match chop_basename(&prefix1.clone()[..]) {
-      None => { break },
-      Some((pfx1, basename1)) => {
-        prefix1 = pfx1.to_string();
-        if basename1 == "." { continue };
-        if basename1 == ".." || basename_list2.is_empty() || basename_list2.first().unwrap() != ".." {
-          prefix1.push_str(&basename1);
-          break
-          }
-        }
+    if basename1 == b".." || basename_list2.get(first) != Some(&&b".."[..]) {
+      // `prefix1 + basename1`; the basename follows its prefix
+      prefix1 = &path1[..prefix1.len() + basename1.len()];
+      break;
     }
-    index_list2.shift();
-    basename_list2.shift();
+    first += 1;
   }
 
-  let result: String;
-
-  let mut r1 = if let Some((_,_)) = chop_basename(&prefix1[..]) {true} else {false};
-
-  if !r1 {
-    r1 = basename(&prefix1[..], "").contains("/");
-    if r1 {
-      while !basename_list2.is_empty() && basename_list2.first().unwrap() == ".." {
-        index_list2.shift();
-        basename_list2.shift();
-      }
+  let mut prefix1_has_name = chop_basename(rules, prefix1).is_some();
+  if !prefix1_has_name && rules.contains_sep(basename(rules, prefix1, b"")) {
+    // Nothing goes above the root
+    prefix1_has_name = true;
+    while basename_list2.get(first) == Some(&&b".."[..]) {
+      first += 1;
     }
   }
-  if !basename_list2.is_empty() {
-    let suffix2 = path2.index(index_list2.first().unwrap().to_owned()..);
-    if r1 {
-      result = Path::new(&prefix1).join(Path::new(&suffix2)).to_str().unwrap().to_string();
+  if first < basename_list2.len() {
+    let suffix2 = &path2[index_list2[first]..];
+    if prefix1_has_name {
+      Cow::Owned(rules.join(prefix1, suffix2))
     } else {
-      prefix1.push_str(&suffix2);
-      result = prefix1.to_string();
+      Cow::Owned([prefix1, suffix2].concat())
     }
+  } else if prefix1_has_name {
+    Cow::Borrowed(prefix1)
   } else {
-    if r1 {
-      result = prefix1.to_string();
-    } else {
-      result = dirname(&prefix1[..]).to_string();
-    }
+    dirname(rules, prefix1)
   }
+}
+
+#[cfg(test)]
+fn plus_str(path1: &str, path2: &str) -> String {
+  String::from_utf8(plus_paths(Rules::UNIX, path1.as_bytes(), path2.as_bytes()).into_owned()).unwrap()
+}
 
-  String::from(result)
+#[cfg(test)]
+fn windows_plus(path1: &str, path2: &str) -> String {
+  String::from_utf8(plus_paths(Rules::WINDOWS, path1.as_bytes(), path2.as_bytes()).into_owned()).unwrap()
 }
 
 #[test]
 fn it_will_plus_same_as_ruby() {
-  assert_eq!("/"      ,       plus_paths("/"  , "/"));
-  assert_eq!("a/b"    ,       plus_paths("a"  , "b"));
-  assert_eq!("a"      ,       plus_paths("a"  , "."));
-  assert_eq!("b"      ,       plus_paths("."  , "b"));
-  assert_eq!("."      ,       plus_paths("."  , "."));
-  assert_eq!("/b"     ,       plus_paths("a"  , "/b"));
+  assert_eq!("/"      ,       plus_str("/"  , "/"));
+  assert_eq!("a/b"    ,       plus_str("a"  , "b"));
+  assert_eq!("a"      ,       plus_str("a"  , "."));
+  assert_eq!("b"      ,       plus_str("."  , "b"));
+  assert_eq!("."      ,       plus_str("."  , "."));
+  assert_eq!("/b"     ,       plus_str("a"  , "/b"));
+
+  assert_eq!("/"      ,       plus_str("/"  , ".."));
+  assert_eq!("////"   ,       plus_str("////", ""));
+  assert_eq!("."      ,       plus_str("a"  , ".."));
+  assert_eq!("a"      ,       plus_str("a/b", ".."));
+  assert_eq!("../.."  ,       plus_str(".." , ".."));
+  assert_eq!("/c"     ,       plus_str("/"  , "../c"));
+  assert_eq!("c"      ,       plus_str("a"  , "../c"));
+  assert_eq!("a/c"    ,       plus_str("a/b", "../c"));
+  assert_eq!("../../c",       plus_str(".." , "../c"));
 
-  assert_eq!("/"      ,       plus_paths("/"  , ".."));
-  assert_eq!("."      ,       plus_paths("a"  , ".."));
-  assert_eq!("a"      ,       plus_paths("a/b", ".."));
-  assert_eq!("../.."  ,       plus_paths(".." , ".."));
-  assert_eq!("/c"     ,       plus_paths("/"  , "../c"));
-  assert_eq!("c"      ,       plus_paths("a"  , "../c"));
-  assert_eq!("a/c"    ,       plus_paths("a/b", "../c"));
-  assert_eq!("../../c",       plus_paths(".." , "../c"));
+  assert_eq!("a//b/d//e",     plus_str("a//b/c", "../d//e"));
 
-  assert_eq!("a//b/d//e",     plus_paths("a//b/c", "../d//e"));
+  assert_eq!("//foo/var/bar", plus_str("//foo/var", "bar"));
+}
 
-  assert_eq!("//foo/var/bar", plus_paths("//foo/var", "bar"));
+#[test]
+fn it_will_plus_same_as_ruby_on_windows() {
+  assert_eq!("a/b",        windows_plus("a", "b"));
+  assert_eq!("a/b",        windows_plus("a\\", "b"));
+  assert_eq!("/b",         windows_plus("a", "/b"));
+  assert_eq!("\\b",        windows_plus("a", "\\b"));
+  assert_eq!("C:/b",       windows_plus("a", "C:/b"));
+  assert_eq!("C:/a/b",     windows_plus("C:/a", "b"));
+  assert_eq!("C:/b",       windows_plus("C:/a", "../b"));
+  assert_eq!("C:/b",       windows_plus("C:/", "../b"));
+  assert_eq!("C:\\a/b",    windows_plus("C:\\a", "b"));
+  assert_eq!("a",          windows_plus("a\\b", ".."));
+  assert_eq!("//a/b/c",    windows_plus("//a/b", "c"));
+  assert_eq!("//a/b/c",    windows_plus("//a/b", "../c"));
 }

data/src/prepend_prefix.rs

@@ -1,19 +1,17 @@
 use std::borrow::Cow;
-use dirname::dirname;
-use path_parsing::{SEP, contains_sep};
-use std::path::MAIN_SEPARATOR;
 
-pub fn prepend_prefix<'a>(prefix: &'a str, relpath: &str) -> Cow<'a, str> {
+use crate::cleanpath_conservative::add_trailing_separator;
+use crate::dirname::dirname;
+use crate::path_parsing::Rules;
+
+// Pathname's `prepend_prefix`
+pub fn prepend_prefix<'a>(rules: Rules, prefix: &'a [u8], relpath: &[u8]) -> Cow<'a, [u8]> {
   if relpath.is_empty() {
-    dirname(prefix).into()
-  } else if contains_sep(prefix.as_bytes()) {
-    let prefix_dirname = dirname(prefix);
-    match prefix_dirname.as_bytes().last() {
-      None => relpath.to_string().into(),
-      Some(&SEP) => format!("{}{}", prefix_dirname, relpath).into(),
-      _ => format!("{}{}{}", prefix_dirname, MAIN_SEPARATOR, relpath).into()
-    }
+    dirname(rules, prefix)
+  } else if rules.contains_sep(prefix) {
+    let prefix = add_trailing_separator(rules, dirname(rules, prefix));
+    Cow::Owned([&prefix[..], relpath].concat())
   } else {
-    format!("{}{}", prefix, relpath).into()
+    Cow::Owned([prefix, relpath].concat())
   }
 }

data/src/relative_path_from.rs

@@ -1,70 +1,94 @@
-use std::iter;
-use helpers::{is_same_path, to_str};
-use path_parsing::SEP_STR;
-use cleanpath_aggressive::cleanpath_aggressive;
-use chop_basename::chop_basename;
-use pathname::Pathname;
-use ruru;
-use ruru::{Exception as Exc, AnyException as Exception};
+use crate::chop_basename::chop_basename;
+use crate::cleanpath_aggressive::cleanpath_aggressive;
+use crate::path_parsing::{Rules, SEP_BYTES};
 
-type MaybeString = Result<ruru::RString, ruru::result::Error>;
+#[derive(Debug, PartialEq)]
+pub enum RelativePathError {
+  // Holds the destination prefix and the cleaned base directory.
+  DifferentPrefix(Vec<u8>, Vec<u8>),
+  // Holds the cleaned base directory.
+  BaseDirectoryHasDotDot(Vec<u8>),
+}
 
-pub fn relative_path_from(itself: MaybeString, base_directory: MaybeString) -> Result<Pathname, Exception> {
-  let dest_directory = cleanpath_aggressive(to_str(&itself));
-  let base_directory = cleanpath_aggressive(to_str(&base_directory));
+// Pathname's `relative_path_from`
+pub fn relative_path_from(rules: Rules, dest: &[u8], base: &[u8]) -> Result<Vec<u8>, RelativePathError> {
+  let dest_directory = cleanpath_aggressive(rules, dest);
+  let base_directory = cleanpath_aggressive(rules, base);
 
-  let (dest_prefix, mut dest_names) = to_names(dest_directory.as_ref());
-  let (base_prefix, mut base_names) = to_names(base_directory.as_ref());
+  let (dest_prefix, mut dest_names) = to_names(rules, &dest_directory);
+  let (base_prefix, mut base_names) = to_names(rules, &base_directory);
 
-  if !is_same_path(&dest_prefix, &base_prefix) {
-    return Err(
-      Exception::new(
-        "ArgumentError",
-        Some(&format!("different prefix: {} and {}", dest_prefix, base_prefix)),
-      )
-    );
+  if !rules.same_path(dest_prefix, base_prefix) {
+    return Err(RelativePathError::DifferentPrefix(dest_prefix.to_vec(), base_directory.to_vec()));
   }
 
-  // Remove shared tail
+  // Remove the shared leading names (stored last, as the names are collected in reverse)
   {
     let num_same = dest_names.iter().rev().zip(base_names.iter().rev()).
-        take_while(|&(dest, base)| dest == base).count();
-    let num_dest_names = dest_names.len();
-    dest_names.truncate(num_dest_names - num_same);
-    let num_base_names = base_names.len();
-    base_names.truncate(num_base_names - num_same);
+        take_while(|&(dest, base)| rules.same_path(dest, base)).count();
+    dest_names.truncate(dest_names.len() - num_same);
+    base_names.truncate(base_names.len() - num_same);
   };
 
-  if base_names.contains(&"..") {
-    return Err(
-      Exception::new(
-        "ArgumentError",
-        Some(&format!("base_directory has ..: {}", base_directory)),
-      )
-    );
+  if base_names.contains(&&b".."[..]) {
+    return Err(RelativePathError::BaseDirectoryHasDotDot(base_directory.to_vec()));
   }
 
   if base_names.is_empty() && dest_names.is_empty() {
-    Ok(Pathname::new("."))
+    Ok(b".".to_vec())
   } else {
-    Ok(Pathname::new(&iter::repeat("..").take(base_names.len()).chain(dest_names.into_iter().rev()).
-        collect::<Vec<&str>>().join(&SEP_STR)))
+    let names: Vec<&[u8]> = std::iter::repeat(&b".."[..]).take(base_names.len()).
+      chain(dest_names.into_iter().rev()).collect();
+    Ok(names.join(SEP_BYTES))
   }
 }
 
 #[inline(always)]
-fn to_names(path: &str) -> (&str, Vec<&str>) {
-  let mut result: Vec<&str> = vec![];
+fn to_names(rules: Rules, path: &[u8]) -> (&[u8], Vec<&[u8]>) {
+  let mut result: Vec<&[u8]> = vec![];
   let mut prefix = path;
-  loop {
-    match chop_basename(&prefix) {
-      Some((ref dest, ref basename)) => {
-        prefix = dest;
-        if basename != &"." {
-          result.push(basename);
-        }
-      }
-      None => return (prefix, result),
+  while let Some((dest, basename)) = chop_basename(rules, prefix) {
+    prefix = dest;
+    if basename != b"." {
+      result.push(basename);
     }
   }
+  (prefix, result)
+}
+
+#[cfg(test)]
+fn relative_str(rules: Rules, dest: &str, base: &str) -> Option<String> {
+  relative_path_from(rules, dest.as_bytes(), base.as_bytes()).ok().map(|path| String::from_utf8(path).unwrap())
+}
+
+#[test]
+fn it_finds_relative_paths() {
+  let u = Rules::UNIX;
+  assert_eq!(relative_str(u, "a", "b").unwrap(), "../a");
+  assert_eq!(relative_str(u, "/a/b/c/d", "/a/b").unwrap(), "c/d");
+  assert_eq!(relative_str(u, "/a/b", "/a/b/c/d").unwrap(), "../..");
+  assert_eq!(relative_str(u, ".", ".").unwrap(), ".");
+  assert_eq!(relative_str(u, "a/b/c", "a/d").unwrap(), "../b/c");
+}
+
+#[test]
+fn it_rejects_incompatible_paths() {
+  assert_eq!(
+    relative_path_from(Rules::UNIX, b"/", b"."),
+    Err(RelativePathError::DifferentPrefix(b"/".to_vec(), b".".to_vec()))
+  );
+  assert_eq!(
+    relative_path_from(Rules::UNIX, b"a", b".."),
+    Err(RelativePathError::BaseDirectoryHasDotDot(b"..".to_vec()))
+  );
+}
+
+#[test]
+fn it_finds_relative_paths_on_windows() {
+  let w = Rules::WINDOWS;
+  assert_eq!(relative_str(w, "C:\\a\\b", "c:/a").unwrap(), "b");
+  assert_eq!(relative_str(w, "C:/A/b", "c:/a/c").unwrap(), "../b");
+  assert_eq!(relative_str(w, "//a/b/c/d", "//a/b/c").unwrap(), "d");
+  assert_eq!(relative_str(w, "C:/a", "D:/a"), None);
+  assert_eq!(relative_str(Rules::UNIX, "a/B", "a/b").unwrap(), "../B");
 }