faster_path 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ad592a885912e4267151be6ee15a9accfbd34ef
-  data.tar.gz: b2b22d3198284b6dc2bb177c72bd1c99bbcbb3a5
+  metadata.gz: 40367b49892754c5b9d83891289cc0ce30e757d6
+  data.tar.gz: 8a92f9a7796c946a873cfded321b529f1f8d57bf
 SHA512:
-  metadata.gz: 17eecf18612f14fa87de8fc58f2ae4b08cb4e7f98e4d62283f87457d09e1822a3aba7db72df2e14e4d9cddcab60abf7cc2148742d9ae301541454e7a62080201
-  data.tar.gz: 15ad8f6310ce3b5188533f957bbc5e0ba9280686dd148adca124d455249c6426b2ee1f4b9cff43383e6601daf5682fad78a0d376d343537fe1f81118a20fcb21
+  metadata.gz: 8dc854ddd64ba12ac79ff11e792bf5fc6723d3ea547056d474a344572e0608f0e0c0c0d688c39a70c50e5a636d36215d0906a952cd65f58402a7fc05d8f135c4
+  data.tar.gz: f0e6009a18eeeb0414836f3b13d4684db44839e466845b745c6b08440da63ad247be78acc7671ef53c07dc8c69237d0e964e81c3bd9bb9dd717ce17a65fd2184

data/Cargo.lock

@@ -10,3 +10,5 @@ name = "libc"
 version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[metadata]
+"checksum libc 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "c96061f0c8a2dc27482e394d82e23073569de41d73cd736672ccd3e5c7471bfd"

data/Gemfile

@@ -1,4 +1,12 @@
-source 'https://rubygems.org'
+source 'https://rubygems.org' do
+  # Specify your gem's dependencies in faster_path.gemspec
+  gemspec
+end
 
-# Specify your gem's dependencies in faster_path.gemspec
-gemspec
+begin
+# https://github.com/ruby/spec dependencies
+eval_gemfile File.expand_path('spec/ruby_spec/Gemfile', File.dirname(__FILE__))
+rescue
+  `git submodule update --init`
+  eval_gemfile File.expand_path('spec/ruby_spec/Gemfile', File.dirname(__FILE__))
+end

data/README.md

@@ -2,6 +2,7 @@
 [![Gem Version](https://badge.fury.io/rb/faster_path.svg)](https://badge.fury.io/rb/faster_path)
 [![Build Status](https://travis-ci.org/danielpclark/faster_path.svg?branch=master)](https://travis-ci.org/danielpclark/faster_path)
 [![Tweet This](https://raw.githubusercontent.com/danielpclark/faster_path/master/assets/tweet.png)](https://twitter.com/share?url=https%3A%2F%2Fgithub.com%2Fdanielpclark%2Ffaster_path&via=6ftdan&hashtags=Ruby&text=You%20could%20save%2015%25%20or%20more%20on%20website%20page%20load%20time%20by%20switching%20to%20the%20FasterPath%20gem.)
+[New Wiki Up!](https://github.com/danielpclark/faster_path/wiki)
 
 #### This gem shaves off more than 30% of my Rails application page load time.
 
@@ -116,25 +117,33 @@ And then execute:
 Or install it yourself as:
 
     $ gem install faster_path
-    
+
 **MAC USERS:** At the moment Mac users need to install the extension manualy.  Go to the gem directory and run `cargo build --release` .  There is an issue opened for this and I'm looking for people who have Macs to help on this.
 
+## Visual Benchmarks
+
+Benchmarks in Faster Path now produce visual graph charts of performance improvements.
+When you run `rake bench` the graph art will be placed in `doc/graph/`.  Here's the performance
+improvement result  for the `chop_basename` method.
+
+![Visual Benchmark](https://raw.githubusercontent.com/danielpclark/faster_path/master/assets/chop_basename_benchmark.jpg "Visual Benchmark")
+
 ## Usage
 
 Current methods implemented:
 
 |FasterPath Rust Implementation|Ruby 2.3.1 Implementation|Performance Improvement|
 |---|---|:---:|
-| `FasterPath.absolute?` | `Pathname#absolute?` | 1234.6% |
-| `FasterPath.basename` | `File.basename` | 31.3% |
-| `FasterPath.chop_basename` | `Pathname#chop_basename` | 66.0% |
-| `FasterPath.relative?` | `Pathname#relative?` | 1262.3% |
+| `FasterPath.absolute?` | `Pathname#absolute?` | 93.9% |
+| `FasterPath.chop_basename` | `Pathname#chop_basename` | 50.6% |
+| `FasterPath.relative?` | `Pathname#relative?` | 93.2% |
 | `FasterPath.blank?` | | |
-| `FasterPath.directory?` | `Pathname#directory?` | 20% |
-| `FasterPath.add_trailing_separator` | `Pathname#add_trailing_separator` | 63.8% |
+| `FasterPath.directory?` | `Pathname#directory?` | 25.5% |
+| `FasterPath.add_trailing_separator` | `Pathname#add_trailing_separator` | 46.8% |
+| `FasterPath.has_trailing_separator?` | `Pathname#has_trailing_separator` | 61.2% |
 
 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 
+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
@@ -154,6 +163,21 @@ require "faster_path/optional/monkeypatches"
 FasterPath.sledgehammer_everything!
 ```
 
+## Unstable optional bits
+
+**Optional methods which ~~have regressions.~~ are unstable.**  These will **not** be included by default in monkey-patches.  Be cautious when using the `FasterPath::RefineFile` refinement.  To try them anyways use the environment flag of `WITH_REGRESSION`.  These methods are here to be improved upon.
+
+|FasterPath Implementation|Ruby Implementation|
+|---|---|
+| `FasterPath.dirname` | `File.dirname` |
+| `FasterPath.basename` | `File.basename` |
+| `FasterPath.extname` | `File.extname` |
+
+It's been my observation (and some others) that the Rust implementation of the C code for `File` has similar results but
+performance seems to vary based on CPU cache on possibly 64bit/32bit system environmnets.
+
+**Developers for FasterPath:** Most of these need to be rewritten, please use `WITH_REGRESSION` in your testing.  You can see the resulting failures currently on TravisCI under "Allow Failures".
+
 ## Getting Started with Development
 
 The primary methods to target are mostly listed in the **Why** section above.  You may find the Ruby
@@ -166,8 +190,46 @@ Methods will be written as exclusively in Rust as possible.  Even just writing a
 Rust method like `!absolute?` _(not absolute)_ drops 39% of the performance already gained in Rust.
 Whenever feasible implement it in Rust.
 
-After checking out the repo, make sure you have Rust installed.  Then run `bundle && rake build_lib` .
-Then, run `rake test` to run the tests, and `rake bench` for benchmarks.
+After checking out the repo, make sure you have Rust installed, then run `bundle`.
+Run `rake test` to run the tests, and `rake bench` for benchmarks.
+
+Learn and share performance tips on the [wiki](https://github.com/danielpclark/faster_path/wiki)!
+
+### Building and running tests
+
+First, bundle the gem's development dependencies by running `bundle`.
+
+Then, build the rust code:
+
+```sh
+rake build_src
+```
+
+FasterPath is tested with [The Ruby Spec Suite](https://github.com/ruby/spec) to ensure it is compatible with the
+native implementation, and also has its own test suite testing its monkey-patching and refinements functionality.
+
+To run all the tests at once, simply run `rake`.
+To run all the ruby spec tests, run `mspec`.
+
+To run an individual test or benchmark from FasterPath's own suite:
+
+```sh
+# An individual test file:
+ruby -I lib:test test/benches/absolute_benchmark.rb
+# All tests:
+rake minitest
+```
+
+To run an individual ruby spec test, run `mspec` with a path relative to `spec/ruby_spec`, e.g.:
+
+```sh
+# A path to a file or a directory:
+mspec core/file/basename_spec.rb
+# Tests most relevant to FasterPath:
+mspec core/file library/pathname
+# All tests:
+mspec
+```
 
 ## Contributing
 

data/Rakefile

@@ -2,13 +2,13 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 require 'fileutils'
 
-desc "Building extension..."
+desc "Build Rust extension"
 task :build_src do
   puts "Building extension..."
   system("cargo build --release")
 end
 
-desc "Cleaning up build..."
+desc "Clean up Rust build"
 task :clean_src do
   puts "Cleaning up build..."
   # Remove all but library file
@@ -22,20 +22,29 @@ task :clean_src do
   )
 end
 
-desc "Compiling Rust extension..."
-task :build_lib => [:build_src, :clean_src] do
+desc "Build + clean up Rust extension"
+task build_lib: [:build_src, :clean_src] do
   puts "Completed build!"
 end
 
-Rake::TestTask.new(:test) do |t|
+Rake::TestTask.new(minitest: :build_lib) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-Rake::TestTask.new(:bench) do |t|
+task :test => :minitest do |t|
+  exec 'mspec --format spec core/file/basename core/file/extname core/file/dirname library/pathname'
+end
+
+Rake::TestTask.new(bench: :build_lib) do |t|
   t.libs = %w(lib test)
   t.pattern = 'test/**/*_benchmark.rb'
 end
 
-task :default => :test
+Rake::TestTask.new(pbench: :build_lib) do |t|
+  t.libs = %w(lib test test/pbench)
+  t.pattern = 'test/pbench/pbench_suite.rb'
+end
+
+task default: :test

data/faster_path.gemspec

@@ -13,17 +13,26 @@ 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|benches)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.files         = [
+    "Cargo.lock", "Cargo.toml", "Gemfile",
+    "MIT-LICENSE.txt", "README.md", "Rakefile", "bin/console", "bin/setup",
+    "ext/faster_path/extconf.rb", "faster_path.gemspec"
+  ]
+  spec.files += Dir['lib/**/*']
+  spec.files += Dir['src/**/*']
+
   spec.extensions    << "ext/faster_path/extconf.rb"
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "bundler", "~> 1.12"
+  spec.add_dependency "rake", "~> 12.0"
   spec.add_dependency "ffi", "~> 1.9"
-  spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "method_source", "~> 0.8.2"
-  spec.add_development_dependency "rake", "~> 11.1"
-  spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_development_dependency "minitest", "~> 5.10"
   spec.add_development_dependency "minitest-reporters", "~> 1.1"
   spec.add_development_dependency "color_pound_spec_reporter", "~> 0.0.5"
+  unless ENV['TRAVIS']
+    spec.add_development_dependency "stop_watch", "~> 0.1.0"
+    spec.add_development_dependency "gruff", "~> 0.7.0"
+  end
 end

data/lib/faster_path/optional/monkeypatches.rb

@@ -1,10 +1,20 @@
+require 'pathname'
+
 module FasterPath
   def self.sledgehammer_everything!
     ::File.class_eval do
-      def basename(pth)
-        FasterPath.basename(pth)
-      end 
-    end 
+      def self.basename(pth, ext = '')
+        FasterPath.basename(pth, ext)
+      end if ENV['WITH_REGRESSION']
+
+      def self.extname(pth)
+        FasterPath.extname(pth)
+      end if ENV['WITH_REGRESSION']
+
+      def self.dirname(pth)
+        FasterPath.dirname(pth)
+      end if ENV['WITH_REGRESSION']
+    end
 
     ::Pathname.class_eval do
       def absolute?
@@ -24,11 +34,20 @@ module FasterPath
         FasterPath.relative?(@path)
       end
 
-     def add_trailing_separator(pth)
+      def add_trailing_separator(pth)
         FasterPath.add_trailing_separator(pth)
-     end
-     private :add_trailing_separator
+      end
+      private :add_trailing_separator
+
+      def has_trailing_separator?(pth)
+        FasterPath.has_trailing_separator?(pth)
+      end
+      private :has_trailing_separator?
+
+      def entries
+        FasterPath.entries(@path)
+      end if ENV['WITH_REGRESSION']
     end
+    "CAUTION: Monkey patching effects everything! Be very sure you want this!"
   end
 end
-

data/lib/faster_path/optional/refinements.rb

@@ -1,11 +1,21 @@
+require 'pathname'
+
 module FasterPath
   module RefineFile
     refine File do
-      def basename(pth)
-        FasterPath.basename(pth)
+      def self.basename(pth, ext = '')
+        FasterPath.basename(pth, ext)
+      end
+
+      def self.extname(pth)
+        FasterPath.extname(pth)
+      end
+
+      def self.dirname(pth)
+        FasterPath.dirname(pth)
       end
     end
-  end 
+  end
 
   module RefinePathname
     refine Pathname do
@@ -30,6 +40,14 @@ module FasterPath
         FasterPath.add_trailing_separator(pth)
       end
       private :add_trailing_separator
+
+      def has_trailing_separator?(pth)
+        FasterPath.has_trailing_separator?(pth)
+      end
+
+      def entries
+        FasterPath.entries(@path)
+      end if ENV['WITH_REGRESSION']
     end
   end
 end

data/lib/faster_path/version.rb

@@ -1,3 +1,3 @@
 module FasterPath
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 end

data/lib/faster_path.rb

@@ -3,6 +3,14 @@ require 'pathname'
 require "ffi"
 
 module FasterPath
+  def self.rust_arch_bits
+    Rust.rust_arch_bits
+  end
+
+  def self.ruby_arch_bits
+    1.size * 8
+  end
+
   # Spec to Pathname#absolute?
   def self.absolute?(pth)
     Rust.is_absolute(pth)
@@ -18,6 +26,10 @@ module FasterPath
     Rust.is_relative(pth)
   end
 
+  def self.dirname(pth)
+    Rust.dirname(pth)
+  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
@@ -33,12 +45,24 @@ module FasterPath
 
   def self.basename(pth, ext="")
     Rust.basename(pth, ext)
-  end 
+  end
 
   def self.add_trailing_separator(pth)
     Rust.add_trailing_separator(pth)
   end
 
+  def self.has_trailing_separator?(pth)
+    Rust.has_trailing_separator(pth)
+  end
+
+  def self.extname(pth)
+    Rust.extname(pth)
+  end
+
+  def self.entries(pth)
+    Array(Rust.entries(pth))
+  end
+
   # EXAMPLE
   #def self.one_and_two
   #  Rust.one_and_two.to_a
@@ -61,6 +85,7 @@ module FasterPath
       end
     end
 
+    attach_function :rust_arch_bits, [], :int32
     attach_function :is_absolute, [ :string ], :bool
     attach_function :is_directory, [ :string ], :bool
     attach_function :is_relative, [ :string ], :bool
@@ -71,6 +96,9 @@ module FasterPath
     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

data/src/basename.rs

@@ -1,86 +1,26 @@
-use std::path::MAIN_SEPARATOR;
 use libc::c_char;
-use std::ffi::{CStr,CString};
-use std::str;
+use std::ffi::{CStr, CString};
+use path_parsing::extract_last_path_segment;
 
-#[allow(dead_code)]
-fn rubyish_basename(string: &str, globish_string: &str) -> String {
-  let result = if globish_string == ".*" {
-    let base = string.rsplit_terminator(MAIN_SEPARATOR).nth(0).unwrap_or("");
-    let index = base.rfind(".");
-    let (first, _) = base.split_at(index.unwrap());
-    first
-  } else {
-    if &string[string.len()-globish_string.len()..] == globish_string {
-      &string[0..string.len()-globish_string.len()]
-    } else {
-      string
-    }.rsplit_terminator(MAIN_SEPARATOR).nth(0).unwrap_or("")
-  };
-  result.to_string()
-}
+#[no_mangle]
+pub extern "C" fn basename(c_pth: *const c_char, c_ext: *const c_char) -> *const c_char {
+  // TODO: rb_raise on type or encoding errors
+  // TODO: support objects that respond to `to_path`
+  if c_pth.is_null() || c_ext.is_null() {
+    return c_pth;
+  }
+  let pth = unsafe { CStr::from_ptr(c_pth) }.to_str().unwrap();
+  let ext = unsafe { CStr::from_ptr(c_ext) }.to_str().unwrap();
 
-#[test]
-fn it_chomps_strings_correctly(){
-  assert_eq!(rubyish_basename("","")                           , "");
-  assert_eq!(rubyish_basename("ruby","")                       , "ruby");
-  assert_eq!(rubyish_basename("ruby.rb",".rb")                 , "ruby");
-  assert_eq!(rubyish_basename("ruby.rb",".*")                  , "ruby");
-  assert_eq!(rubyish_basename(".ruby/ruby.rb",".rb")           , "ruby");
-  assert_eq!(rubyish_basename(".ruby/ruby.rb.swp",".rb")       , "ruby.rb.swp");
-  assert_eq!(rubyish_basename(".ruby/ruby.rb.swp",".swp")      , "ruby.rb");
-  assert_eq!(rubyish_basename(".ruby/ruby.rb.swp",".*")        , "ruby.rb");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp","")           , "asdf.rb.swp"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".*")        , "asdf.rb"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", "*")         , "asdf.rb.swp"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".")         , "asdf.rb.swp"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".*")        , "asdf.rb"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".rb")       , "asdf.rb.swp"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".swp")      , "asdf.rb"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".sw")       , "asdf.rb.swp"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".sw*")      , "asdf.rb.swp"); 
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".rb.s*")    , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".s*")       , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".s**")      , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".**")       , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".*")        , "asdf.rb");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".*.*")      , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".rb.swp")   , "asdf");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".rb.s*p")   , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".r*.s*p")   , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".r*.sw*p")  , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", ".r*b.sw*p") , "asdf.rb.swp");
-  assert_eq!(rubyish_basename("asdf/asdf.rb.swp", "rb.swp")    , "asdf.");
-}
+  let mut name = extract_last_path_segment(pth);
 
-#[no_mangle]
-pub extern fn basename(str_pth: *const c_char, comp_ext: *const c_char) -> *const c_char {
-  let c_str1 = unsafe {
-    if str_pth.is_null(){
-      return str_pth;
-    } 
-    CStr::from_ptr(str_pth)
-  };
-  let c_str2 = unsafe {
-    if comp_ext.is_null() {
-      return str_pth;
+  if ext == ".*" {
+    if let Some(dot_i) = name.rfind('.') {
+      name = &name[0..dot_i];
     }
-    CStr::from_ptr(comp_ext)
+  } else if name.ends_with(ext) {
+    name = &name[..name.len() - ext.len()];
   };
-  let string         = str::from_utf8(c_str1.to_bytes()).unwrap();
-  let globish_string = str::from_utf8(c_str2.to_bytes()).unwrap();
 
-  let result = if globish_string == ".*" {
-    let base = string.rsplit_terminator(MAIN_SEPARATOR).nth(0).unwrap_or("");
-    let index = base.rfind(".");
-    let (first, _) = base.split_at(index.unwrap());
-    first
-  } else {
-    if &string[string.len()-globish_string.len()..] == globish_string {
-      &string[0..string.len()-globish_string.len()]
-    } else {
-      string
-    }.rsplit_terminator(MAIN_SEPARATOR).nth(0).unwrap_or("")
-  };
-  CString::new(result).unwrap().into_raw()
+  CString::new(name).unwrap().into_raw()
 }

data/src/dirname.rs

@@ -1,30 +1,32 @@
-use std::path::{Path,MAIN_SEPARATOR};
+use std::path::MAIN_SEPARATOR;
 use libc::c_char;
-use std::ffi::{CStr,CString};
-use std::str;
+use std::ffi::{CStr, CString};
+use path_parsing::{last_sep_i, last_non_sep_i, last_non_sep_i_before};
 
 #[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();
-
+pub extern "C" fn dirname(path: *const c_char) -> *const c_char {
+  if path.is_null() {
+    return path
+  }
+  let r_str = unsafe { CStr::from_ptr(path) }.to_str().unwrap();
   if r_str.is_empty() {
-    return string
+    return CString::new(".").unwrap().into_raw();
   }
-
-  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)
+  let non_sep_i = last_non_sep_i(r_str);
+  if non_sep_i == -1 {
+    return CString::new(MAIN_SEPARATOR.to_string()).unwrap().into_raw();
+  }
+  let sep_i = last_sep_i(r_str, non_sep_i);
+  if sep_i == -1 {
+    return CString::new(".").unwrap().into_raw();
+  }
+  if sep_i == 0 {
+    return CString::new(MAIN_SEPARATOR.to_string()).unwrap().into_raw();
+  }
+  let non_sep_i2 = last_non_sep_i_before(r_str, sep_i);
+  if non_sep_i2 != -1 {
+    return CString::new(&r_str[..(non_sep_i2 + 1) as usize]).unwrap().into_raw();
   } else {
-    format!("{}", path.to_str().unwrap())
-  };
-
-  let output = CString::new(out_str).unwrap();
-  output.into_raw()
+    return CString::new(MAIN_SEPARATOR.to_string()).unwrap().into_raw();
+  }
 }

data/src/entries.rs

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

@@ -0,0 +1,20 @@
+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());
+
+  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()
+    }
+  }
+
+  CString::new("").unwrap().into_raw()
+}

data/src/has_trailing_separator.rs

@@ -0,0 +1,27 @@
+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,19 +1,17 @@
 use libc::c_char;
 use std::ffi::{CStr};
-use std::str;
 use std::path::MAIN_SEPARATOR;
 
 
 #[no_mangle]
-pub extern fn is_absolute(string: *const c_char) -> bool {
-  let c_str = unsafe {
-    if string.is_null() {
-      return false;
-    }
-    CStr::from_ptr(string)
-  };
+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();
 
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
-
-  r_str.chars().next().unwrap_or("muffins".chars().next().unwrap()) == MAIN_SEPARATOR
+  match r_str.chars().next() {
+    Some(c) => c == MAIN_SEPARATOR,
+    None => false
+  }
 }

data/src/is_relative.rs

@@ -1,18 +1,16 @@
 use std::path::MAIN_SEPARATOR;
 use libc::c_char;
 use std::ffi::{CStr};
-use std::str;
 
 #[no_mangle]
-pub extern fn is_relative(string: *const c_char) -> bool {
-  let c_str = unsafe {
-    if string.is_null() {
-      return false;
-    }
-    CStr::from_ptr(string)
-  };
+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();
 
-  let r_str = str::from_utf8(c_str.to_bytes()).unwrap_or("");
-
-  r_str.chars().next().unwrap_or("muffins".chars().next().unwrap()) != MAIN_SEPARATOR
+  match r_str.chars().next() {
+    Some(c) => c != MAIN_SEPARATOR,
+    None => true
+  }
 }

data/src/lib.rs

@@ -18,6 +18,11 @@ pub mod dirname;
 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;
+pub mod rust_arch_bits;
+mod path_parsing;
 
 // EXAMPLE
 //

data/src/path_parsing.rs

@@ -0,0 +1,55 @@
+use std::path::MAIN_SEPARATOR;
+
+static SEP: u8 = MAIN_SEPARATOR as u8;
+
+pub fn extract_last_path_segment(path: &str) -> &str {
+  // 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.
+  // See src/benches/path_parsing.rs for benchmarks of different approaches.
+  let ptr = path.as_ptr();
+  let mut i = path.len() as isize - 1;
+  while i >= 0 {
+    let c = unsafe { *ptr.offset(i) };
+    if c != SEP { break; };
+    i -= 1;
+  }
+  let end = (i + 1) as usize;
+  while i >= 0 {
+    let c = unsafe { *ptr.offset(i) };
+    if c == SEP {
+      return &path[(i + 1) as usize..end];
+    };
+    i -= 1;
+  }
+  &path[..end]
+}
+
+
+// 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 preceding a MAIN_SEPARATOR before the given end offset.
+pub fn last_non_sep_i_before(path: &str, end: isize) -> isize {
+  let ptr = path.as_ptr();
+  let mut i = end;
+  while i >= 0 {
+    if unsafe { *ptr.offset(i) } != SEP { break; };
+    i -= 1;
+  }
+  i
+}
+
+// Returns the byte offset of the last MAIN_SEPARATOR before the given end offset.
+pub fn last_sep_i(path: &str, end: isize) -> isize {
+  let ptr = path.as_ptr();
+  let mut i = end - 1;
+  while i >= 0 {
+    if unsafe { *ptr.offset(i) } == SEP {
+      return i;
+    };
+    i -= 1;
+  }
+  -1
+}

data/src/ruby_array.rs

@@ -9,10 +9,10 @@ pub struct RubyArray {
 
 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 
+  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/rust_arch_bits.rs

@@ -0,0 +1,11 @@
+#[no_mangle]
+pub extern fn rust_arch_bits() -> i32 {
+  use std::mem::size_of;
+  let s = size_of::<usize>() * 8;
+  s as i32
+}
+
+#[test]
+fn it_is_32_or_64(){
+  assert!(rust_arch_bits() == 32 || rust_arch_bits() == 64);
+}

metadata

@@ -1,85 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2016-06-20 00:00:00.000000000 Z
+date: 2017-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ffi
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
-  type: :development
+        version: '12.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
-  name: method_source
+  name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
-  type: :development
+        version: '1.9'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: '1.9'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: method_source
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.1'
+        version: 0.8.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.1'
+        version: 0.8.2
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.8'
+        version: '5.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.8'
+        version: '5.10'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.5
+- !ruby/object:Gem::Dependency
+  name: stop_watch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: gruff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
 description: FasterPath is a reimplementation of Pathname for better performance.
 email:
 - 6ftdan@gmail.com
@@ -116,8 +144,6 @@ extensions:
 - ext/faster_path/extconf.rb
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
 - Cargo.lock
 - Cargo.toml
 - Gemfile
@@ -138,13 +164,18 @@ files:
 - src/both_are_blank.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/ruby_array.rs
 - src/ruby_string.rs
+- src/rust_arch_bits.rs
 homepage: https://github.com/danielpclark/faster_path
 licenses:
 - MIT OR Apache-2.0
@@ -165,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Reimplementation of Pathname for better performance

data/.gitignore

@@ -1,13 +0,0 @@
-/.bundle/
-/target/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-mkmf.log
-**/*.swp
-**/*.gem

data/.travis.yml

@@ -1,13 +0,0 @@
-sudo: true
-language: ruby
-rvm:
-  - 2.2.5
-  - 2.3.1
-env:
-  - TEST_MONKEYPATCHES=true
-  - TEST_MONKEYPATCHES=false
-before_install: 
-  - gem install bundler -v 1.12.5
-  - curl -sSf https://static.rust-lang.org/rustup.sh | sudo sh -s -- --channel=nightly
-  - bundle && bundle exec rake build_src && rake clean_src
-script: bundle exec rake test