faster_path 0.3.10 → 0.4.0

data/src/lib.rs

@@ -4,16 +4,10 @@
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
-#[macro_use]
-extern crate ruru;
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 #[macro_use]
-extern crate lazy_static;
-
-module!(FasterPath);
-
-mod debug;
-mod helpers;
+mod ruby;
 mod pathname;
 mod basename;
 mod chop_basename;
@@ -21,149 +15,106 @@ mod cleanpath_aggressive;
 mod cleanpath_conservative;
 mod dirname;
 mod extname;
-mod pathname_sys;
 mod plus;
 mod prepend_prefix;
 pub mod rust_arch_bits;
-mod memrnchr;
 mod path_parsing;
 mod relative_path_from;
 
-use pathname::Pathname;
-use pathname_sys::raise;
-
-use ruru::{Module, Object, RString, Boolean, AnyObject};
-
-use pathname_sys::*;
-
-methods!(
-  FasterPath,
-  _itself,
+use rutie::{Class, Module, Object, RString};
 
-  fn pub_add_trailing_separator(pth: RString) -> RString {
-    pathname::pn_add_trailing_separator(pth)
+ruby_methods! {
+  fn pub_add_trailing_separator(arguments) {
+    pathname::pn_add_trailing_separator(arguments)
   }
 
-  fn pub_is_absolute(pth: RString) -> Boolean {
-    pathname::pn_is_absolute(pth)
+  fn pub_is_absolute(arguments) {
+    pathname::pn_is_absolute(arguments)
   }
 
-  // fn r_ascend(){}
-
-  fn pub_basename(pth: RString, ext: RString) -> RString {
-    pathname::pn_basename(pth, ext)
+  fn pub_basename(arguments) {
+    pathname::pn_basename(arguments)
   }
 
-  fn pub_children(pth: RString, with_dir: Boolean) -> AnyObject {
-    pathname::pn_children(pth, with_dir).
-      map_err(|e| raise(e) ).unwrap()
+  fn pub_children(arguments) {
+    pathname::pn_children(arguments)
   }
 
-  fn pub_children_compat(pth: RString, with_dir: Boolean) -> AnyObject {
-    pathname::pn_children_compat(pth, with_dir).
-      map_err(|e| raise(e) ).unwrap()
+  fn pub_children_compat(arguments) {
+    pathname::pn_children_compat(arguments)
   }
 
-  fn pub_chop_basename(pth: RString) -> AnyObject {
-    pathname::pn_chop_basename(pth)
+  fn pub_chop_basename(arguments) {
+    pathname::pn_chop_basename(arguments)
   }
 
-  // fn r_cleanpath(){ pub_cleanpath(r_to_path()) }
-  // fn pub_cleanpath(pth: RString){}
-
-  fn pub_cleanpath_aggressive(pth: RString) -> RString {
-    pathname::pn_cleanpath_aggressive(pth)
+  fn pub_cleanpath_aggressive(arguments) {
+    pathname::pn_cleanpath_aggressive(arguments)
   }
 
-  fn pub_cleanpath_conservative(pth: RString) -> RString {
-    pathname::pn_cleanpath_conservative(pth)
+  fn pub_cleanpath_conservative(arguments) {
+    pathname::pn_cleanpath_conservative(arguments)
   }
 
-  fn pub_del_trailing_separator(pth: RString) -> RString {
-    pathname::pn_del_trailing_separator(pth)
+  fn pub_del_trailing_separator(arguments) {
+    pathname::pn_del_trailing_separator(arguments)
   }
 
-  // fn r_descend(){}
-
-  fn pub_is_directory(pth: RString) -> Boolean {
-    pathname::pn_is_directory(pth)
+  fn pub_is_directory(arguments) {
+    pathname::pn_is_directory(arguments)
   }
 
-  fn pub_dirname(pth: RString) -> RString {
-    pathname::pn_dirname(pth)
+  fn pub_dirname(arguments) {
+    pathname::pn_dirname(arguments)
   }
 
-  // fn r_each_child(){}
-  // fn pub_each_child(){}
-
-  // fn pub_each_filename(pth: RString) -> NilClass {
-  //   pathname::pn_each_filename(pth)
-  // }
-
   // pub_entries returns an array of String objects
-  fn pub_entries(pth: RString) -> AnyObject {
-    pathname::pn_entries(pth).
-      map_err(|e| raise(e) ).unwrap()
+  fn pub_entries(arguments) {
+    pathname::pn_entries(arguments)
   }
 
   // pub_entries_compat returns an array of Pathname objects
-  fn pub_entries_compat(pth: RString) -> AnyObject {
-    pathname::pn_entries_compat(pth).
-      map_err(|e| raise(e) ).unwrap()
+  fn pub_entries_compat(arguments) {
+    pathname::pn_entries_compat(arguments)
   }
 
-  fn pub_extname(pth: RString) -> RString {
-    pathname::pn_extname(pth)
+  fn pub_extname(arguments) {
+    pathname::pn_extname(arguments)
   }
 
-  // fn r_find(ignore_error: Boolean){}
-  // fn pub_find(pth: RString ,ignore_error: Boolean){}
-
-  fn pub_has_trailing_separator(pth: RString) -> Boolean {
-    pathname::pn_has_trailing_separator(pth)
+  fn pub_has_trailing_separator(arguments) {
+    pathname::pn_has_trailing_separator(arguments)
   }
 
-  // fn pub_mkpath(pth: RString) -> NilClass {
-  //   pathname::pn_mkpath(pth)
-  // }
-
-  // fn r_is_mountpoint(){ pub_is_mountpount(r_to_path()) }
-  // fn pub_is_mountpoint(pth: RString){}
-
-  // fn r_parent(){ pub_parent(r_to_path()) }
-  // fn pub_parent(pth: RString){}
-
-  // also need impl +
-  fn pub_plus(pth1: RString, pth2: RString) -> RString {
-    pathname::pn_plus(pth1, pth2)
+  fn pub_join(arguments) {
+    pathname::pn_join(arguments)
   }
 
-  // fn r_prepend_prefix(prefix: RString, relpath: RString){}
-
-  fn pub_is_relative(pth: RString) -> Boolean {
-    pathname::pn_is_relative(pth)
+  fn pub_plus(arguments) {
+    pathname::pn_plus(arguments)
   }
 
-  // fn r_root(){ pub_root(r_to_path()) }
-  // fn pub_root(pth: RString){}
-
-  // fn r_split_names(pth: RString){}
-
-  fn pub_relative_path_from(itself: RString, base_directory: AnyObject) -> Pathname {
-    let to_string = |i: AnyObject| { RString::from(i.send("to_s", None).value()) };
-
-    pathname::pn_relative_path_from(itself, base_directory.map(to_string)).
-      map_err(|e| raise(e) ).unwrap()
+  fn pub_is_relative(arguments) {
+    pathname::pn_is_relative(arguments)
   }
 
-  // fn pub_rmtree(pth: RString) -> NilClass {
-  //   pathname::pn_rmtree(pth)
-  // }
-);
+  fn pub_relative_path_from(arguments) {
+    pathname::pn_relative_path_from(arguments)
+  }
+}
 
 #[allow(non_snake_case)]
 #[no_mangle]
 pub extern "C" fn Init_faster_pathname() {
+  // An extension of only a dot: "" before Ruby 2.7, "." since. ("a." would
+  // tell on Unix, but Windows doesn't count trailing dots.)
+  let trailing_dot_extname = Class::file().
+    protect_send("extname", &[RString::new_utf8("a./").into()]).
+    ok().
+    and_then(|extname| extname.try_convert_to::<RString>().ok()).
+    map_or(false, |extname| extname.to_bytes_unchecked() == b".");
+  extname::set_trailing_dot_is_extname(trailing_dot_extname);
+
   Module::from_existing("FasterPath").define(|itself| {
     itself.def_self("absolute?", pub_is_absolute);
     itself.def_self("add_trailing_separator", pub_add_trailing_separator);
@@ -177,8 +128,7 @@ pub extern "C" fn Init_faster_pathname() {
     itself.def_self("entries_compat", pub_entries_compat);
     itself.def_self("extname", pub_extname);
     itself.def_self("has_trailing_separator?", pub_has_trailing_separator);
-    //itself.def_self("join", pub_join);
-    pathname_sys::define_singleton_method(itself.value(), "join", pub_join);
+    itself.def_self("join", pub_join);
     itself.def_self("plus", pub_plus);
     itself.def_self("relative?", pub_is_relative);
     itself.def_self("relative_path_from", pub_relative_path_from);

data/src/path_parsing.rs

@@ -1,29 +1,290 @@
-extern crate memchr;
+// The building blocks of Ruby's path handling (`file.c`), for both of the
+// sets of rules Ruby is built with:
+//
+// * Unix: `/` is the only separator.
+// * Windows ("DOSISH"): `/` and `\` are separators, a path can start with a
+//   drive letter (`C:`) or a UNC prefix (`//server/share`), NTFS ignores
+//   trailing dots and spaces and `:stream` names at the end of a file name,
+//   and file names compare case-insensitively.
+//
+// Both are always compiled so each can be tested on any platform;
+// `Rules::NATIVE` is the one Ruby uses where this is built.
+use memchr::{memchr, memchr2, memrchr, memrchr2};
 
-use self::memchr::{memchr, memrchr};
-use memrnchr::memrnchr;
-use std::path::MAIN_SEPARATOR;
-use std::str;
-
-pub const SEP: u8 = MAIN_SEPARATOR as u8;
-lazy_static! {
-  pub static ref SEP_STR: &'static str = str::from_utf8(&[SEP]).unwrap();
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Rules {
+  dosish: bool,
 }
 
-// Returns the byte offset of the last byte that equals MAIN_SEPARATOR.
-#[inline(always)]
-pub fn find_last_sep_pos(bytes: &[u8]) -> Option<usize> {
-  memrchr(SEP, bytes)
+// `File::SEPARATOR`, which joins paths on every platform.
+pub const SEP_BYTES: &[u8] = b"/";
+
+impl Rules {
+  #[cfg_attr(not(test), allow(dead_code))]
+  pub const UNIX: Rules = Rules { dosish: false };
+  #[cfg_attr(not(test), allow(dead_code))]
+  pub const WINDOWS: Rules = Rules { dosish: true };
+  pub const NATIVE: Rules = Rules { dosish: cfg!(windows) };
+
+  #[inline(always)]
+  pub fn is_dosish(self) -> bool {
+    self.dosish
+  }
+
+  // Ruby's `isdirsep`
+  #[inline(always)]
+  pub fn is_sep(self, c: u8) -> bool {
+    c == b'/' || (self.dosish && c == b'\\')
+  }
+
+  // Byte offset of the last separator.
+  #[inline]
+  pub fn last_sep_pos(self, bytes: &[u8]) -> Option<usize> {
+    if self.dosish { memrchr2(b'/', b'\\', bytes) } else { memrchr(b'/', bytes) }
+  }
+
+  // Byte offset of the last byte that isn't a separator.
+  #[inline]
+  pub fn last_non_sep_pos(self, bytes: &[u8]) -> Option<usize> {
+    bytes.iter().rposition(|&c| !self.is_sep(c))
+  }
+
+  #[inline]
+  pub fn contains_sep(self, bytes: &[u8]) -> bool {
+    if self.dosish { memchr2(b'/', b'\\', bytes).is_some() } else { memchr(b'/', bytes).is_some() }
+  }
+
+  // `has_drive_letter`: "C:"
+  #[inline]
+  pub fn has_drive_letter(self, path: &[u8]) -> bool {
+    self.dosish && path.len() >= 2 && path[0].is_ascii_alphabetic() && path[1] == b':'
+  }
+
+  // `istrailinggarbage`: ignored at the end of NTFS file names.
+  #[inline(always)]
+  fn is_trailing_garbage(self, c: u8) -> bool {
+    self.dosish && (c == b'.' || c == b' ')
+  }
+
+  // `isADS`: starts an NTFS alternate data stream name.
+  #[inline(always)]
+  pub fn is_ads(self, c: u8) -> bool {
+    self.dosish && c == b':'
+  }
+
+  // `Pathname::SAME_PATHS`, and the comparison `File.basename` uses for
+  // extensions (`CASEFOLD_FILESYSTEM`).
+  #[inline]
+  pub fn same_path(self, a: &[u8], b: &[u8]) -> bool {
+    if self.dosish { a.eq_ignore_ascii_case(b) } else { a == b }
+  }
+
+  // `skipprefix`: the end of a UNC ("//server/share") or drive letter prefix.
+  pub fn skip_prefix(self, path: &[u8]) -> usize {
+    if !self.dosish {
+      return 0;
+    }
+    let end = path.len();
+    if end >= 2 && self.is_sep(path[0]) && self.is_sep(path[1]) {
+      let mut i = 2;
+      while i < end && self.is_sep(path[i]) {
+        i += 1;
+      }
+      i = self.next_sep(path, i);
+      if i + 1 < end && !self.is_sep(path[i + 1]) {
+        i = self.next_sep(path, i + 1);
+      }
+      return i;
+    }
+    if self.has_drive_letter(path) {
+      return 2;
+    }
+    0
+  }
+
+  // `skiproot`: past a drive letter and the separators after it.
+  pub fn skip_root(self, path: &[u8]) -> usize {
+    let mut i = if self.has_drive_letter(path) { 2 } else { 0 };
+    while i < path.len() && self.is_sep(path[i]) {
+      i += 1;
+    }
+    i
+  }
+
+  // `nextdirsep`: the next separator at or after `from`, or the end.
+  fn next_sep(self, path: &[u8], from: usize) -> usize {
+    let rest = &path[from.min(path.len())..];
+    let found = if self.dosish { memchr2(b'/', b'\\', rest) } else { memchr(b'/', rest) };
+    found.map_or(path.len(), |pos| from + pos)
+  }
+
+  // `strrdirsep`: where the last run of separators that isn't at the end
+  // of the path starts.
+  pub fn last_separator(self, path: &[u8]) -> Option<usize> {
+    let end = self.last_non_sep_pos(path)? + 1;
+    let pos = self.last_sep_pos(&path[..end])?;
+    Some(path[..pos].iter().rposition(|&c| !self.is_sep(c)).map_or(0, |p| p + 1))
+  }
+
+  // `chompdirsep`: where the separators at the end of the path start, or
+  // its end.
+  #[inline]
+  pub fn chomp_dir_sep(self, path: &[u8]) -> usize {
+    self.last_non_sep_pos(path).map_or(0, |pos| pos + 1)
+  }
+
+  // `ntfs_tail`: the end of an NTFS file name without trailing dots,
+  // spaces, separators or `:stream`.
+  pub fn ntfs_tail(self, path: &[u8]) -> usize {
+    let end = path.len();
+    let mut i = 0;
+    while i < end && path[i] == b'.' {
+      i += 1;
+    }
+    while i < end && !self.is_ads(path[i]) {
+      if self.is_trailing_garbage(path[i]) {
+        let last = i;
+        i += 1;
+        while i < end && self.is_trailing_garbage(path[i]) {
+          i += 1;
+        }
+        if i >= end || self.is_ads(path[i]) {
+          return last;
+        }
+      } else if self.is_sep(path[i]) {
+        let last = i;
+        i += 1;
+        while i < end && self.is_sep(path[i]) {
+          i += 1;
+        }
+        if i >= end {
+          return last;
+        }
+        if self.is_ads(path[i]) {
+          i += 1;
+        }
+      } else {
+        i += 1;
+      }
+    }
+    i
+  }
+
+  // Ruby's Windows `stat` doesn't find a path whose first "..." is a
+  // whole name of dots, as Windows would take "dir\\..." for "dir"
+  // (`check_valid_dir` in `win32.c`).
+  pub fn has_dots_name(self, path: &[u8]) -> bool {
+    if !self.dosish {
+      return false;
+    }
+    let start = match memchr::memmem::find(path, b"...") {
+      Some(start) => start,
+      None => return false,
+    };
+    let end = start + path[start..].iter().take_while(|&&c| c == b'.').count();
+    let delimits = |c: u8| c == b':' || self.is_sep(c);
+    (start == 0 || delimits(path[start - 1])) && (end == path.len() || delimits(path[end]))
+  }
+
+  // `File.join(a, b)`
+  pub fn join(self, a: &[u8], b: &[u8]) -> Vec<u8> {
+    let tail = self.chomp_dir_sep(a);
+    if b.first().map_or(false, |&c| self.is_sep(c)) {
+      [&a[..tail], b].concat()
+    } else if tail == a.len() {
+      [a, SEP_BYTES, b].concat()
+    } else {
+      [a, b].concat()
+    }
+  }
 }
 
-// Returns the byte offset of the last byte that is not MAIN_SEPARATOR.
-#[inline(always)]
-pub fn find_last_non_sep_pos(bytes: &[u8]) -> Option<usize> {
-  memrnchr(SEP, bytes)
+// Where `part`, a slice of `whole`, starts in it.
+#[inline]
+pub fn offset_in(whole: &[u8], part: &[u8]) -> usize {
+  part.as_ptr() as usize - whole.as_ptr() as usize
 }
 
-// Whether the given byte sequence contains a MAIN_SEPARATOR.
-#[inline(always)]
-pub fn contains_sep(bytes: &[u8]) -> bool {
-  memchr(SEP, bytes) != None
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  const U: Rules = Rules::UNIX;
+  const W: Rules = Rules::WINDOWS;
+
+  #[test]
+  fn it_finds_separators() {
+    assert_eq!(U.last_sep_pos(b""), None);
+    assert_eq!(U.last_sep_pos(b"a/b/c"), Some(3));
+    assert_eq!(U.last_sep_pos(b"a/b\\c"), Some(1));
+    assert_eq!(W.last_sep_pos(b"a/b\\c"), Some(3));
+    assert_eq!(U.last_non_sep_pos(b"///"), None);
+    assert_eq!(U.last_non_sep_pos(b"a///"), Some(0));
+    assert_eq!(W.last_non_sep_pos(b"a/\\/"), Some(0));
+    assert!(U.contains_sep(b"a/b"));
+    assert!(!U.contains_sep(b"a\\b"));
+    assert!(W.contains_sep(b"a\\b"));
+  }
+
+  #[test]
+  fn it_skips_prefixes() {
+    assert_eq!(U.skip_prefix(b"//a/b/c"), 0);
+    assert_eq!(W.skip_prefix(b"//a/b/c"), 5);
+    assert_eq!(W.skip_prefix(b"\\\\a\\b\\c"), 5);
+    assert_eq!(W.skip_prefix(b"//a/"), 3);
+    assert_eq!(W.skip_prefix(b"//a"), 3);
+    assert_eq!(W.skip_prefix(b"//"), 2);
+    assert_eq!(W.skip_prefix(b"C:/a"), 2);
+    assert_eq!(W.skip_prefix(b"/a"), 0);
+    assert_eq!(W.skip_root(b"C://a"), 4);
+    assert_eq!(U.skip_root(b"C://a"), 0);
+    assert_eq!(U.skip_root(b"//a"), 2);
+  }
+
+  #[test]
+  fn it_finds_the_last_separator() {
+    assert_eq!(U.last_separator(b"a//b//"), Some(1));
+    assert_eq!(U.last_separator(b"//b"), Some(0));
+    assert_eq!(U.last_separator(b"b//"), None);
+    assert_eq!(W.last_separator(b"a\\/b"), Some(1));
+    assert_eq!(U.chomp_dir_sep(b"a//"), 1);
+    assert_eq!(U.chomp_dir_sep(b"///"), 0);
+    assert_eq!(U.chomp_dir_sep(b"a"), 1);
+  }
+
+  #[test]
+  fn it_finds_ntfs_tails() {
+    assert_eq!(W.ntfs_tail(b"foo."), 3);
+    assert_eq!(W.ntfs_tail(b"foo. ."), 3);
+    assert_eq!(W.ntfs_tail(b"foo::$DATA"), 3);
+    assert_eq!(W.ntfs_tail(b"foo.bar"), 7);
+    assert_eq!(W.ntfs_tail(b"..."), 3);
+    assert_eq!(W.ntfs_tail(b"foo/"), 3);
+  }
+
+  #[test]
+  fn it_finds_names_of_dots() {
+    assert!(W.has_dots_name(b"dir/..."));
+    assert!(W.has_dots_name(b"..."));
+    assert!(W.has_dots_name(b"C:..../a"));
+    assert!(W.has_dots_name(b"a\\...\\b"));
+    assert!(!W.has_dots_name(b"dir/a..."));
+    assert!(!W.has_dots_name(b"dir/..a"));
+    assert!(!W.has_dots_name(b"dir/."));
+    assert!(!U.has_dots_name(b"dir/..."));
+  }
+
+  #[test]
+  fn it_joins_like_file_join() {
+    assert_eq!(U.join(b"a", b"b"), b"a/b");
+    assert_eq!(U.join(b"a/", b"b"), b"a/b");
+    assert_eq!(U.join(b"a//", b"b"), b"a//b");
+    assert_eq!(U.join(b"a/", b"/b"), b"a/b");
+    assert_eq!(U.join(b"a", b""), b"a/");
+    assert_eq!(U.join(b"/", b""), b"/");
+    assert_eq!(U.join(b"", b"b"), b"/b");
+    assert_eq!(W.join(b"a\\", b"b"), b"a\\b");
+    assert_eq!(W.join(b"a", b"\\b"), b"a\\b");
+    assert_eq!(U.join(b"a", b"\\b"), b"a/\\b");
+  }
 }