faster_path 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d4375a359961afcc5baa61ac3c67569797e7f2f
-  data.tar.gz: b73c128d729d3fd37d5b125f584149466463a83b
+  metadata.gz: 8487e703f71a357f9d42a04c8f4ba2b98291bad4
+  data.tar.gz: 4c2c24ac1f470bfddbae8ccbfec0447961476e07
 SHA512:
-  metadata.gz: 42ab2f7cf2f3d45acf871b1169722905bc7bc7081048fc8ec23d74f5163dc4a25c65247c01ca97edd9cb2202886e8a482a9c40518301a59a216c58ed76125ccd
-  data.tar.gz: 1800e1268585ef4970508199ea494be7aaf5382229dc7d4f1f5486bda8b94c3576144f5afb9783400a555509b8ac485a5d7e1a924049e9baa46ccb8470053958
+  metadata.gz: 57e7745e69f3f30b32981731c250ffa001e4f4f58b5a4b44a0b6558ea786a0a741dc0ce225c959998055ed99c8070dcc78f995ec3c3bb538258cee9429bb71bc
+  data.tar.gz: b30307165e8fbdee36a2dd62bf92618af2f062d8bd93d94c4324c650d6c282fc45778508930d77e2f991a6a998ba6281dad53a742dca4c45751d346e42b3714f

data/Cargo.lock

@@ -1,20 +1,26 @@
-[root]
+[[package]]
+name = "array_tool"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
 name = "faster_path"
 version = "0.0.1"
 dependencies = [
  "array_tool 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "ruby-sys 0.2.20 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "ruru 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
-name = "array_tool"
-version = "0.4.1"
+name = "lazy_static"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "lazy_static"
-version = "0.2.8"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -22,6 +28,14 @@ name = "libc"
 version = "0.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "memchr"
+version = "2.0.1"
+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 = "ruby-sys"
 version = "0.2.20"
@@ -42,6 +56,8 @@ dependencies = [
 [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 lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c8f31047daa365f19be14b47c29df4f7c3b581832407daabe6ae77397619237d"
 "checksum libc 0.2.30 (registry+https://github.com/rust-lang/crates.io-index)" = "2370ca07ec338939e356443dac2296f581453c35fe1e3a3ed06023c49435f915"
+"checksum memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "796fba70e76612589ed2ce7f45282f5af869e0fdd7cc6199fa1aa1f1d591ba9d"
 "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,6 +13,7 @@ name = "faster_path"
 crate-type = ["dylib"]
 
 [dependencies]
-ruby-sys = "0.2.20"
 ruru = "0.9.3"
 array_tool = "0.4.1"
+lazy_static = "1.0"
+memchr = "2.0.1"

data/MIT-LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Daniel P. Clark
+Copyright (c) 2016-2017 Daniel P. Clark & FasterPath Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -3,7 +3,7 @@
 [![TravisCI Build Status](https://travis-ci.org/danielpclark/faster_path.svg?branch=master)](https://travis-ci.org/danielpclark/faster_path)
 [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/10ul0gk3cwhlt2lj/branch/master?svg=true)](https://ci.appveyor.com/project/danielpclark/faster-path/branch/master)
 [![Latest Tag](https://img.shields.io/github/tag/danielpclark/faster_path.svg)](https://github.com/danielpclark/faster_path/tags)
-[![Commits Since Last Release](https://img.shields.io/github/commits-since/danielpclark/faster_path/v0.2.1.svg)](https://github.com/danielpclark/faster_path/pulse)
+[![Commits Since Last Release](https://img.shields.io/github/commits-since/danielpclark/faster_path/v0.2.3.svg)](https://github.com/danielpclark/faster_path/pulse)
 [![Binary Release](https://img.shields.io/github/release/danielpclark/faster_path.svg)](https://github.com/danielpclark/faster_path/releases)
 [![Coverage Status](https://coveralls.io/repos/github/danielpclark/faster_path/badge.svg)](https://coveralls.io/github/danielpclark/faster_path)
 [![Inline docs](http://inch-ci.org/github/danielpclark/faster_path.svg?branch=master)](http://inch-ci.org/github/danielpclark/faster_path)
@@ -113,7 +113,7 @@ curl -sSf https://static.rust-lang.org/rustup.sh | sh
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'faster_path', '~> 0.1.13'
+gem 'faster_path', '~> 0.2.3'
 ```
 
 And then execute:
@@ -124,8 +124,6 @@ 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.
@@ -142,12 +140,13 @@ Current methods implemented:
 |---|---|:---:|
 | `FasterPath.absolute?` | `Pathname#absolute?` | 88.5% |
 | `FasterPath.add_trailing_separator` | `Pathname#add_trailing_separator` | 31.1% |
-| `FasterPath.children` | `Pathname#children` | 13.6% |
-| `FasterPath.chop_basename` | `Pathname#chop_basename` | 55.8% |
+| `FasterPath.children` | `Pathname#children` | 14.6% |
+| `FasterPath.chop_basename` | `Pathname#chop_basename` | 56.7% |
+| `FasterPath.cleanpath_aggressive` | `Pathname#cleanpath_aggressive` | 69.8% |
 | `FasterPath.directory?` | `Pathname#directory?` | 12.7% |
 | `FasterPath.entries` | `Pathname#entries` | 7.7% |
 | `FasterPath.has_trailing_separator?` | `Pathname#has_trailing_separator` | 59.2% |
-| `FasterPath.plus` | `Pathname#plus` | 77.5% |
+| `FasterPath.plus` | `Pathname#plus` | 77.9% |
 | `FasterPath.relative?` | `Pathname#relative?` | 83.1% |
 
 You may choose to use the methods directly, or scope change to rewrite behavior on the

data/Rakefile

@@ -24,6 +24,13 @@ task :sysinfo do
   end
 end
 
+desc "Generate Contriburs.md Manifest"
+task :contrib do
+  puts "Generating Contriburs.md Manifest"
+  exec "printf '# Contributors\n
+' > Contributors.md;git shortlog -s -n -e | sed 's/^......./- /' >> Contributors.md"
+end
+
 desc "Add libruby to deps"
 task :libruby_release do
   filename = RbConfig::CONFIG["LIBRUBY_ALIASES"].split(" ").first
@@ -98,21 +105,31 @@ Rake::TestTask.new(minitest: :build_lib) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task test: [:cargo, :minitest, :lint, :pbench] do |_t|
+task :init_mspec do |_t|
+  if Dir.open('spec/mspec').entries.-([".", ".."]).empty?
+    `git submodule init`
+    `git submodule update`
+  end
+end
+
+task test: [:cargo, :minitest, :lint, :pbench, :init_mspec] do |_t|
   exec 'spec/mspec/bin/mspec --format spec core/file/basename core/file/extname core/file/dirname library/pathname'
 end
 
 desc "Full mspec results w/o encoding"
-task :mspec_full do
+task mspec_full: :init_mspec do
   exec %(bash -c "TEST_MONKEYPATCHES=true WITH_REGRESSION=true spec/mspec/bin/mspec --format spec core/file/basename core/file/extname core/file/dirname library/pathname")
 end
 
 desc "Full mspec results w/ encoding"
-task :mspec_encoding_full do
+task mspec_encoding_full: :init_mspec do
   exec %(bash -c "ENCODING=1 TEST_MONKEYPATCHES=true WITH_REGRESSION=true mspec --format spec core/file/basename core/file/extname core/file/dirname library/pathname")
 end
 
 Rake::TestTask.new(bench: :build_lib) do |t|
+  if ENV['GRAPH']
+    `bundle install`
+  end
   t.libs = %w[lib test]
   t.pattern = 'test/**/*_benchmark.rb'
 end

data/faster_path.gemspec

@@ -31,9 +31,9 @@ Gem::Specification.new do |spec|
   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.9"
-  spec.add_development_dependency "rubocop", "~> 0.47"
-  unless ENV['CI']
-    spec.add_development_dependency "stop_watch", "~> 1.0.0"
+  spec.add_development_dependency "rubocop", "~> 0.51"
+  spec.add_development_dependency "stop_watch", "~> 1.0.0"
+  if !ENV['CI'] && ENV['GRAPH']
     spec.add_development_dependency "gruff", "~> 0.7.0"
   end
 end

data/lib/faster_path.rb

@@ -15,20 +15,21 @@ module FasterPath
     call
 
   FasterPathname::Public.class_eval do
-    private :absolute?
-    private :add_trailing_separator
-    private :basename
-    private :children # String results
-    private :children_compat # wrap Pathname on each
-    private :chop_basename
-    private :directory?
-    private :dirname
-    private :entries # String results
-    private :entries_compat # wrap Pathname on each
-    private :extname
-    private :has_trailing_separator?
-    private :plus
-    private :relative?
+    private_class_method :absolute?
+    private_class_method :add_trailing_separator
+    private_class_method :basename
+    private_class_method :children # String results
+    private_class_method :children_compat # wrap Pathname on each
+    private_class_method :chop_basename
+    private_class_method :cleanpath_aggressive
+    private_class_method :directory?
+    private_class_method :dirname
+    private_class_method :entries # String results
+    private_class_method :entries_compat # wrap Pathname on each
+    private_class_method :extname
+    private_class_method :has_trailing_separator?
+    private_class_method :plus
+    private_class_method :relative?
   end
 
   FasterPathname.class_eval do
@@ -60,11 +61,11 @@ module FasterPath
   end
 
   def self.absolute?(pth)
-    FasterPathname::Public.allocate.send(:absolute?, pth)
+    FasterPathname::Public.send(:absolute?, pth)
   end
 
   def self.add_trailing_separator(pth)
-    FasterPathname::Public.allocate.send(:add_trailing_separator, pth)
+    FasterPathname::Public.send(:add_trailing_separator, pth)
   end
 
   def self.blank?(str)
@@ -72,44 +73,48 @@ module FasterPath
   end
 
   def self.basename(pth, ext="")
-    FasterPathname::Public.allocate.send(:basename, pth, ext)
+    FasterPathname::Public.send(:basename, pth, ext)
   end
 
   def self.children(pth, with_directory=true)
-    FasterPathname::Public.allocate.send(:children, pth, with_directory)
+    FasterPathname::Public.send(:children, pth, with_directory)
   end
 
   def self.chop_basename(pth)
-    result = FasterPathname::Public.allocate.send(:chop_basename, pth)
+    result = FasterPathname::Public.send(:chop_basename, pth)
     result unless result.empty?
   end
 
+  def self.cleanpath_aggressive(pth)
+    FasterPathname::Public.send(:cleanpath_aggressive, pth)
+  end
+
   def self.directory?(pth)
-    FasterPathname::Public.allocate.send(:directory?, pth)
+    FasterPathname::Public.send(:directory?, pth)
   end
 
   def self.dirname(pth)
-    FasterPathname::Public.allocate.send(:dirname, pth)
+    FasterPathname::Public.send(:dirname, pth)
   end
 
   def self.entries(pth)
-    FasterPathname::Public.allocate.send(:entries, pth)
+    FasterPathname::Public.send(:entries, pth)
   end
 
   def self.extname(pth)
-    FasterPathname::Public.allocate.send(:extname, pth)
+    FasterPathname::Public.send(:extname, pth)
   end
 
   def self.has_trailing_separator?(pth)
-    FasterPathname::Public.allocate.send(:has_trailing_separator?, pth)
+    FasterPathname::Public.send(:has_trailing_separator?, pth)
   end
 
   def self.plus(pth, pth2)
-    FasterPathname::Public.allocate.send(:plus, pth, pth2)
+    FasterPathname::Public.send(:plus, pth, pth2)
   end
 
   def self.relative?(pth)
-    FasterPathname::Public.allocate.send(:relative?, pth)
+    FasterPathname::Public.send(:relative?, pth)
   end
 
   module Rust

data/lib/faster_path/optional/monkeypatches.rb

@@ -25,6 +25,8 @@ module FasterPath
         end
       end
     end
+
+    # rubocop:disable Metrics/MethodLength
     def self._ruby_library_pathname!
       ::Pathname.class_eval do
         def absolute?
@@ -46,6 +48,11 @@ module FasterPath
         end
         private :chop_basename
 
+        def cleanpath_aggressive
+          Pathname.new(FasterPath.cleanpath_aggressive(@path))
+        end
+        private :cleanpath_aggressive
+
         def directory?
           FasterPath.directory?(@path)
         end

data/lib/faster_path/optional/refinements.rb

@@ -44,6 +44,11 @@ module FasterPath
       end
       private :chop_basename
 
+      def cleanpath_aggressive
+        Pathname.new(FasterPath.cleanpath_aggressive(@path))
+      end
+      private :cleanpath_aggressive
+
       def directory?
         FasterPath.directory?(@path)
       end

data/lib/faster_path/version.rb

@@ -1,3 +1,3 @@
 module FasterPath
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/src/basename.rs

@@ -1,23 +1,29 @@
-extern crate array_tool;
-use path_parsing::extract_last_path_segment;
-use self::array_tool::string::Squeeze;
+extern crate memchr;
+use self::memchr::memrchr;
+use path_parsing::{SEP, last_non_sep_i};
 
-pub fn basename(pth: &str, ext: &str) -> String {
-  // Known edge case
-  match &pth.squeeze("/")[..] {
-    "/" => { return "/".to_string() }
-    _ => {}
+pub fn basename<'a>(pth: &'a str, ext: &str) -> &'a str {
+  let name_end = (last_non_sep_i(pth) + 1) as usize;
+  // Known edge case, all '/'.
+  if !pth.is_empty() && name_end == 0 {
+    return &pth[..1];
   }
-
-  let mut name = extract_last_path_segment(pth);
-
+  let name_start = match memrchr(SEP, &pth.as_bytes()[..name_end]) {
+    Some(i) => i + 1,
+    _ => 0
+  };
+  let mut name = &pth[name_start..name_end];
   if ext == ".*" {
-    if let Some(dot_i) = name.rfind('.') {
-      name = &name[0..dot_i];
+    if let Some(dot_i) = memrchr('.' as u8, name.as_bytes()) {
+      name = &name[..dot_i];
     }
   } else if name.ends_with(ext) {
     name = &name[..name.len() - ext.len()];
   };
-  name.to_string()
+  name
 }
 
+#[test]
+fn edge_case_all_seps() {
+  assert_eq!("/", basename("///", ".*"));
+}

data/src/cleanpath_aggressive.rs

@@ -0,0 +1,104 @@
+use prepend_prefix::prepend_prefix;
+use basename::basename;
+use chop_basename::chop_basename;
+extern crate array_tool;
+use self::array_tool::vec::Shift;
+use std::path::MAIN_SEPARATOR;
+
+pub fn cleanpath_aggressive(path: &str) -> String {
+  let sep = MAIN_SEPARATOR.to_string();
+  let mut names: Vec<String> = vec![];
+  let mut pre = path.to_string();
+  loop {
+    match chop_basename(&pre) {
+      Some((ref p, ref base)) => {
+        pre = p.to_string();
+        match base.as_ref() {
+          "." => {},
+          ".." => names.unshift(base.to_string()),
+          _ => {
+            if names.first() == Some(&"..".to_string()) {
+              names.shift();
+            } else {
+              names.unshift(base.to_string())
+            }
+          }
+
+        }
+      },
+      None => break,
+    }
+  }
+  // // Windows Feature
+  //
+  // ```ruby
+  // pre.tr!(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
+  // ```
+  //
+  if basename(&pre, "").contains(&sep) {
+    loop {
+      if names.first() == Some(&"..".to_string()) {
+        let _ = names.shift();
+      } else {
+        break
+      }
+    }
+  }
+  prepend_prefix(&pre, &names.join(&sep)[..])
+}
+
+#[test]
+fn it_aggressively_cleans_the_path() {
+  assert_eq!(cleanpath_aggressive("/")                     ,       "/");
+  assert_eq!(cleanpath_aggressive("")                      ,       ".");
+  assert_eq!(cleanpath_aggressive(".")                     ,       ".");
+  assert_eq!(cleanpath_aggressive("..")                    ,      "..");
+  assert_eq!(cleanpath_aggressive("a")                     ,       "a");
+  assert_eq!(cleanpath_aggressive("/.")                    ,       "/");
+  assert_eq!(cleanpath_aggressive("/..")                   ,       "/");
+  assert_eq!(cleanpath_aggressive("/a")                    ,      "/a");
+  assert_eq!(cleanpath_aggressive("./")                    ,       ".");
+  assert_eq!(cleanpath_aggressive("../")                   ,      "..");
+  assert_eq!(cleanpath_aggressive("a/")                    ,       "a");
+  assert_eq!(cleanpath_aggressive("a//b")                  ,     "a/b");
+  assert_eq!(cleanpath_aggressive("a/.")                   ,       "a");
+  assert_eq!(cleanpath_aggressive("a/./")                  ,       "a");
+  assert_eq!(cleanpath_aggressive("a/..")                  ,       ".");
+  assert_eq!(cleanpath_aggressive("a/../")                 ,       ".");
+  assert_eq!(cleanpath_aggressive("/a/.")                  ,      "/a");
+  assert_eq!(cleanpath_aggressive("./..")                  ,      "..");
+  assert_eq!(cleanpath_aggressive("../.")                  ,      "..");
+  assert_eq!(cleanpath_aggressive("./../")                 ,      "..");
+  assert_eq!(cleanpath_aggressive(".././")                 ,      "..");
+  assert_eq!(cleanpath_aggressive("/./..")                 ,       "/");
+  assert_eq!(cleanpath_aggressive("/../.")                 ,       "/");
+  assert_eq!(cleanpath_aggressive("/./../")                ,       "/");
+  assert_eq!(cleanpath_aggressive("/.././")                ,       "/");
+  assert_eq!(cleanpath_aggressive("a/b/c")                 ,   "a/b/c");
+  assert_eq!(cleanpath_aggressive("./b/c")                 ,     "b/c");
+  assert_eq!(cleanpath_aggressive("a/./c")                 ,     "a/c");
+  assert_eq!(cleanpath_aggressive("a/b/.")                 ,     "a/b");
+  assert_eq!(cleanpath_aggressive("a/../.")                ,       ".");
+  assert_eq!(cleanpath_aggressive("/../.././../a")         ,      "/a");
+  assert_eq!(cleanpath_aggressive("a/b/../../../../c/../d"), "../../d");
+}
+
+// Future Windows Support
+//
+// DOSISH = File::ALT_SEPARATOR != nil
+// DOSISH_DRIVE_LETTER = File.dirname("A:") == "A:."
+// DOSISH_UNC = File.dirname("//") == "//"
+//
+// if DOSISH_UNC
+//   defassert(:cleanpath_aggressive, '//a/b/c', '//a/b/c/')
+// else
+//   defassert(:cleanpath_aggressive, '/',       '///')
+//   defassert(:cleanpath_aggressive, '/a',      '///a')
+//   defassert(:cleanpath_aggressive, '/',       '///..')
+//   defassert(:cleanpath_aggressive, '/',       '///.')
+//   defassert(:cleanpath_aggressive, '/',       '///a/../..')
+// end
+//
+// if DOSISH
+//   defassert(:cleanpath_aggressive, 'c:/foo/bar', 'c:\\foo\\bar')
+// end

data/src/dirname.rs

@@ -1,27 +1,22 @@
-use std::path::MAIN_SEPARATOR;
-use path_parsing::{last_sep_i, last_non_sep_i, last_non_sep_i_before};
+extern crate memchr;
+use self::memchr::memrchr;
+use path_parsing::{SEP, SEP_STR, 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();
+pub fn dirname(path: &str) -> &str {
+  if path.is_empty() { return "."; }
+  let non_sep_i = last_non_sep_i(path);
+  if non_sep_i == -1 { return *SEP_STR; }
+  return match memrchr(SEP, &path.as_bytes()[..non_sep_i as usize]) {
+    None => ".",
+    Some(0) => *SEP_STR,
+    Some(sep_i) => {
+      let non_sep_i2 = last_non_sep_i_before(path, sep_i as isize);
+      if non_sep_i2 != -1 {
+        &path[..(non_sep_i2 + 1) as usize]
+      } else {
+        *SEP_STR
+      }
+    }
   }
 }
 

data/src/extname.rs

@@ -1,13 +1,13 @@
 use path_parsing::extract_last_path_segment;
 
-pub fn extname(pth: &str) -> String {
+pub fn extname(pth: &str) -> &str {
   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 String::from(&name[dot_i..])
+      return &name[dot_i..]
     }
   }
 
-  String::from("")
+  ""
 }

data/src/helpers.rs

@@ -1,19 +1,7 @@
-extern crate ruby_sys;
-use self::ruby_sys::string;
-
-use ruru::{AnyObject, Class};
-use ruru::types::{c_char, c_long, Value};
-
-#[inline]
-pub fn str_to_value(string: &str) -> Value {
-  let str_ptr = string.as_ptr() as *const c_char;
-  let len = string.len() as c_long;
-
-  unsafe { string::rb_str_new(str_ptr, len) }
-}
+use ruru::{AnyObject, Class, Object, RString};
 
 pub fn str_to_any_obj(str_var: &str) -> AnyObject {
-  AnyObject::from(str_to_value(str_var))
+  RString::new(str_var).to_any_object()
 }
 
 pub fn class_new(klass: &str, params: Vec<AnyObject>) -> AnyObject {

data/src/lib.rs

@@ -7,15 +7,20 @@
 #[macro_use]
 extern crate ruru;
 
+#[macro_use]
+extern crate lazy_static;
+
 class!(FasterPathname);
 
 mod helpers;
 mod pathname;
 mod basename;
 mod chop_basename;
+mod cleanpath_aggressive;
 mod dirname;
 mod extname;
 mod plus;
+mod prepend_prefix;
 pub mod rust_arch_bits;
 mod path_parsing;
 
@@ -56,7 +61,9 @@ methods!(
   // fn r_cleanpath(){ pub_cleanpath(r_to_path()) }
   // fn pub_cleanpath(pth: RString){}
 
-  // fn r_cleanpath_aggressive(pth: RString){}
+  fn pub_cleanpath_aggressive(pth: RString) -> RString {
+    pathname::pn_cleanpath_aggressive(pth)
+  }
 
   // fn r_cleanpath_conservative(pth: RString){}
 
@@ -95,7 +102,7 @@ methods!(
 
   // fn r_find(ignore_error: Boolean){}
   // fn pub_find(pth: RString ,ignore_error: Boolean){}
-  
+
   fn pub_has_trailing_separator(pth: RString) -> Boolean {
     pathname::pn_has_trailing_separator(pth)
   }
@@ -147,19 +154,20 @@ pub extern "C" fn Init_faster_pathname(){
   // * methods for refinements, monkeypatching
   // * methods that need all values as parameters
   Class::from_existing("FasterPathname").get_nested_class("Public").define(|itself| {
-    itself.def("absolute?", pub_is_absolute);
-    itself.def("add_trailing_separator", pub_add_trailing_separator);
-    itself.def("basename", pub_basename);
-    itself.def("children", pub_children);
-    itself.def("children_compat", pub_children_compat);
-    itself.def("chop_basename", pub_chop_basename);
-    itself.def("directory?", pub_is_directory);
-    itself.def("dirname", pub_dirname);
-    itself.def("entries", pub_entries);
-    itself.def("entries_compat", pub_entries_compat);
-    itself.def("extname", pub_extname);
-    itself.def("has_trailing_separator?", pub_has_trailing_separator);
-    itself.def("plus", pub_plus);
-    itself.def("relative?", pub_is_relative);
+    itself.def_self("absolute?", pub_is_absolute);
+    itself.def_self("add_trailing_separator", pub_add_trailing_separator);
+    itself.def_self("basename", pub_basename);
+    itself.def_self("children", pub_children);
+    itself.def_self("children_compat", pub_children_compat);
+    itself.def_self("chop_basename", pub_chop_basename);
+    itself.def_self("cleanpath_aggressive", pub_cleanpath_aggressive);
+    itself.def_self("directory?", pub_is_directory);
+    itself.def_self("dirname", pub_dirname);
+    itself.def_self("entries", pub_entries);
+    itself.def_self("entries_compat", pub_entries_compat);
+    itself.def_self("extname", pub_extname);
+    itself.def_self("has_trailing_separator?", pub_has_trailing_separator);
+    itself.def_self("plus", pub_plus);
+    itself.def_self("relative?", pub_is_relative);
   });
 }

data/src/path_parsing.rs

@@ -1,30 +1,18 @@
+extern crate memchr;
+use self::memchr::memrchr;
 use std::path::MAIN_SEPARATOR;
+use std::str;
 
-static SEP: u8 = MAIN_SEPARATOR as u8;
+pub const SEP: u8 = MAIN_SEPARATOR as u8;
+lazy_static! {
+  pub static ref SEP_STR: &'static str = str::from_utf8(&[SEP]).unwrap();
+}
 
 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]
+  let end = (last_non_sep_i(path) + 1) as usize;
+  &path[memrchr(SEP, &path.as_bytes()[..end]).unwrap_or(0)..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)
@@ -32,6 +20,8 @@ pub fn last_non_sep_i(path: &str) -> isize {
 
 // 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 {
+  // 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.
   let ptr = path.as_ptr();
   let mut i = end;
   while i >= 0 {
@@ -40,16 +30,3 @@ pub fn last_non_sep_i_before(path: &str, end: isize) -> isize {
   }
   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/pathname.rs

@@ -1,6 +1,7 @@
 use helpers::*;
 use basename;
 use chop_basename;
+use cleanpath_aggressive;
 use dirname;
 use extname;
 use plus;
@@ -33,10 +34,10 @@ pub fn pn_is_absolute(pth: MaybeString) -> Boolean {
 
 pub fn pn_basename(pth: MaybeString, ext: MaybeString) -> RString {
   RString::new(
-    &basename::basename(
+    basename::basename(
       pth.ok().unwrap_or(RString::new("")).to_str(),
       ext.ok().unwrap_or(RString::new("")).to_str()
-    )[..]
+    )
   )
 }
 
@@ -115,7 +116,13 @@ pub fn pn_chop_basename(pth: MaybeString) -> Array {
 
 // pub fn pn_cleanpath(pth: MaybeString){}
 
-// pub fn pn_cleanpath_aggressive(pth: MaybeString){}
+pub fn pn_cleanpath_aggressive(pth: MaybeString) -> RString {
+  let path = cleanpath_aggressive::cleanpath_aggressive(
+    pth.ok().unwrap_or(RString::new("")).to_str()
+  );
+
+  RString::new(&path)
+}
 
 // pub fn pn_cleanpath_conservative(pth: MaybeString){}
 
@@ -133,9 +140,9 @@ pub fn pn_is_directory(pth: MaybeString) -> Boolean {
 
 pub fn pn_dirname(pth: MaybeString) -> RString {
   RString::new(
-    &dirname::dirname(
+    dirname::dirname(
       pth.ok().unwrap_or(RString::new("")).to_str()
-    )[..]
+    )
   )
 }
 
@@ -177,7 +184,7 @@ pub fn pn_entries_compat(pth: MaybeString) -> Array {
 
 pub fn pn_extname(pth: MaybeString) -> RString {
   RString::new(
-    &extname::extname(pth.ok().unwrap_or(RString::new("")).to_str())[..]
+    extname::extname(pth.ok().unwrap_or(RString::new("")).to_str())
   )
 }
 
@@ -228,4 +235,3 @@ pub fn pn_is_relative(pth: MaybeString) -> Boolean {
 // pub fn pn_rmtree(pth: MaybeString) -> NilClass {
 //   NilClass::new()
 // }
-

data/src/plus.rs

@@ -73,7 +73,7 @@ pub fn plus_paths(path1: &str, path2: &str) -> String {
     if r1 {
       result = prefix1.to_string();
     } else {
-      result = dirname(&prefix1[..]);
+      result = dirname(&prefix1[..]).to_string();
     }
   }
 

data/src/prepend_prefix.rs

@@ -0,0 +1,18 @@
+use dirname::dirname;
+use basename::basename;
+use std::path::MAIN_SEPARATOR as SEP;
+
+pub fn prepend_prefix(prefix: &str, relpath: &str) -> String {
+  let mut prefix: String = prefix.to_string();
+  if relpath.is_empty() {
+    dirname(&prefix).to_string()
+  } else if prefix.contains(&SEP.to_string()[..]) {
+    prefix = dirname(&prefix).to_string();
+    if basename(&format!("{}{}", &prefix, "a"), "") != "a" {
+      prefix = format!("{}{}", prefix, &SEP);
+    }
+    format!("{}{}", prefix, relpath)
+  } else {
+    format!("{}{}", prefix, relpath)
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-25 00:00:00.000000000 Z
+date: 2018-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: '0.51'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: '0.51'
 - !ruby/object:Gem::Dependency
   name: stop_watch
   requirement: !ruby/object:Gem::Requirement
@@ -136,20 +136,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.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
@@ -175,6 +161,7 @@ files:
 - lib/faster_path/version.rb
 - src/basename.rs
 - src/chop_basename.rs
+- src/cleanpath_aggressive.rs
 - src/dirname.rs
 - src/extname.rs
 - src/helpers.rs
@@ -182,6 +169,7 @@ files:
 - src/path_parsing.rs
 - src/pathname.rs
 - src/plus.rs
+- src/prepend_prefix.rs
 - src/rust_arch_bits.rs
 homepage: https://github.com/danielpclark/faster_path
 licenses: