faster_path 0.1.13 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f1b4b37c294db2912d786c35de76f60cba0b6a9
-  data.tar.gz: 46af8f1bb6c06baed02866d6f9777bb9dfb6f1ff
+  metadata.gz: 4b227f5a94ba3ae27a33eab04fa65c80d95b9842
+  data.tar.gz: 6cf955a639547780ecd12279dd50c8f00343b772
 SHA512:
-  metadata.gz: c6d51a6c3a7796aa41063ee31a3c0f05c88df32350f5fbc2f0913553c9fdaf6ab5600475594d3e9dc3706df49785f5bfc0e0ed0de4b29d169e166abd1acf4f45
-  data.tar.gz: 96b16a98d9e807e33669956d6adb879f57d5e976def60c2d11502b9107a601bf793cfe75148f56e2e6c99b3b3af7745434e5c166d40c1b902b911efd797a0b65
+  metadata.gz: 2571373e3f523f8db360b7b68593d192b10b4e718ba8f12cdc47292479c9e6facb74498d799dca7121aa4e895a7d2088b8d921855bd6857a3c9f1c7512617fcb
+  data.tar.gz: 3e2c243a5921e93c3e0f47e028aa2e7b10cbdf5eb304830093e869a6abca1159b6b86dc627516c548e404b5ce738ecbc8fd2f5a5b5e48ef802d8e20a7c392d34

data/Cargo.lock

@@ -3,7 +3,7 @@ name = "faster_path"
 version = "0.0.1"
 dependencies = [
  "array_tool 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ruru 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -11,11 +11,36 @@ name = "array_tool"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "lazy_static"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "libc"
 version = "0.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "ruby-sys"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.30 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "ruru"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ruby-sys 0.2.20 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [metadata]
 "checksum array_tool 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1a07ccb27c611e5cda99e498e99ba71b3ecdb7db5df02096cef42a3df5b84542"
+"checksum lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3b37545ab726dd833ec6420aaba8231c5b320814b9029ad585555d2a03e94fbf"
 "checksum libc 0.2.30 (registry+https://github.com/rust-lang/crates.io-index)" = "2370ca07ec338939e356443dac2296f581453c35fe1e3a3ed06023c49435f915"
+"checksum ruby-sys 0.2.20 (registry+https://github.com/rust-lang/crates.io-index)" = "e71509f17ce93733dc196258e168b58050490a156b04563816a8120a74ba04c7"
+"checksum ruru 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6486d6c50b7a08246a492a61893635c1977d41c138041d443eb603f6298e0273"

data/Cargo.toml

@@ -13,5 +13,5 @@ name = "faster_path"
 crate-type = ["dylib"]
 
 [dependencies]
-libc = "0.2.30"
+ruru = "0.9.3"
 array_tool = "0.4.1"

data/Rakefile

@@ -24,8 +24,38 @@ task :sysinfo do
   end
 end
 
+desc "Add libruby to deps"
+task :libruby_release do
+  filename = RbConfig::CONFIG["LIBRUBY_ALIASES"].split(" ").first
+  libfile = File.join(RbConfig::CONFIG["libdir"], filename)
+  deps = "target/release/deps"
+
+  printf "Copying libruby.so ... "
+  unless File.exist? "#{deps}/#{filename}"
+    FileUtils.mkdir_p deps
+    FileUtils.cp libfile, deps
+  end
+  exit 1 unless File.exist? "#{deps}/#{filename}"
+  puts "libruby.so copied."
+end
+
+desc "Add libruby to debug deps"
+task :libruby_debug do
+  filename = RbConfig::CONFIG["LIBRUBY_ALIASES"].split(" ").first
+  libfile = File.join(RbConfig::CONFIG["libdir"], filename)
+  deps = "target/debug/deps"
+
+  printf "Copying libruby.so ... "
+  unless File.exist? "#{deps}/#{filename}"
+    FileUtils.mkdir_p deps
+    FileUtils.cp libfile, deps
+  end
+  exit 1 unless File.exist? "#{deps}/#{filename}"
+  puts "libruby.so copied."
+end
+
 desc "Build Rust extension"
-task :build_src do
+task build_src: :libruby_release do
   puts "Building extension..."
   sh "cargo build --release"
 end
@@ -58,7 +88,7 @@ task :lint do
 end
 
 desc "Run Rust Tests"
-task :cargo do
+task cargo: :libruby_debug do
   sh "cargo test -- --nocapture"
 end
 

data/lib/faster_path.rb

@@ -4,6 +4,26 @@ require "ffi"
 require 'faster_path/asset_resolution'
 
 module FasterPath
+  FFI_LIBRARY = begin
+    prefix = Gem.win_platform? ? "" : "lib"
+    "#{File.expand_path("../target/release/", __dir__)}/#{prefix}faster_path.#{FFI::Platform::LIBSUFFIX}"
+  end
+  require 'fiddle'
+  library = Fiddle.dlopen(FFI_LIBRARY)
+  Fiddle::Function.
+    new(library['Init_faster_pathname'], [], Fiddle::TYPE_VOIDP).
+    call
+
+  FasterPathname.class_eval do
+    private :add_trailing_separator
+    private :basename
+    private :chop_basename
+    private :dirname
+    private :entries
+    private :extname
+    private :plus
+  end
+
   def self.rust_arch_bits
     Rust.rust_arch_bits
   end
@@ -12,102 +32,60 @@ module FasterPath
     1.size * 8
   end
 
-  # Spec to Pathname#absolute?
   def self.absolute?(pth)
-    Rust.is_absolute(pth)
+    FasterPathname.allocate.send(:absolute?, pth)
   end
 
-  # Spec to Pathname#directory?
-  def self.directory?(pth)
-    Rust.is_directory(pth)
+  def self.add_trailing_separator(pth)
+    FasterPathname.allocate.send(:add_trailing_separator, pth)
   end
 
-  # Spec to Pathname#relative?
-  def self.relative?(pth)
-    Rust.is_relative(pth)
+  def self.blank?(str)
+    "#{str}".strip.empty?
   end
 
-  def self.dirname(pth)
-    Rust.dirname(pth)
+  def self.basename(pth, ext="")
+    FasterPathname.allocate.send(:basename, pth, ext)
   end
 
-  # Spec to Pathname#chop_basename
-  # WARNING! Pathname#chop_basename in STDLIB doesn't handle blank strings correctly!
-  # This implementation correctly handles blank strings just as Pathname had intended
-  # to handle non-path strings.
   def self.chop_basename(pth)
-    d = Rust.dirname_for_chop(pth)
-    b = Rust.basename_for_chop(pth)
-    [d, b] unless Rust.both_are_blank(d, b)
+    result = FasterPathname.allocate.send(:chop_basename, pth)
+    result unless result.empty?
   end
 
-  def self.blank?(str)
-    Rust.is_blank(str)
+  def self.directory?(pth)
+    FasterPathname.allocate.send(:directory?, pth)
   end
 
-  def self.basename(pth, ext="")
-    Rust.basename(pth, ext)
+  def self.dirname(pth)
+    FasterPathname.allocate.send(:dirname, pth)
   end
 
-  def self.plus(pth, pth2)
-    Rust.plus(pth, pth2)
+  def self.entries(pth)
+    FasterPathname.allocate.send(:entries, pth)
   end
 
-  def self.add_trailing_separator(pth)
-    Rust.add_trailing_separator(pth)
+  def self.extname(pth)
+    FasterPathname.allocate.send(:extname, pth)
   end
 
   def self.has_trailing_separator?(pth)
-    Rust.has_trailing_separator(pth)
+    FasterPathname.allocate.send(:has_trailing_separator?, pth)
   end
 
-  def self.extname(pth)
-    Rust.extname(pth)
+  def self.plus(pth, pth2)
+    FasterPathname.allocate.send(:plus, pth, pth2)
   end
 
-  def self.entries(pth)
-    Array(Rust.entries(pth))
+  def self.relative?(pth)
+    FasterPathname.allocate.send(:relative?, pth)
   end
 
-  # EXAMPLE
-  # def self.one_and_two
-  #  Rust.one_and_two.to_a
-  # end
-
   module Rust
     extend FFI::Library
-    ffi_lib begin
-      prefix = Gem.win_platform? ? "" : "lib"
-      "#{File.expand_path("../target/release/", __dir__)}/#{prefix}faster_path.#{FFI::Platform::LIBSUFFIX}"
-    end
-
-    class FromRustArray < FFI::Struct
-      layout :len,    :size_t, # dynamic array layout
-             :data,   :pointer #
-
-      def to_a
-        self[:data].get_array_of_string(0, self[:len]).compact
-      end
-    end
+    ffi_lib ::FasterPath::FFI_LIBRARY
 
     attach_function :rust_arch_bits, [], :int32
-    attach_function :is_absolute, [ :string ], :bool
-    attach_function :is_directory, [ :string ], :bool
-    attach_function :is_relative, [ :string ], :bool
-    attach_function :is_blank, [ :string ], :bool
-    attach_function :both_are_blank, [ :string, :string ], :bool
-    attach_function :basename, [ :string, :string ], :string
-    attach_function :plus, [ :string, :string ], :string
-    attach_function :dirname, [ :string ], :string
-    attach_function :basename_for_chop, [ :string ], :string # decoupling behavior
-    attach_function :dirname_for_chop, [ :string ], :string # decoupling behavior
-    attach_function :add_trailing_separator, [ :string ], :string
-    attach_function :has_trailing_separator, [ :string ], :bool
-    attach_function :extname, [ :string ], :string
-    attach_function :entries, [ :string ], FromRustArray.by_value
-
-    # EXAMPLE
-    # attach_function :one_and_two, [], FromRustArray.by_value
   end
   private_constant :Rust
 end

data/lib/faster_path/optional/monkeypatches.rb

@@ -3,11 +3,12 @@ require 'pathname'
 module FasterPath
   module MonkeyPatches
     # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def self._ruby_core_file!
       ::File.class_eval do
         def self.basename(pth, ext = '')
           pth = pth.to_path if pth.respond_to? :to_path
-          raise TypeError unless pth.is_a? String
+          raise TypeError unless pth.is_a?(String) && ext.is_a?(String)
           FasterPath.basename(pth, ext)
         end
 

data/lib/faster_path/optional/refinements.rb

@@ -5,7 +5,7 @@ module FasterPath
     refine File do
       def self.basename(pth, ext = '')
         pth = pth.to_path if pth.respond_to? :to_path
-        raise TypeError unless pth.is_a? String
+        raise TypeError unless pth.is_a?(String) && ext.is_a?(String)
         FasterPath.basename(pth, ext)
       end
 

data/lib/faster_path/version.rb

@@ -1,3 +1,3 @@
 module FasterPath
-  VERSION = "0.1.13"
+  VERSION = "0.2.0"
 end

data/src/basename.rs

@@ -1,41 +1,23 @@
-use libc::c_char;
-use std::ffi::{CStr, CString};
+extern crate array_tool;
+use path_parsing::extract_last_path_segment;
+use self::array_tool::string::Squeeze;
 
-#[no_mangle]
-pub extern "C" fn basename(c_pth: *const c_char, c_ext: *const c_char) -> *const c_char {
-  if c_pth.is_null() || c_ext.is_null() {
-    return c_pth;
+pub fn basename(pth: &str, ext: &str) -> String {
+  // Known edge case
+  match &pth.squeeze("/")[..] {
+    "/" => { return "/".to_string() }
+    _ => {}
   }
-  let pth = unsafe { CStr::from_ptr(c_pth) }.to_str().unwrap();
-  let ext = unsafe { CStr::from_ptr(c_ext) }.to_str().unwrap();
 
-  let name = rust::basename(pth, ext);
-  
-  CString::new(name).unwrap().into_raw()
-}
-
-pub mod rust {
-  extern crate array_tool;
-  use path_parsing::extract_last_path_segment;
-  use self::array_tool::string::Squeeze;
+  let mut name = extract_last_path_segment(pth);
 
-  pub fn basename(pth: &str, ext: &str) -> String {
-    // Known edge case
-    match &pth.squeeze("/")[..] {
-      "/" => { return "/".to_string() }
-      _ => {}
+  if ext == ".*" {
+    if let Some(dot_i) = name.rfind('.') {
+      name = &name[0..dot_i];
     }
-
-    let mut name = extract_last_path_segment(pth);
-
-    if ext == ".*" {
-      if let Some(dot_i) = name.rfind('.') {
-        name = &name[0..dot_i];
-      }
-    } else if name.ends_with(ext) {
-      name = &name[..name.len() - ext.len()];
-    };
-    name.to_string()
-  }
+  } else if name.ends_with(ext) {
+    name = &name[..name.len() - ext.len()];
+  };
+  name.to_string()
 }
 

data/src/chop_basename.rs

@@ -1,56 +1,54 @@
-pub mod rust {
-  use std::path::MAIN_SEPARATOR;
-  use std::str;
+use std::path::MAIN_SEPARATOR;
+use std::str;
 
-  pub fn chop_basename(input: &str) -> Option<(String,String)> {
-    if input.is_empty() {
-      return None;
-    }
+pub fn chop_basename(input: &str) -> Option<(String,String)> {
+  if input.is_empty() {
+    return None;
+  }
 
-    let mut offset = 0;
-    let mut trailing_slashes = input.chars().rev();
-    loop {
-      match trailing_slashes.next() {
-        Some(MAIN_SEPARATOR) => { offset = offset + 1 },
-        _                    => { break               },
-      }
+  let mut offset = 0;
+  let mut trailing_slashes = input.chars().rev();
+  loop {
+    match trailing_slashes.next() {
+      Some(MAIN_SEPARATOR) => { offset = offset + 1 },
+      _                    => { break               },
     }
+  }
 
-    let input = &input[0..input.len()-offset];
-    let base = input.rsplit_terminator(MAIN_SEPARATOR).nth(0).unwrap_or("");
-    let directory = &input[0..input.len()-base.len()];
-
-    if directory.is_empty() && (base.is_empty() || base == "/") {
-      return None
-    };
+  let input = &input[0..input.len()-offset];
+  let base = input.rsplit_terminator(MAIN_SEPARATOR).nth(0).unwrap_or("");
+  let directory = &input[0..input.len()-base.len()];
 
-    Some((directory.to_string(), base.to_string()))
-  }
+  if directory.is_empty() && (base.is_empty() || base.chars().next().unwrap() == MAIN_SEPARATOR) {
+    return None
+  };
 
-  #[test]
-  fn it_chops_the_basename_and_dirname() {
-    assert_eq!(chop_basename(&""[..]), None);
-    assert_eq!(chop_basename(&"/"[..]), None);
-    assert_eq!(
-      chop_basename(&"."[..]),
-      Some(("".to_string(), ".".to_string()))
-    );
-    assert_eq!(
-      chop_basename(&"asdf/asdf"[..]),
-      Some(("asdf/".to_string(), "asdf".to_string()))
-    );
-    assert_eq!(
-      chop_basename(&"asdf.txt"[..]),
-      Some(("".to_string(), "asdf.txt".to_string()))
-    );
-    assert_eq!(
-      chop_basename(&"asdf/"[..]),
-      Some(("".to_string(), "asdf".to_string()))
-    );
-    assert_eq!(
-      chop_basename(&"/asdf/"[..]),
-      Some(("/".to_string(), "asdf".to_string()))
-    );
-  }
+  Some((directory.to_string(), base.to_string()))
+}
 
+#[test]
+fn it_chops_the_basename_and_dirname() {
+  assert_eq!(chop_basename(&""[..]), None);
+  assert_eq!(chop_basename(&"/"[..]), None);
+  assert_eq!(
+    chop_basename(&"."[..]),
+    Some(("".to_string(), ".".to_string()))
+  );
+  assert_eq!(
+    chop_basename(&"asdf/asdf"[..]),
+    Some(("asdf/".to_string(), "asdf".to_string()))
+  );
+  assert_eq!(
+    chop_basename(&"asdf.txt"[..]),
+    Some(("".to_string(), "asdf.txt".to_string()))
+  );
+  assert_eq!(
+    chop_basename(&"asdf/"[..]),
+    Some(("".to_string(), "asdf".to_string()))
+  );
+  assert_eq!(
+    chop_basename(&"/asdf/"[..]),
+    Some(("/".to_string(), "asdf".to_string()))
+  );
 }
+

data/src/dirname.rs

@@ -1,46 +1,31 @@
-use libc::c_char;
-use std::ffi::{CStr, CString};
+use std::path::MAIN_SEPARATOR;
+use path_parsing::{last_sep_i, last_non_sep_i, last_non_sep_i_before};
 
-#[no_mangle]
-pub extern "C" fn dirname(path: *const c_char) -> *const c_char {
-  if path.is_null() {
-    return path
+pub fn dirname(path: &str) -> String {
+  let r_str = path;
+  if r_str.is_empty() {
+    return ".".to_string();
   }
-  let r_str = unsafe { CStr::from_ptr(path) }.to_str().unwrap();
-
-  CString::new(rust::dirname(r_str)).unwrap().into_raw()
-}
-
-pub mod rust {
-  use std::path::MAIN_SEPARATOR;
-  use path_parsing::{last_sep_i, last_non_sep_i, last_non_sep_i_before};
-
-  pub fn dirname(path: &str) -> String {
-    let r_str = path;
-    if r_str.is_empty() {
-      return ".".to_string();
-    }
-    let non_sep_i = last_non_sep_i(r_str);
-    if non_sep_i == -1 {
-      return MAIN_SEPARATOR.to_string();
-    }
-    let sep_i = last_sep_i(r_str, non_sep_i);
-    if sep_i == -1 {
-      return ".".to_string();
-    }
-    if sep_i == 0 {
-      return MAIN_SEPARATOR.to_string();
-    }
-    let non_sep_i2 = last_non_sep_i_before(r_str, sep_i);
-    if non_sep_i2 != -1 {
-      return r_str[..(non_sep_i2 + 1) as usize].to_string();
-    } else {
-      return MAIN_SEPARATOR.to_string();
-    }
+  let non_sep_i = last_non_sep_i(r_str);
+  if non_sep_i == -1 {
+    return MAIN_SEPARATOR.to_string();
+  }
+  let sep_i = last_sep_i(r_str, non_sep_i);
+  if sep_i == -1 {
+    return ".".to_string();
+  }
+  if sep_i == 0 {
+    return MAIN_SEPARATOR.to_string();
+  }
+  let non_sep_i2 = last_non_sep_i_before(r_str, sep_i);
+  if non_sep_i2 != -1 {
+    return r_str[..(non_sep_i2 + 1) as usize].to_string();
+  } else {
+    return MAIN_SEPARATOR.to_string();
   }
 }
 
 #[test]
 fn returns_dot_for_empty_string(){
-  assert_eq!(rust::dirname(""), ".".to_string());
+  assert_eq!(dirname(""), ".".to_string());
 }

data/src/extname.rs

@@ -1,20 +1,13 @@
-use libc::c_char;
-use std::ffi::{CStr, CString};
 use path_parsing::extract_last_path_segment;
 
-#[no_mangle]
-pub extern "C" fn extname(c_pth: *const c_char) -> *const c_char {
-  if c_pth.is_null() {
-    return c_pth
-  }
-
-  let name = extract_last_path_segment(unsafe { CStr::from_ptr(c_pth) }.to_str().unwrap());
+pub fn extname(pth: &str) -> String {
+  let name = extract_last_path_segment(pth);
 
   if let Some(dot_i) = name.rfind('.') {
     if dot_i > 0 && dot_i < name.len() - 1 && name[..dot_i].chars().rev().next().unwrap() != '.' {
-      return CString::new(&name[dot_i..]).unwrap().into_raw()
+      return String::from(&name[dot_i..])
     }
   }
 
-  CString::new("").unwrap().into_raw()
+  String::from("")
 }

data/src/lib.rs

@@ -4,34 +4,140 @@
 // 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.
-extern crate libc;
-
-pub mod ruby_string;
-pub mod ruby_array;
-pub mod is_absolute;
-pub mod is_directory;
-pub mod is_relative;
-pub mod is_blank;
-pub mod both_are_blank;
-pub mod basename;
-pub mod plus;
-pub mod dirname;
-pub mod chop_basename;
-pub mod basename_for_chop;
-pub mod dirname_for_chop;
-pub mod add_trailing_separator;
-pub mod has_trailing_separator;
-pub mod extname;
-pub mod entries;
+#[macro_use]
+extern crate ruru;
+
+class!(FasterPathname);
+
+mod basename;
+mod chop_basename;
+mod dirname;
+mod extname;
+mod plus;
 pub mod rust_arch_bits;
 mod path_parsing;
 
-// EXAMPLE
-//
-//#[no_mangle]
-//pub extern fn one_and_two() -> RubyArray {
-//  let mut words = vec![];
-//  words.push(RubyString::to_ruby(&"one".to_string()));
-//  words.push(RubyString::to_ruby(&"two".to_string()));
-//  RubyArray::from_vec(words)
-//}
+use ruru::{Class, Object, RString, Boolean, Array};
+use std::path::{MAIN_SEPARATOR,Path};
+use std::fs;
+
+methods!(
+  FasterPathname,
+  _itself,
+
+  fn r_add_trailing_separator(pth: RString) -> RString {
+    let p = pth.ok().unwrap();
+    let x = format!("{}{}", p.to_str(), "a");
+    match x.rsplit_terminator(MAIN_SEPARATOR).next() {
+      Some("a") => p,
+      _ => RString::new(format!("{}{}", p.to_str(), MAIN_SEPARATOR).as_str())
+    }
+  }
+
+  fn r_is_absolute(pth: RString) -> Boolean {
+    Boolean::new(match pth.ok().unwrap_or(RString::new("")).to_str().chars().next() {
+      Some(c) => c == MAIN_SEPARATOR,
+      None => false
+    })
+  }
+
+  fn r_basename(pth: RString, ext: RString) -> RString {
+    RString::new(
+      &basename::basename(
+        pth.ok().unwrap_or(RString::new("")).to_str(),
+        ext.ok().unwrap_or(RString::new("")).to_str()
+      )[..]
+    )
+  }
+
+  fn r_chop_basename(pth: RString) -> Array {
+    let mut arr = Array::with_capacity(2);
+    let results = chop_basename::chop_basename(pth.ok().unwrap_or(RString::new("")).to_str());
+    match results {
+      Some((dirname, basename)) => {
+        arr.push(RString::new(&dirname[..]));
+        arr.push(RString::new(&basename[..]));
+        arr
+      },
+      None => arr
+    }
+  }
+
+  fn r_is_directory(pth: RString) -> Boolean {
+    Boolean::new(
+      Path::new(
+        pth.ok().unwrap_or(RString::new("")).to_str()
+      ).is_dir()
+    )
+  }
+
+  fn r_dirname(pth: RString) -> RString {
+    RString::new(
+      &dirname::dirname(
+        pth.ok().unwrap_or(RString::new("")).to_str()
+      )[..]
+    )
+  }
+
+  fn r_entries(pth: RString) -> Array {
+    let files = fs::read_dir(pth.ok().unwrap_or(RString::new("")).to_str()).unwrap();
+    let mut arr = Array::new();
+
+    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
+  }
+
+  fn r_extname(pth: RString) -> RString {
+    RString::new(
+      &extname::extname(pth.ok().unwrap_or(RString::new("")).to_str())[..]
+    )
+  }
+
+  fn r_has_trailing_separator(pth: RString) -> 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())
+      },
+      _ => Boolean::new(false)
+    }
+  }
+
+  fn r_plus(pth1: RString, pth2: RString) -> RString {
+    RString::new(&plus::plus_paths(pth1.ok().unwrap().to_str(), pth2.ok().unwrap().to_str())[..])
+  }
+
+  fn r_is_relative(pth: RString) -> 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
+      }
+    )
+  }
+);
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Init_faster_pathname(){
+  Class::new("FasterPathname", None).define(|itself| {
+    itself.def("absolute?", r_is_absolute);
+    itself.def("add_trailing_separator", r_add_trailing_separator);
+    itself.def("basename", r_basename);
+    itself.def("chop_basename", r_chop_basename);
+    itself.def("directory?", r_is_directory);
+    itself.def("dirname", r_dirname);
+    itself.def("entries", r_entries);
+    itself.def("extname", r_extname);
+    itself.def("has_trailing_separator?", r_has_trailing_separator);
+    itself.def("plus", r_plus);
+    itself.def("relative?", r_is_relative);
+  });
+}

data/src/plus.rs

@@ -1,40 +1,13 @@
 extern crate array_tool;
 use std::path::Path;
-use libc::c_char;
-use std::ffi::{CStr,CString};
 use std::str;
-use chop_basename::rust::chop_basename;
-use basename::rust::basename;
-use dirname::rust::dirname;
+use chop_basename::chop_basename;
+use basename::basename;
+use dirname::dirname;
 use self::array_tool::vec::Shift;
 use std::ops::Index;
 
-#[no_mangle]
-pub extern fn plus(string: *const c_char, string2: *const c_char) -> *const c_char {
-  let c_str = unsafe {
-    if string.is_null() {
-      return string;
-    }
-    CStr::from_ptr(string)
-  };
-
-  let c_str2 = unsafe {
-    if string2.is_null() {
-      return string2;
-    }
-    CStr::from_ptr(string2)
-  };
-
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
-  let r_str2 = str::from_utf8(c_str2.to_bytes()).unwrap();
-
-  let result = plus_paths(r_str, r_str2);
-  
-  let output = CString::new(result).unwrap();
-  output.into_raw()
-}
-
-fn plus_paths(path1: &str, path2: &str) -> String {
+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![];

data/src/rust_arch_bits.rs

@@ -1,5 +1,5 @@
 #[no_mangle]
-pub extern fn rust_arch_bits() -> i32 {
+pub extern "C" fn rust_arch_bits() -> i32 {
   use std::mem::size_of;
   let s = size_of::<usize>() * 8;
   s as i32

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-08 00:00:00.000000000 Z
+date: 2017-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -173,25 +173,13 @@ files:
 - lib/faster_path/optional/monkeypatches.rb
 - lib/faster_path/optional/refinements.rb
 - lib/faster_path/version.rb
-- src/add_trailing_separator.rs
 - src/basename.rs
-- src/basename_for_chop.rs
-- src/both_are_blank.rs
 - src/chop_basename.rs
 - src/dirname.rs
-- src/dirname_for_chop.rs
-- src/entries.rs
 - src/extname.rs
-- src/has_trailing_separator.rs
-- src/is_absolute.rs
-- src/is_blank.rs
-- src/is_directory.rs
-- src/is_relative.rs
 - src/lib.rs
 - src/path_parsing.rs
 - src/plus.rs
-- src/ruby_array.rs
-- src/ruby_string.rs
 - src/rust_arch_bits.rs
 homepage: https://github.com/danielpclark/faster_path
 licenses:

data/src/add_trailing_separator.rs

@@ -1,29 +0,0 @@
-use std::path::{Path, MAIN_SEPARATOR};
-use libc::c_char;
-use std::ffi::{CStr, CString};
-use std::str;
-
-#[no_mangle]
-pub extern fn add_trailing_separator(string: *const c_char) -> *const c_char {
-  let c_str = unsafe {
-    if string.is_null() {
-      return string;
-    }
-    CStr::from_ptr(string)
-  };
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
-
-  if r_str.is_empty() {
-    return string;
-  }
-
-  let path = Path::new(r_str);
-  let out_str = if !(path.to_str().unwrap().chars().last().unwrap() == '/') {
-    format!("{}{}", path.to_str().unwrap(), MAIN_SEPARATOR)
-  } else {
-    path.to_str().unwrap().to_string()
-  };
-
-  let output = CString::new(out_str).unwrap();
-  output.into_raw()
-}

data/src/basename_for_chop.rs

@@ -1,31 +0,0 @@
-use std::path::MAIN_SEPARATOR;
-use libc::c_char;
-use std::ffi::{CStr,CString};
-use std::str;
-
-#[no_mangle]
-pub extern fn basename_for_chop(string: *const c_char) -> *const c_char {
-  let c_str = unsafe {
-    if string.is_null() {
-      return string;
-    }
-    CStr::from_ptr(string)
-  };
-
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
-
-  let mut offset = 0;
-  let mut trailing_slashes = r_str.chars().rev();
-  loop {
-    match trailing_slashes.next() {
-      Some(MAIN_SEPARATOR) => { offset = offset + 1 },
-      _                    => { break               },
-    }
-  }
-  
-  let r_str = &r_str[0..r_str.len()-offset];
-  let part = r_str.rsplit_terminator(MAIN_SEPARATOR).nth(0).unwrap_or("");
-  
-  let output = CString::new(part).unwrap();
-  output.into_raw()
-}

data/src/both_are_blank.rs

@@ -1,22 +0,0 @@
-use libc::c_char;
-use std::ffi::{CStr};
-use std::str;
-
-#[no_mangle]
-pub extern fn both_are_blank(s1: *const c_char, s2: *const c_char) -> bool {
-  let c_str1 = unsafe {
-    if s1.is_null() {
-      return true;
-    }
-    CStr::from_ptr(s1)
-  };
-  let c_str2 = unsafe {
-    if s2.is_null() {
-      return true;
-    }
-    CStr::from_ptr(s2)
-  };
-
-  str::from_utf8(c_str1.to_bytes()).unwrap().trim().is_empty() &&
-    str::from_utf8(c_str2.to_bytes()).unwrap().trim().is_empty()
-}

data/src/dirname_for_chop.rs

@@ -1,36 +0,0 @@
-use std::path::MAIN_SEPARATOR;
-use libc::c_char;
-use std::ffi::{CStr,CString};
-use std::str;
-
-#[no_mangle]
-pub extern fn dirname_for_chop(string: *const c_char) -> *const c_char {
-  let c_str = unsafe {
-    if string.is_null() {
-      return string
-    }
-    CStr::from_ptr(string)
-  };
-
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
-
-  if r_str.is_empty() {
-    return string
-  }
-
-  let mut offset = 0;
-  let mut trailing_slashes = r_str.chars().rev();
-  loop {
-    match trailing_slashes.next() {
-      Some(MAIN_SEPARATOR) => { offset = offset + 1 },
-      _                    => { break               },
-    }
-  }
-  
-  let r_str = &r_str[0..r_str.len()-offset];
-
-  let base = r_str.rsplit_terminator(MAIN_SEPARATOR).nth(0).unwrap_or("");
-
-  let output = CString::new(&r_str[0..r_str.len()-base.len()]).unwrap();
-  output.into_raw()
-}

data/src/entries.rs

@@ -1,30 +0,0 @@
-use libc::c_char;
-use std::ffi::{CStr,CString};
-use std::str;
-use std::fs;
-use ruby_array::RubyArray;
-
-#[no_mangle]
-pub extern fn entries(string: *const c_char) -> RubyArray {
-    let c_str = unsafe {
-        assert!(!string.is_null());
-
-        CStr::from_ptr(string)
-    };
-
-    let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
-
-    let files = fs::read_dir(r_str).unwrap();
-    let mut files_vec = vec![];
-
-    files_vec.push(CString::new(".").unwrap().into_raw());
-    files_vec.push(CString::new("..").unwrap().into_raw());
-
-    for file in files {
-        let file_name_str = file.unwrap().file_name().into_string().unwrap();
-        let file_name_cstr = CString::new(file_name_str).unwrap().into_raw();
-        files_vec.push(file_name_cstr);
-    }
-
-    RubyArray::from_vec(files_vec)
-}

data/src/has_trailing_separator.rs

@@ -1,27 +0,0 @@
-use std::path::{Path, MAIN_SEPARATOR};
-use libc::c_char;
-use std::ffi::CStr;
-use std::str;
-
-#[no_mangle]
-pub extern "C" fn has_trailing_separator(string: *const c_char) -> bool {
-    let c_str = unsafe {
-        if string.is_null() {
-            return false
-        }
-        CStr::from_ptr(string)
-    };
-
-    let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
-    let path = Path::new(r_str);
-    let last_component = path.iter().last();
-    if last_component.is_none() {
-        false
-    } else {
-        let mut parts: Vec<&str> = r_str.rsplit_terminator(MAIN_SEPARATOR).collect();
-        parts.retain(|x| !x.is_empty());
-        let last_part = parts.first().unwrap_or(&"").chars().last().unwrap_or(MAIN_SEPARATOR);
-        let last_char = r_str.chars().last().unwrap();
-        (last_part != last_char) && (last_char == MAIN_SEPARATOR)
-    }
-}

data/src/is_absolute.rs

@@ -1,17 +0,0 @@
-use libc::c_char;
-use std::ffi::{CStr};
-use std::path::MAIN_SEPARATOR;
-
-
-#[no_mangle]
-pub extern fn is_absolute(path: *const c_char) -> bool {
-  if path.is_null() {
-    return false;
-  }
-  let r_str = unsafe { CStr::from_ptr(path) }.to_str().unwrap();
-
-  match r_str.chars().next() {
-    Some(c) => c == MAIN_SEPARATOR,
-    None => false
-  }
-}

data/src/is_blank.rs

@@ -1,15 +0,0 @@
-use libc::c_char;
-use std::ffi::{CStr};
-use std::str;
-
-#[no_mangle]
-pub extern fn is_blank(string: *const c_char) -> bool {
-  let c_str = unsafe {
-    if string.is_null() {
-      return true;
-    }
-    CStr::from_ptr(string)
-  };
-
-  str::from_utf8(c_str.to_bytes()).unwrap().trim().is_empty()
-}

data/src/is_directory.rs

@@ -1,18 +0,0 @@
-use libc::c_char;
-use std::ffi::{CStr};
-use std::str;
-use std::path::Path;
-
-#[no_mangle]
-pub extern fn is_directory(string: *const c_char) -> bool {
-  let c_str = unsafe {
-    if string.is_null() {
-      return false;
-    }
-    CStr::from_ptr(string)
-  };
-
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
-
-  Path::new(r_str).is_dir()
-}

data/src/is_relative.rs

@@ -1,16 +0,0 @@
-use std::path::MAIN_SEPARATOR;
-use libc::c_char;
-use std::ffi::{CStr};
-
-#[no_mangle]
-pub extern fn is_relative(path: *const c_char) -> bool {
-  if path.is_null() {
-    return false;
-  }
-  let r_str = unsafe { CStr::from_ptr(path) }.to_str().unwrap();
-
-  match r_str.chars().next() {
-    Some(c) => c != MAIN_SEPARATOR,
-    None => true
-  }
-}

data/src/ruby_array.rs

@@ -1,20 +0,0 @@
-use libc;
-use std::mem;
-
-#[repr(C)]
-pub struct RubyArray {
-  len: libc::size_t,
-  data: *const libc::c_void,
-}
-
-impl RubyArray {
-  #[allow(dead_code)]
-  pub fn from_vec<T>(vec: Vec<T>) -> RubyArray {
-    let array = RubyArray {
-      data: vec.as_ptr() as *const libc::c_void,
-        len: vec.len() as libc::size_t
-    };
-    mem::forget(vec);
-    array
-  }
-}

data/src/ruby_string.rs

@@ -1,34 +0,0 @@
-use libc::c_char;
-use std::ffi::{CStr,CString};
-use std::str;
-
-pub struct RubyString;
-
-// Coercing strs into Strings has some loss of performance
-// You may use these methods temporarily but it would be much better
-// to write all of this code out in each method using just str.
-//
-// Using these methods you will still get you 10X (= 900%) performance
-// gain regardless.  But really consider not using String.  If you do
-// as I've intstructed the performance gains will go from 900% to 1250%.
-impl RubyString {
-  #[allow(dead_code)]
-  // FOR QUICK IMPLEMENTATION.  NOT FOR PRODUCTION.
-  // SEE BENCHMARKS FOR SANCTIONED IMPLEMENTATION.
-  fn from_ruby(s: *const c_char) -> String {
-    let c_str = unsafe {
-      assert!(!s.is_null());
-      CStr::from_ptr(s)
-    };
-    (*str::from_utf8(c_str.to_bytes()).unwrap_or("")).to_string()
-  }
-
-  #[allow(dead_code)]
-  // FOR QUICK IMPLEMENTATION.  NOT FOR PRODUCTION.
-  // SEE BENCHMARKS FOR SANCTIONED IMPLEMENTATION.
-  fn to_ruby<S: Into<String>>(s: S) -> *const c_char {
-    let r_str = s.into();
-    let s_slice: &str = &r_str[..];
-    CString::new(s_slice).unwrap().into_raw()
-  }
-}