faster_path 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 145d0ead52899b0287c3854351371ed572753abf
-  data.tar.gz: 26a96e5e5120c5697f44d1dd2aae6d0780f361c0
+  metadata.gz: f92e6ae04b2843b4ebbe35489a57a3761e549c5a
+  data.tar.gz: cf6a2778380a40beae6bd75f399c8e3ba3945c57
 SHA512:
-  metadata.gz: d05a6334782f4994a0ff6d25f4b9e3851c08fc26dec8e32e8533ea459f602fe9df0ec2ac8a8d557ad4d278b713d7073db0ec641754f0537416e9bfa1ee3decf6
-  data.tar.gz: 98e70ecc789fbdb19d945f07a0f3c2ab2844c719ef7d41794aace5e659a3b9fa0353d4ca409bea0a28f1549d0db698f494a1d819d7de2cf2158a5fa6def61dd9
+  metadata.gz: 0924b343e18fbe1444b5e1ebe8def4f7856dfe99298bd24b3ba1e5d1b2367900d6464063ba9c0b6508ea75799cee37085531d63627937e0a1b620e7002496742
+  data.tar.gz: 834d364fd05f66a698964e9fd9c9f71717a8026f114f04f0349fe5e6c700572e1f39d86b1083cc1b475c659605d13b708f116c2f4baf9075be3976d18b466c47

data/README.md

@@ -86,7 +86,7 @@ Current methods implemented:
 |FasterPath Rust Implementation|Ruby 2.3.1 Implementation|Performance Improvement|
 |---|---|:---:|
 | `FasterPath.absolute?` | `Pathname#absolute?` | 1234.6% |
-| `FasterPath.chop_basename` | `Pathname#chop_basename` | 27.5% |
+| `FasterPath.chop_basename` | `Pathname#chop_basename` | 46.7% |
 | `FasterPath.relative?` | `Pathname#relative?` | 1262.3% |
 | `FasterPath.blank?` | | |
 
@@ -115,8 +115,9 @@ FasterPath.sledgehammer_everything!
 
 The primary methods to target are mostly listed in the **Why** section above.  You may find the Ruby
 source code useful for Pathname's [Ruby source](https://github.com/ruby/ruby/blob/32674b167bddc0d737c38f84722986b0f228b44b/ext/pathname/lib/pathname.rb),
-[C source](https://github.com/ruby/ruby/blob/32674b167bddc0d737c38f84722986b0f228b44b/ext/pathname/pathname.c), and
-[tests](https://github.com/ruby/ruby/blob/32674b167bddc0d737c38f84722986b0f228b44b/test/pathname/test_pathname.rb).
+[C source](https://github.com/ruby/ruby/blob/32674b167bddc0d737c38f84722986b0f228b44b/ext/pathname/pathname.c),
+[tests](https://github.com/ruby/ruby/blob/32674b167bddc0d737c38f84722986b0f228b44b/test/pathname/test_pathname.rb),
+and checkout the [documentation](http://ruby-doc.org/stdlib-2.3.1/libdoc/pathname/rdoc/Pathname.html).
 
 Methods will be written as exclusively in Rust as possible.  Even just writing a **not** in Ruby with a
 Rust method like `!absolute?` _(not absolute)_ drops 39% of the performance already gained in Rust.

data/ext/faster_path/extconf.rb

@@ -16,4 +16,4 @@ Dir.chdir('../../') do
   system("rake clean_src")
 end
 
-create_makefile('faster_path/dummy')
+create_makefile('faster_path/dummy')

data/faster_path.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/danielpclark/faster_path"
   spec.license       = "MIT OR Apache-2.0"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|assets)/}) }
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|assets|benches)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.extensions    << "ext/faster_path/extconf.rb"

data/lib/faster_path.rb

@@ -18,17 +18,18 @@ module FasterPath
   # to handle non-path strings.
   def self.chop_basename(pth)
     d,b = [Rust.dirname(pth), Rust.basename(pth)]
-    if blank?(d) && blank?(b)
-      nil
-    else
-      [d,b]
-    end
+    [d,b] unless Rust.both_are_blank(d,b)
   end
 
   def self.blank?(str)
     Rust.is_blank(str)
   end
 
+  # EXAMPLE
+  #def self.one_and_two
+  #  Rust.one_and_two.to_a
+  #end
+
   private
   module Rust
     extend FFI::Library
@@ -36,11 +37,25 @@ module FasterPath
       prefix = Gem.win_platform? ? "" : "lib"
       "#{File.expand_path("../target/release/", File.dirname(__FILE__))}/#{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
+
     attach_function :is_absolute, [ :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
     attach_function :dirname, [ :string ], :string
+
+    # EXAMPLE
+    #attach_function :one_and_two, [], FromRustArray.by_value
   end
   private_constant :Rust
 end

data/lib/faster_path/version.rb

@@ -1,3 +1,3 @@
 module FasterPath
-  VERSION = "0.0.6"
+  VERSION = "0.0.8"
 end

data/src/basename.rs

@@ -0,0 +1,15 @@
+#[no_mangle]
+pub extern fn basename(string: *const c_char) -> *const c_char {
+  let c_str = unsafe {
+    assert!(!string.is_null());
+
+    CStr::from_ptr(string)
+  };
+
+  let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
+
+  let part = Path::new(r_str).file_name().unwrap_or(OsStr::new("")).to_str();
+  
+  let output = CString::new(format!("{}", part.unwrap())).unwrap();
+  output.into_raw()
+}

data/src/both_are_blank.rs

@@ -0,0 +1,14 @@
+#[no_mangle]
+pub extern fn both_are_blank(s1: *const c_char, s2: *const c_char) -> bool {
+  let c_str1 = unsafe {
+    assert!(!s1.is_null());
+    CStr::from_ptr(s1)
+  };
+  let c_str2 = unsafe {
+    assert!(!s2.is_null());
+    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.rs

@@ -0,0 +1,25 @@
+#[no_mangle]
+pub extern fn dirname(string: *const c_char) -> *const c_char {
+  let c_str = unsafe {
+    assert!(!string.is_null());
+
+    CStr::from_ptr(string)
+  };
+
+  let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
+
+  if r_str.is_empty() {
+    return string
+  }
+
+  let path = Path::new(r_str).parent().unwrap_or(Path::new(""));
+
+  let out_str = if !path.to_str().unwrap().is_empty() {
+    format!("{}{}", path.to_str().unwrap(), MAIN_SEPARATOR)
+  } else {
+    format!("{}", path.to_str().unwrap())
+  };
+
+  let output = CString::new(out_str).unwrap();
+  output.into_raw()
+}

data/src/is_absolute.rs

@@ -0,0 +1,12 @@
+#[no_mangle]
+pub extern fn is_absolute(string: *const c_char) -> bool {
+  let c_str = unsafe {
+    assert!(!string.is_null());
+
+    CStr::from_ptr(string)
+  };
+
+  let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
+
+  r_str.chars().next().unwrap_or("muffins".chars().next().unwrap()) == MAIN_SEPARATOR
+}

data/src/is_blank.rs

@@ -0,0 +1,10 @@
+#[no_mangle]
+pub extern fn is_blank(string: *const c_char) -> bool {
+  let c_str = unsafe {
+    assert!(!string.is_null());
+
+    CStr::from_ptr(string)
+  };
+
+  str::from_utf8(c_str.to_bytes()).unwrap().trim().is_empty()
+}

data/src/is_relative.rs

@@ -0,0 +1,12 @@
+#[no_mangle]
+pub extern fn is_relative(string: *const c_char) -> bool {
+  let c_str = unsafe {
+    assert!(!string.is_null());
+
+    CStr::from_ptr(string)
+  };
+
+  let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
+
+  r_str.chars().next().unwrap_or("muffins".chars().next().unwrap()) != MAIN_SEPARATOR
+}

data/src/lib.rs

@@ -10,82 +10,23 @@ use std::path::{Path,MAIN_SEPARATOR};
 use libc::c_char;
 use std::ffi::{CStr,CString,OsStr};
 use std::str;
-
-#[no_mangle]
-pub extern fn is_absolute(string: *const c_char) -> bool {
-  let c_str = unsafe {
-    assert!(!string.is_null());
-
-    CStr::from_ptr(string)
-  };
-
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
-
-  r_str.chars().next().unwrap_or("muffins".chars().next().unwrap()) == MAIN_SEPARATOR
-}
-
-#[no_mangle]
-pub extern fn is_relative(string: *const c_char) -> bool {
-  let c_str = unsafe {
-    assert!(!string.is_null());
-
-    CStr::from_ptr(string)
-  };
-
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
-
-  r_str.chars().next().unwrap_or("muffins".chars().next().unwrap()) != MAIN_SEPARATOR
-}
-
-#[no_mangle]
-pub extern fn is_blank(string: *const c_char) -> bool {
-  let c_str = unsafe {
-    assert!(!string.is_null());
-
-    CStr::from_ptr(string)
-  };
-
-  str::from_utf8(c_str.to_bytes()).unwrap().trim().is_empty()
-}
-
-#[no_mangle]
-pub extern fn basename(string: *const c_char) -> *const c_char {
-  let c_str = unsafe {
-    assert!(!string.is_null());
-
-    CStr::from_ptr(string)
-  };
-
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
-
-  let part = Path::new(r_str).file_name().unwrap_or(OsStr::new("")).to_str();
-  
-  let output = CString::new(format!("{}", part.unwrap())).unwrap();
-  output.into_raw()
-}
-
-#[no_mangle]
-pub extern fn dirname(string: *const c_char) -> *const c_char {
-  let c_str = unsafe {
-    assert!(!string.is_null());
-
-    CStr::from_ptr(string)
-  };
-
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
-
-  if r_str.is_empty() {
-    return string
-  }
-
-  let path = Path::new(r_str).parent().unwrap_or(Path::new(""));
-
-  let out_str = if !path.to_str().unwrap().is_empty() {
-    format!("{}{}", path.to_str().unwrap(), MAIN_SEPARATOR)
-  } else {
-    format!("{}", path.to_str().unwrap())
-  };
-
-  let output = CString::new(out_str).unwrap();
-  output.into_raw()
-}
+use std::mem;
+
+include!("ruby_string.rs");
+include!("ruby_array.rs");
+include!("is_absolute.rs");
+include!("is_relative.rs");
+include!("is_blank.rs");
+include!("both_are_blank.rs");
+include!("basename.rs");
+include!("dirname.rs");
+
+// 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)
+//}

data/src/ruby_array.rs

@@ -0,0 +1,17 @@
+#[repr(C)]
+pub struct RubyArray {
+  len: libc::size_t,
+  data: *const libc::c_void,
+}
+
+impl RubyArray {
+  #[allow(dead_code)]
+  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

@@ -0,0 +1,30 @@
+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()
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-11 00:00:00.000000000 Z
+date: 2016-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -90,7 +90,15 @@ files:
 - lib/faster_path/optional/monkeypatches.rb
 - lib/faster_path/optional/refinements.rb
 - lib/faster_path/version.rb
+- src/basename.rs
+- src/both_are_blank.rs
+- src/dirname.rs
+- src/is_absolute.rs
+- src/is_blank.rs
+- src/is_relative.rs
 - src/lib.rs
+- src/ruby_array.rs
+- src/ruby_string.rs
 homepage: https://github.com/danielpclark/faster_path
 licenses:
 - MIT OR Apache-2.0