faster_path 0.3.7 → 0.3.8

data/src/dirname.rs

@@ -1,26 +1,66 @@
-extern crate memchr;
-use self::memchr::memrchr;
-use path_parsing::{SEP, SEP_STR, last_non_sep_i, last_non_sep_i_before};
+use std::str;
+use path_parsing::{find_last_sep_pos, find_last_non_sep_pos};
 
 pub fn dirname(path: &str) -> &str {
-  if path.is_empty() { return "."; }
-  let non_sep_i = last_non_sep_i(path);
-  if non_sep_i == -1 { return *SEP_STR; }
-  return match memrchr(SEP, &path.as_bytes()[..non_sep_i as usize]) {
-    None => ".",
-    Some(0) => *SEP_STR,
-    Some(sep_i) => {
-      let non_sep_i2 = last_non_sep_i_before(path, sep_i as isize);
-      if non_sep_i2 != -1 {
-        &path[..(non_sep_i2 + 1) as usize]
-      } else {
-        *SEP_STR
-      }
-    }
+  let bytes = path.as_bytes();
+  let mut last_slash_pos = match find_last_sep_pos(bytes) {
+    Some(pos) => pos,
+    _ => return ".",
+  };
+  // Skip trailing slashes.
+  if last_slash_pos == bytes.len() - 1 {
+    let last_non_slash_pos = match find_last_non_sep_pos(&bytes[..last_slash_pos]) {
+      Some(pos) => pos,
+      _ => return "/"
+    };
+    last_slash_pos = match find_last_sep_pos(&bytes[..last_non_slash_pos]) {
+      Some(pos) => pos,
+      _ => return "."
+    };
+  };
+  if let Some(end) = find_last_non_sep_pos(&bytes[..last_slash_pos]) {
+    &path[..end + 1]
+  } else {
+    "/"
   }
 }
 
 #[test]
-fn returns_dot_for_empty_string(){
-  assert_eq!(dirname(""), ".".to_string());
+fn absolute() {
+  assert_eq!(dirname("/a/b///c"), "/a/b");
+}
+
+#[test]
+fn trailing_slashes_absolute() {
+  assert_eq!(dirname("/a/b///c//////"), "/a/b");
+}
+
+#[test]
+fn relative() {
+  assert_eq!(dirname("b///c"), "b");
+}
+
+#[test]
+fn trailing_slashes_relative() {
+  assert_eq!(dirname("b/c//"), "b");
+}
+
+#[test]
+fn root() {
+  assert_eq!(dirname("//c"), "/");
+}
+
+#[test]
+fn trailing_slashes_root() {
+  assert_eq!(dirname("//c//"), "/");
+}
+
+#[test]
+fn trailing_slashes_relative_root() {
+  assert_eq!(dirname("c//"), ".");
+}
+
+#[test]
+fn returns_dot_for_empty_string() {
+  assert_eq!(dirname(""), ".");
 }

data/src/extname.rs

@@ -1,63 +1,25 @@
-use path_parsing::SEP;
 use std::str;
+use path_parsing::{SEP, find_last_non_sep_pos};
 
-struct ExtnameCoords {
-  word: bool,
-  pred: bool,
-  dot: bool,
-  start: usize,
-  end: usize,
-}
-
-impl ExtnameCoords {
-  pub fn dec(&mut self) {
-    self.start -= 1;
-    if !self.word {
-      self.end -= 1;
-    }
-  }
-}
-
-pub fn extname(pth: &str) -> &str {
-  let path = pth.as_bytes();
-  let mut extname = ExtnameCoords {
-    word: false,
-    pred: false,
-    dot: false,
-    start: path.len(),
-    end: path.len(),
+pub fn extname(path: &str) -> &str {
+  let end = match find_last_non_sep_pos(path.as_bytes()) {
+    Some(pos) => pos + 1,
+    _ => return "",
   };
-
-  for &item in path.iter().rev() {
-    if (item == b'.' && !extname.dot) || item == SEP {
-      if item == SEP && extname.word {
-        return ""
-      }
-
-      if !extname.pred {
-        extname.dec();
-      }
-
-      if extname.word {
-        extname.dot = true;
-      }
-    } else {
-      if extname.dot {
-        extname.pred = true;
-        break;
-      } else {
-        extname.word = true;
-      }
-
-      if !extname.pred {
-        extname.dec()
+  let bytes = &path.as_bytes()[..end];
+  for (pos, c) in bytes.iter().enumerate().rev() {
+    match *c {
+      b'.' => {
+        let prev = bytes.get(pos - 1);
+        if pos == end - 1 || prev == None || prev == Some(&SEP) {
+          return "";
+        } else {
+          return &path[pos..end]
+        };
       }
+      SEP => return "",
+      _ => {}
     }
-  }
-
-  if !extname.pred {
-    return "";
-  }
-
-  str::from_utf8(&path[extname.start..extname.end]).unwrap_or("")
+  };
+  ""
 }

data/src/helpers.rs

@@ -1,7 +1,9 @@
 use ruru::{RString, Object, Class, AnyObject};
 extern crate ruby_sys;
 use debug::RubyDebugInfo;
-use pathname::Pathname;
+use ruru;
+
+type MaybeString = Result<ruru::RString, ruru::result::Error>;
 
 pub trait TryFrom<T>: Sized {
   type Error;
@@ -23,21 +25,24 @@ pub fn anyobject_to_string(item: AnyObject) -> Result<String, RubyDebugInfo> {
   if Class::from_existing("String").case_equals(result) {
     return Ok(RString::from(result.value()).to_string())
   }
-  
+
   if Class::from_existing("Pathname").case_equals(result) {
     return Ok(result.instance_variable_get("@path").
       try_convert_to::<RString>().
       unwrap_or(RString::new("")).
       to_string())
   }
-  
+
   if result.respond_to("to_path") {
-    return Ok(Pathname::from(result.send("to_path", None).value()).
-      instance_variable_get("@path").
-      try_convert_to::<RString>().
-      unwrap_or(RString::new("")).
-      to_string())
+    return Ok(RString::from(result.send("to_path", None).value()).to_string())
   }
 
   Ok(RString::from(result.send("to_s", None).value()).to_string())
 }
+
+pub fn to_str(maybe_string: &MaybeString) -> &str {
+  match maybe_string {
+    &Ok(ref ruru_string) => ruru_string.to_str(),
+    &Err(_) => "",
+  }
+}

data/src/lib.rs

@@ -25,13 +25,14 @@ 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, Array, AnyObject};
+use ruru::{Module, Object, RString, Boolean, AnyObject};
 
 use pathname_sys::*;
 
@@ -54,14 +55,16 @@ methods!(
   }
 
   fn pub_children(pth: RString, with_dir: Boolean) -> AnyObject {
-    pathname::pn_children(pth, with_dir)
+    pathname::pn_children(pth, with_dir).
+      map_err(|e| raise(e) ).unwrap()
   }
 
   fn pub_children_compat(pth: RString, with_dir: Boolean) -> AnyObject {
-    pathname::pn_children_compat(pth, with_dir)
+    pathname::pn_children_compat(pth, with_dir).
+      map_err(|e| raise(e) ).unwrap()
   }
 
-  fn pub_chop_basename(pth: RString) -> Array {
+  fn pub_chop_basename(pth: RString) -> AnyObject {
     pathname::pn_chop_basename(pth)
   }
 
@@ -99,12 +102,14 @@ methods!(
 
   // pub_entries returns an array of String objects
   fn pub_entries(pth: RString) -> AnyObject {
-    pathname::pn_entries(pth)
+    pathname::pn_entries(pth).
+      map_err(|e| raise(e) ).unwrap()
   }
 
   // pub_entries_compat returns an array of Pathname objects
   fn pub_entries_compat(pth: RString) -> AnyObject {
-    pathname::pn_entries_compat(pth)
+    pathname::pn_entries_compat(pth).
+      map_err(|e| raise(e) ).unwrap()
   }
 
   fn pub_extname(pth: RString) -> RString {
@@ -163,10 +168,13 @@ pub extern "C" fn Init_faster_pathname() {
     itself.def_self("absolute?", pub_is_absolute);
     itself.def_self("add_trailing_separator", pub_add_trailing_separator);
     itself.def_self("del_trailing_separator", pub_del_trailing_separator);
+    itself.def_self("chop_basename", pub_chop_basename);
     itself.def_self("cleanpath_aggressive", pub_cleanpath_aggressive);
     itself.def_self("cleanpath_conservative", pub_cleanpath_conservative);
     itself.def_self("directory?", pub_is_directory);
     itself.def_self("dirname", pub_dirname);
+    itself.def_self("entries", pub_entries);
+    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);
@@ -182,8 +190,5 @@ pub extern "C" fn Init_faster_pathname() {
     itself.def_self("basename", pub_basename);
     itself.def_self("children", pub_children);
     itself.def_self("children_compat", pub_children_compat);
-    itself.def_self("chop_basename", pub_chop_basename);
-    itself.def_self("entries", pub_entries);
-    itself.def_self("entries_compat", pub_entries_compat);
   });
 }

data/src/memrnchr.rs

@@ -0,0 +1,70 @@
+// The code below is based on the fallback `memrchr` implementation from the respective crate.
+//
+// We use this mainly to skip repeated `/`. If there is only one slash, `memrnchr` performs the same
+// as a naive version (e.g. `rposition`). However, it is much faster in pathological cases.
+
+use std::mem::size_of;
+
+// Returns the byte offset of the last byte that is NOT equal to the given one.
+#[inline(always)]
+pub fn memrnchr(x: u8, text: &[u8]) -> Option<usize> {
+  // Scan for a single byte value by reading two `usize` words at a time.
+  //
+  // Split `text` in three parts
+  // - unaligned tail, after the last word aligned address in text
+  // - body, scan by 2 words at a time
+  // - the first remaining bytes, < 2 word size
+  let len = text.len();
+  let ptr = text.as_ptr();
+
+  // search to an aligned boundary
+  let end_align = (ptr as usize + len) & (size_of::<usize>() - 1);
+  let mut offset;
+  if end_align > 0 {
+    offset = if end_align >= len { 0 } else { len - end_align };
+    if let Some(index) = memrnchr_naive(x, &text[offset..]) {
+      return Some(offset + index);
+    }
+  } else {
+    offset = len;
+  }
+
+  // search the body of the text
+  let repeated_x = repeat_byte(x);
+  while offset >= 2 * size_of::<usize>() {
+    debug_assert_eq!((ptr as usize + offset) % size_of::<usize>(), 0);
+    unsafe {
+      let u = *(ptr.offset(offset as isize - 2 * size_of::<usize>() as isize) as *const usize);
+      let v = *(ptr.offset(offset as isize - size_of::<usize>() as isize) as *const usize);
+      if u & repeated_x != usize::max_value() || v & repeated_x != usize::max_value() {
+        break;
+      }
+    }
+    offset -= 2 * size_of::<usize>();
+  }
+
+  // find the byte before the point the body loop stopped
+  memrnchr_naive(x, &text[..offset])
+}
+
+#[inline(always)]
+fn memrnchr_naive(x: u8, text: &[u8]) -> Option<usize> {
+  text.iter().rposition(|c| *c != x)
+}
+
+#[cfg(target_pointer_width = "32")]
+#[inline]
+fn repeat_byte(b: u8) -> usize {
+  let mut rep = (b as usize) << 8 | b as usize;
+  rep = rep << 16 | rep;
+  rep
+}
+
+#[cfg(target_pointer_width = "64")]
+#[inline]
+fn repeat_byte(b: u8) -> usize {
+  let mut rep = (b as usize) << 8 | b as usize;
+  rep = rep << 16 | rep;
+  rep = rep << 32 | rep;
+  rep
+}

data/src/path_parsing.rs

@@ -1,4 +1,7 @@
 extern crate memchr;
+
+use self::memchr::{memchr, memrchr};
+use memrnchr::memrnchr;
 use std::path::MAIN_SEPARATOR;
 use std::str;
 
@@ -7,20 +10,26 @@ lazy_static! {
   pub static ref SEP_STR: &'static str = str::from_utf8(&[SEP]).unwrap();
 }
 
-// Returns the byte offset of the last byte preceding a MAIN_SEPARATOR.
-pub fn last_non_sep_i(path: &str) -> isize {
-  last_non_sep_i_before(path, path.len() as isize - 1)
+// Returns the byte offset of the last byte that equals MAIN_SEPARATOR.
+#[inline(always)]
+pub fn find_last_dot_pos(bytes: &[u8]) -> Option<usize> {
+  memrchr(b'.', bytes)
+}
+
+// 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)
+}
+
+// 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)
 }
 
-// Returns the byte offset of the last byte preceding a MAIN_SEPARATOR before the given end offset.
-pub fn last_non_sep_i_before(path: &str, end: isize) -> isize {
-  // Works with bytes directly because MAIN_SEPARATOR is always in the ASCII 7-bit range so we can
-  // avoid the overhead of full UTF-8 processing.
-  let ptr = path.as_ptr();
-  let mut i = end;
-  while i >= 0 {
-    if unsafe { *ptr.offset(i) } != SEP { break; };
-    i -= 1;
-  }
-  i
+// Whether the given byte sequence contains a MAIN_SEPARATOR.
+#[inline(always)]
+pub fn contains_sep(bytes: &[u8]) -> bool {
+  memchr(SEP, bytes) != None
 }

data/src/pathname.rs

@@ -8,8 +8,9 @@ use extname;
 use plus;
 use relative_path_from;
 use debug;
-use helpers::TryFrom;
+use helpers::{TryFrom, to_str};
 use pathname_sys::null_byte_check;
+use path_parsing::{SEP, find_last_non_sep_pos};
 
 use ruru;
 use ruru::{
@@ -40,7 +41,7 @@ impl Pathname {
   pub fn new(path: &str) -> Pathname {
     let mut instance = Class::from_existing("Pathname").allocate();
     instance.instance_variable_set("@path", RString::new(path).to_any_object());
-    
+
     Pathname { value: instance.value() }
   }
 
@@ -58,14 +59,14 @@ impl Pathname {
       )
     };
 
-    if null_byte_check(path.value()) { 
+    if null_byte_check(path.value()) {
       return Err( Exception::new("ArgumentError", Some("pathname contains null byte")) )
     }
 
     // if it crashes then dup the path string here before assigning to @path
     let mut instance = Class::from_existing("Pathname").allocate();
     instance.instance_variable_set("@path", RString::from(pth).to_any_object());
-    
+
     Ok(Pathname { value: instance.value() })
   }
 
@@ -84,11 +85,11 @@ impl TryFrom<AnyObject> for Pathname {
   type Error = debug::RubyDebugInfo;
   fn try_from(obj: AnyObject) -> Result<Pathname, Self::Error> {
     if Class::from_existing("String").case_equals(&obj) {
-      Ok(Pathname::new(&RString::from(obj.value()).to_string()))
+      Ok(Pathname::new(&RString::from(obj.value()).to_str()))
     } else if Class::from_existing("Pathname").case_equals(&obj) {
       Ok(Pathname::from(obj.value()))
     } else if obj.respond_to("to_path") {
-      Ok(Pathname::from(obj.send("to_path", None).value()))
+      Ok(Pathname::new(&RString::from(obj.send("to_path", None).value()).to_str()))
     } else {
       Err(Self::Error::from(obj))
     }
@@ -114,7 +115,7 @@ impl VerifiedObject for Pathname {
 }
 
 pub fn pn_add_trailing_separator(pth: MaybeString) -> RString {
-  let p = pth.ok().unwrap();
+  let p = pth.unwrap();
   let x = format!("{}{}", p.to_str(), "a");
   match x.rsplit_terminator(MAIN_SEPARATOR).next() {
     Some("a") => p,
@@ -123,34 +124,26 @@ pub fn pn_add_trailing_separator(pth: MaybeString) -> RString {
 }
 
 pub fn pn_is_absolute(pth: MaybeString) -> Boolean {
-  Boolean::new(match pth.ok().unwrap_or(RString::new("")).to_str().chars().next() {
-    Some(c) => c == MAIN_SEPARATOR,
-    None => false
-  })
+  Boolean::new(to_str(&pth).as_bytes().get(0) == Some(&SEP))
 }
 
 // pub fn pn_ascend(){}
 
 pub fn pn_basename(pth: MaybeString, ext: MaybeString) -> RString {
-  RString::new(
-    basename::basename(
-      pth.ok().unwrap_or(RString::new("")).to_str(),
-      ext.ok().unwrap_or(RString::new("")).to_str()
-    )
-  )
+  RString::new(basename::basename(to_str(&pth), to_str(&ext)))
 }
 
-pub fn pn_children(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject {
-  let val = pth.ok().unwrap_or(RString::new("."));
-  let val = val.to_str();
+pub fn pn_children(pth: MaybeString, with_dir: MaybeBoolean) -> Result<AnyObject, Exception> {
+  let path = pth.unwrap_or(RString::new("."));
+  let path = path.to_str();
 
-  if let Ok(entries) = fs::read_dir(val) {
-    let mut with_directory = with_dir.ok().unwrap_or(Boolean::new(true)).to_bool();
-    if val == "." {
+  if let Ok(entries) = fs::read_dir(path) {
+    let mut with_directory = with_dir.unwrap_or(Boolean::new(true)).to_bool();
+    if path == "." {
       with_directory = false;
     }
 
-    let mut arr = Array::new();
+    let mut arr = Array::with_capacity(entries.size_hint().1.unwrap_or(0));
     for entry in entries {
       if with_directory {
         match entry {
@@ -165,25 +158,23 @@ pub fn pn_children(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject {
       }
     }
 
-    arr.to_any_object()
+    Ok(arr.to_any_object())
   } else {
-    // TODO: When ruru exceptions are available switch the exception logic
-    // from the Ruby side to the Rust side
-    NilClass::new().to_any_object()
+    let msg = format!("No such file or directory @ dir_initialize - {}", path);
+    Err(Exception::new("Errno::NOENT", Some(&msg)))
   }
 }
 
-pub fn pn_children_compat(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject {
-  let val = pth.ok().unwrap_or(RString::new("."));
-  let val = val.to_str();
+pub fn pn_children_compat(pth: MaybeString, with_dir: MaybeBoolean) -> Result<AnyObject, Exception> {
+  let path = to_str(&pth);
 
-  if let Ok(entries) = fs::read_dir(val) {
-    let mut with_directory = with_dir.ok().unwrap_or(Boolean::new(true)).to_bool();
-    if val == "." {
+  if let Ok(entries) = fs::read_dir(path) {
+    let mut with_directory = with_dir.unwrap_or(Boolean::new(true)).to_bool();
+    if path == "." {
       with_directory = false;
     }
 
-    let mut arr = Array::new();
+    let mut arr = Array::with_capacity(entries.size_hint().1.unwrap_or(0));
     for entry in entries {
       if with_directory {
         if let Ok(v) = entry {
@@ -196,82 +187,60 @@ pub fn pn_children_compat(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject
       }
     }
 
-    arr.to_any_object()
+    Ok(arr.to_any_object())
   } else {
-    // TODO: When ruru exceptions are available switch the exception logic
-    // from the Ruby side to the Rust side
-    NilClass::new().to_any_object()
+    let msg = format!("No such file or directory @ dir_initialize - {}", path);
+    Err(Exception::new("Errno::NOENT", Some(&msg)))
   }
 }
 
-pub fn pn_chop_basename(pth: MaybeString) -> Array {
-  let mut arr = Array::with_capacity(2);
-  let pth = pth.ok().unwrap_or(RString::new(""));
-  let results = chop_basename::chop_basename(pth.to_str());
-  match results {
+pub fn pn_chop_basename(pth: MaybeString) -> AnyObject {
+  match chop_basename::chop_basename(to_str(&pth)) {
     Some((dirname, basename)) => {
-      arr.push(RString::new(&dirname[..]));
-      arr.push(RString::new(&basename[..]));
-      arr
+      let mut arr = Array::with_capacity(2);
+      arr.push(RString::new(&dirname));
+      arr.push(RString::new(&basename));
+      arr.to_any_object()
     },
-    None => arr
+    None => NilClass::new().to_any_object()
   }
 }
 
 // pub fn pn_cleanpath(pth: MaybeString){}
 
 pub fn pn_cleanpath_aggressive(pth: MaybeString) -> RString {
-  let path = cleanpath_aggressive::cleanpath_aggressive(
-    pth.ok().unwrap_or(RString::new("")).to_str()
-  );
-
-  RString::new(&path)
+  RString::new(&cleanpath_aggressive::cleanpath_aggressive(to_str(&pth)))
 }
 
 pub fn pn_cleanpath_conservative(pth: MaybeString) -> RString {
-  let path = cleanpath_conservative::cleanpath_conservative(
-    pth.ok().unwrap_or(RString::new("")).to_str()
-  );
-
-  RString::new(&path)
+  RString::new(&cleanpath_conservative::cleanpath_conservative(to_str(&pth)))
 }
 
 pub fn pn_del_trailing_separator(pth: MaybeString) -> RString {
-  if let &Ok(ref path) = &pth {
-    let path = path.to_str();
-
-    if !path.is_empty() {
-      let path = path.trim_right_matches('/');
-
-      if path.is_empty() {
-        return RString::new("/");
-      } else {
-        return RString::new(path);
-      }
+  {
+    let path = to_str(&pth);
+    if path.is_empty() {
+      return RString::new("/");
+    }
+    let pos = match find_last_non_sep_pos(path.as_bytes()) {
+      Some(pos) => pos,
+      None => return RString::new("/"),
+    };
+    if pos != path.len() - 1 {
+      return RString::new(&path[..pos + 1]);
     }
-  } else {
-    return RString::new("");
   }
-
   pth.unwrap()
 }
 
 // pub fn pn_descend(){}
 
 pub fn pn_is_directory(pth: MaybeString) -> Boolean {
-  Boolean::new(
-    Path::new(
-      pth.ok().unwrap_or(RString::new("")).to_str()
-    ).is_dir()
-  )
+  Boolean::new(Path::new(to_str(&pth)).is_dir())
 }
 
 pub fn pn_dirname(pth: MaybeString) -> RString {
-  RString::new(
-    dirname::dirname(
-      pth.ok().unwrap_or(RString::new("")).to_str()
-    )
-  )
+  RString::new(dirname::dirname(to_str(&pth)))
 }
 
 // pub fn pn_each_child(){}
@@ -280,60 +249,54 @@ pub fn pn_dirname(pth: MaybeString) -> RString {
 //   NilClass::new()
 // }
 
-pub fn pn_entries(pth: MaybeString) -> AnyObject {
-  if let Ok(files) = fs::read_dir(pth.ok().unwrap_or(RString::new("")).to_str()) {
-    let mut arr = Array::new();
+pub fn pn_entries(pth: MaybeString) -> Result<AnyObject, Exception> {
+  let path = to_str(&pth);
+  if let Ok(files) = fs::read_dir(path) {
+    let mut arr = Array::with_capacity(files.size_hint().1.unwrap_or(0) + 2);
 
     arr.push(RString::new("."));
     arr.push(RString::new(".."));
 
     for file in files {
-      let file_name_str = file.unwrap().file_name().into_string().unwrap();
-      arr.push(RString::new(&file_name_str[..]));
+      arr.push(RString::new(file.unwrap().file_name().to_str().unwrap()));
     }
 
-    arr.to_any_object()
+    Ok(arr.to_any_object())
   } else {
-    // TODO: When ruru exceptions are available switch the exception logic
-    // from the Ruby side to the Rust side
-    NilClass::new().to_any_object()
+    let msg = format!("No such file or directory @ dir_initialize - {}", path);
+    Err(Exception::new("Errno::NOENT", Some(&msg)))
   }
 }
 
-pub fn pn_entries_compat(pth: MaybeString) -> AnyObject {
-  if let Ok(files) = fs::read_dir(pth.ok().unwrap_or(RString::new("")).to_str()) {
-    let mut arr = Array::new();
+pub fn pn_entries_compat(pth: MaybeString) -> Result<AnyObject, Exception> {
+  let path = to_str(&pth);
+  if let Ok(files) = fs::read_dir(path) {
+    let mut arr = Array::with_capacity(files.size_hint().1.unwrap_or(0) + 2);
 
     arr.push(Pathname::new("."));
     arr.push(Pathname::new(".."));
 
     for file in files {
-      let file_name_str = file.unwrap().file_name().into_string().unwrap();
-      arr.push(Pathname::new(&file_name_str));
+      arr.push(Pathname::new(file.unwrap().file_name().to_str().unwrap()));
     }
 
-    arr.to_any_object()
+    Ok(arr.to_any_object())
   } else {
-    // TODO: When ruru exceptions are available switch the exception logic
-    // from the Ruby side to the Rust side
-    NilClass::new().to_any_object()
+    let msg = format!("No such file or directory @ dir_initialize - {}", path);
+    Err(Exception::new("Errno::NOENT", Some(&msg)))
   }
 }
 
 pub fn pn_extname(pth: MaybeString) -> RString {
-  RString::new(
-    extname::extname(pth.ok().unwrap_or(RString::new("")).to_str())
-  )
+  RString::new(extname::extname(to_str(&pth)))
 }
 
 // pub fn pn_find(pth: MaybeString, ignore_error: Boolean){}
 
 pub fn pn_has_trailing_separator(pth: MaybeString) -> Boolean {
-  let v = pth.ok().unwrap_or(RString::new(""));
-  match chop_basename::chop_basename(v.to_str()) {
-    Some((a,b)) => {
-      Boolean::new(a.len() + b.len() < v.to_str().len())
-    },
+  let v = to_str(&pth);
+  match chop_basename::chop_basename(v) {
+    Some((a,b)) => Boolean::new(a.len() + b.len() < v.len()),
     _ => Boolean::new(false)
   }
 }
@@ -353,13 +316,13 @@ pub fn pn_join(args: MaybeArray) -> AnyObject {
 
     let item = args.pop();
     result = plus::plus_paths(&anyobject_to_string(item).unwrap(), &result);
-    if result.chars().next() == Some(MAIN_SEPARATOR) {
+    if result.as_bytes().get(0) == Some(&SEP) {
       return Pathname::new(&result).to_any_object()
     }
 
     qty -= 1;
   }
-  
+
   let result = plus::plus_paths(&path_self, &result);
 
   Pathname::new(&result).to_any_object()
@@ -374,23 +337,17 @@ pub fn pn_join(args: MaybeArray) -> AnyObject {
 // pub fn pn_parent(pth: MaybeString){}
 
 pub fn pn_plus(pth1: MaybeString, pth2: MaybeString) -> RString {
-  RString::new(
-    &plus::plus_paths(
-      pth1.ok().unwrap_or(RString::new("")).to_str(),
-      pth2.ok().unwrap_or(RString::new("")).to_str()
-    )[..]
-  )
+  RString::new(&plus::plus_paths(to_str(&pth1), to_str(&pth2)))
 }
 
 // pub fn pn_prepend_prefix(prefix: MaybeString, relpath: MaybeString){}
 
 pub fn pn_is_relative(pth: MaybeString) -> Boolean {
-  Boolean::new(
-    match pth.ok().unwrap_or(RString::new(&MAIN_SEPARATOR.to_string()[..])).to_str().chars().next() {
-      Some(c) => c != MAIN_SEPARATOR,
-      None => true
-    }
-  )
+  let path = match &pth {
+    &Ok(ref ruru_string) => ruru_string.to_str(),
+    &Err(_) => return Boolean::new(false),
+  };
+  Boolean::new(path.as_bytes().get(0) != Some(&SEP))
 }
 
 // pub fn pn_root(pth: MaybeString){}