faster_path 0.3.10 → 0.4.0

data/src/helpers.rs

@@ -1,51 +0,0 @@
-use ruru::{RString, Object, Class, AnyObject};
-extern crate ruby_sys;
-use debug::RubyDebugInfo;
-use ruru;
-
-type MaybeString = Result<ruru::RString, ruru::result::Error>;
-
-pub trait TryFrom<T>: Sized {
-  type Error;
-
-  fn try_from(value: T) -> Result<Self, Self::Error>;
-}
-
-#[cfg(windows)]
-#[inline]
-pub fn is_same_path(a: &str, b: &str) -> bool {
-  a.to_uppercase() == b.to_uppercase()
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub fn is_same_path(a: &str, b: &str) -> bool {
-  a == b
-}
-
-pub fn anyobject_to_string(item: AnyObject) -> Result<String, RubyDebugInfo> {
-  let result = &item;
-  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(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/memrnchr.rs

@@ -1,70 +0,0 @@
-// 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/pathname_sys.rs

@@ -1,41 +0,0 @@
-use ruru::{AnyObject, Array, Object, AnyException};
-use ruru::types::{Argc, Value, CallbackPtr};
-use ruru::util::str_to_cstring;
-extern crate ruby_sys;
-use self::ruby_sys::{class, util, vm};
-use ::pathname;
-extern crate memchr;
-
-pub fn raise(exception: AnyException) {
-  unsafe { vm::rb_exc_raise(exception.value()); }
-}
-
-pub type ValueCallback<I, O> = extern "C" fn(Argc, *const Value, I) -> O;
-
-pub fn define_singleton_method<I: Object, O: Object>(
-  klass: Value,
-  name: &str,
-  callback: ValueCallback<I, O>,
-) {
-  let name = str_to_cstring(name);
-
-  unsafe {
-    class::rb_define_singleton_method(klass, name.as_ptr(), callback as CallbackPtr, -1);
-  }
-}
-
-// ruru doesn't support splat arguments yet
-pub extern fn pub_join(argc: Argc, argv: *const Value, _: AnyObject) -> AnyObject {
-  let args = Value::from(0);
-
-  unsafe {
-    util::rb_scan_args(
-      argc,
-      argv,
-      str_to_cstring("*").as_ptr(),
-      &args
-    )
-  };
-  
-  pathname::pn_join(Ok(Array::from(args)))
-}