faster_path 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4df270a95aa742a4ebdb10cac2ab2f761b1255b9
-  data.tar.gz: c3b4fe124baee6268a02ec46d9c25917ec63d5e9
+  metadata.gz: ab56b250d7522c94ed78c2754087e351691b4be2
+  data.tar.gz: ac3c62e7d2d87ccc264fc2e6cf5eced81c511a8b
 SHA512:
-  metadata.gz: 40fcb306c9eb7d316f0fd590df581afc9e96165b7120d2e02ab6aeb750b3e3d03a4c325d2ecbe5212c563310114c43f7e9d37e4c737500ad37db3132f602a9f0
-  data.tar.gz: 3330b8afe7d5d1fd5ffab234bf2fbdd8e0dd988821f3133b32b5b2c62e93dad5a9df90ca1ef0daabb41fa72a6ef6139d19db360587b2b1da713e6c28bb9f50e2
+  metadata.gz: e5171e63daf6173d3a57c37b446c015bd04b5abe5cac5b769ef9403734711c9a787b5070291c4bed6d6ef0ada61bb3f2be0b77a7f62a996ced1ed1ede6213114
+  data.tar.gz: 0d0f4ce1529dae792d785d7588ef3eb7b4dc4b9d4819ea230a3bb33dc9da889b88e2204fc99a2343822872ce90325950ce3edb94f04422cdeec61ba79f7fde68

data/.gitignore

@@ -1,8 +1,5 @@
 /.bundle/
-/target/debug
-/target/release/.fingerprint
-/target/release/.cargo-lock
-/target/release/deps
+/target/
 /.yardoc
 /Gemfile.lock
 /_yardoc/
@@ -11,3 +8,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+priority-methods.txt
+mkmf.log

data/Cargo.toml

@@ -14,3 +14,4 @@ crate-type = ["dylib"]
 
 [dependencies]
 libc = "0.2.11"
+#regex = "0.1.71"

data/README.md

@@ -18,6 +18,14 @@ be a sledge hammer ;-)
 
 ## Installation
 
+Ensure Rust is installed:
+
+[Rust Downloads](https://www.rust-lang.org/downloads.html)
+
+```
+curl -sSf https://static.rust-lang.org/rustup.sh | sudo sh -s -- --channel=nightly
+```
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -34,7 +42,34 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: _(project is too young for usage details)_
+Current methods implemented:
+
+|Rust Implementation|Ruby Implementation|Performance Improvemant|
+|---|---|---|
+| `FasterPath.absolute?` | `Pathname#absolute?` | 545% to 1450% |
+| `FasterPath.chop_basename` | `Pathname#chop_basename` | 6.7% to 54.6% |
+| FasterPath.blank? | | |
+
+You may choose to use the methods directly, or scope change to rewrite behavior on the
+standard library with the included refinements, or even call a method to monkeypatch 
+everything everywhere.
+
+**Note:** `Pathname#chop_basename` in Ruby STDLIB has a bug with blank strings, that is the
+only difference in behavior against FasterPath's implementation.
+
+For the scoped **refinements** you will need to
+
+```
+require "faster_path/optional/refinements"
+using FasterPath::RefinePathname
+```
+
+And for the sldeghammer of monkey patching you can do
+
+```
+require "faster_path/optional/monkeypatching"
+FasterPath.sledgehammer_everything!
+```
 
 ## Development
 

data/Rakefile

@@ -1,5 +1,32 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require 'fileutils'
+
+desc "Building extension..."
+task :build_src do
+  puts "Building extension..."
+  system("cargo build --release")
+end
+
+desc "Cleaning up build..."
+task :clean_src do
+  puts "Cleaning up build..."
+  # Remove all but library file
+  FileUtils.
+    rm_rf(
+      Dir.
+      glob('target/release/*').
+      keep_if {|f|
+        # TODO: change regex to include other library extensions for other OS builds
+        !f[/\.so\z/]
+      }
+  )
+end
+
+desc "Compiling Rust extension..."
+task :build_lib => [:build_src, :clean_src] do
+  puts "Completed build!"
+end
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"

data/ext/faster_path/extconf.rb

@@ -0,0 +1,19 @@
+require 'mkmf'
+
+have_header('Dummy Makefile')
+
+unless find_executable('cargo')
+  puts "You need to have Rust installed for this gem to build natively."
+  puts "Please install the latest nightly build:"
+  puts
+  puts "curl -sSf https://static.rust-lang.org/rustup.sh | sudo sh -s -- --channel=nightly"
+  puts
+  END { puts "Exiting..."}
+end
+
+Dir.chdir('../../') do
+  system("rake build_src")
+  system("rake clean_src")
+end
+
+create_makefile('faster_path/dummy')

data/faster_path.gemspec

@@ -16,10 +16,11 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.extensions    << "ext/faster_path/extconf.rb"
   spec.require_paths = ["lib"]
 
   spec.add_dependency "ffi"
   spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 11.1"
   spec.add_development_dependency "minitest", "~> 5.8"
 end

data/lib/faster_path.rb

@@ -1,32 +1,39 @@
 require "faster_path/version"
+require 'pathname'
 require "ffi"
 
 module FasterPath
+  # Spec to Pathname#absolute?
   def self.absolute?(pth)
-    Rust.absolute(pth)
+    Rust.is_absolute(pth)
   end
 
-  def self.monkeypatch_pathname
-    class << ::Pathname
-      def absolute?
-        FasterPath.absolute?(@path)
-      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,b = [Rust.dirname(pth), Rust.basename(pth)]
+    if blank?(d) && blank?(b)
+      nil
+    else
+      [d,b]
     end
   end
 
-  module RefinePathname
-    refine Pathname do
-      def absolute?
-        FasterPath.absolute?(@path)
-      end
-    end
+  def self.blank?(str)
+    Rust.is_blank(str)
   end
 
   private
   module Rust
     extend FFI::Library
     ffi_lib 'target/release/libfaster_path.so'
-    attach_function :absolute, [ :string ], :bool
+    attach_function :is_absolute, [ :string ], :bool
+    attach_function :is_blank, [ :string ], :bool
+    attach_function :basename, [ :string ], :string
+    attach_function :dirname, [ :string ], :string
+    #attach_function :chop_basename, [ :string ], [:string]
   end
   private_constant :Rust
 end

data/lib/faster_path/optional/monkeypatches.rb

@@ -0,0 +1,15 @@
+module FasterPath
+  def self.sledgehammer_everything!
+    class << ::Pathname
+      def absolute?
+        FasterPath.absolute?(@path)
+      end
+
+      def chop_basename(pth)
+        FasterPath.chop_basename(pth)
+      end
+      private :chop_basename
+    end
+  end
+end
+

data/lib/faster_path/optional/refinements.rb

@@ -0,0 +1,14 @@
+module FasterPath
+  module RefinePathname
+    refine Pathname do
+      def absolute?
+        FasterPath.absolute?(@path)
+      end
+
+      def chop_basename(pth)
+        FasterPath.chop_basename(pth)
+      end
+      private :chop_basename
+    end
+  end
+end

data/lib/faster_path/version.rb

@@ -1,3 +1,3 @@
 module FasterPath
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/src/lib.rs

@@ -5,13 +5,15 @@
 // 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;
+//extern crate regex;
 
+use std::path::{Path,MAIN_SEPARATOR};
 use libc::c_char;
-use std::ffi::CStr;
+use std::ffi::{CStr,CString,OsStr};
 use std::str;
 
 #[no_mangle]
-pub extern fn absolute(string: *const c_char) -> bool {
+pub extern fn is_absolute(string: *const c_char) -> bool {
   let c_str = unsafe {
     assert!(!string.is_null());
 
@@ -20,9 +22,92 @@ pub extern fn absolute(string: *const c_char) -> bool {
 
   let r_str = str::from_utf8(c_str.to_bytes()).unwrap();
 
-  match r_str.chars().next() {
-    Some('/') => { true },
-    _ => { false },
+  r_str.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()
 }
 
+//#[no_mangle]
+//pub extern fn chop_basename(string: *const c_char) -> Vec<*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 mut parts: Vec<*const libc::c_char> = vec![];
+//
+//  {
+//    use regex::Regex;
+//    let re = Regex::new(format!(r"\A{}?\z", MAIN_SEPARATOR).as_str()).unwrap();
+//    if re.is_match(r_str){
+//      return parts;
+//    }
+//  }
+//  
+//  let mut pieces = r_str.rsplitn(1, MAIN_SEPARATOR);
+//  loop {
+//    match pieces.next() {
+//      Some(val) => { parts.push(CString::new(val.to_string()).unwrap().into_raw()) },
+//      None => { break },
+//    }
+//  }
+//  parts
+//}
+
+//#[test]
+//fn it_chops_basename() {
+//  let result = chop_basename(CString::new("/hello/world.txt").unwrap().as_ptr());
+//}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-09 00:00:00.000000000 Z
+date: 2016-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -70,7 +70,8 @@ description: FasterPath is a reimplementation of Pathname for better performance
 email:
 - 6ftdan@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/faster_path/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -78,16 +79,18 @@ files:
 - Cargo.lock
 - Cargo.toml
 - Gemfile
-- LICENSE.txt
+- MIT-LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- ext/faster_path/extconf.rb
 - faster_path.gemspec
 - lib/faster_path.rb
+- lib/faster_path/optional/monkeypatches.rb
+- lib/faster_path/optional/refinements.rb
 - lib/faster_path/version.rb
 - src/lib.rs
-- target/release/libfaster_path.so
 homepage: https://github.com/danielpclark/faster_path
 licenses:
 - MIT OR Apache-2.0