faster_path 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5bfc3ff4266b588930207d414eeb0eb1ae7b8d7
-  data.tar.gz: 58191c69400ca14fdbdd0ce4d5c8ed7666e9674e
+  metadata.gz: 8f1b4b37c294db2912d786c35de76f60cba0b6a9
+  data.tar.gz: 46af8f1bb6c06baed02866d6f9777bb9dfb6f1ff
 SHA512:
-  metadata.gz: af28e5efb74251311e18af3991b99d08550f40961116738641f39b1c883d4ac0248547563210cd32c67ff87705da21ef7de7a7fbf02783c66625867bec79b0d3
-  data.tar.gz: 763bc9c1199eec48b708f00e5f68d4dba2e110c17d587b627a6148cfd06f2a134ea1e9a5a3f7d2db8574cce5ee3de1438527496d5f0b72bd30a3c02fe0272d83
+  metadata.gz: c6d51a6c3a7796aa41063ee31a3c0f05c88df32350f5fbc2f0913553c9fdaf6ab5600475594d3e9dc3706df49785f5bfc0e0ed0de4b29d169e166abd1acf4f45
+  data.tar.gz: 96b16a98d9e807e33669956d6adb879f57d5e976def60c2d11502b9107a601bf793cfe75148f56e2e6c99b3b3af7745434e5c166d40c1b902b911efd797a0b65

data/Cargo.lock

@@ -2,20 +2,20 @@
 name = "faster_path"
 version = "0.0.1"
 dependencies = [
- "array_tool 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "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)",
 ]
 
 [[package]]
 name = "array_tool"
-version = "0.3.8"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "libc"
-version = "0.2.11"
+version = "0.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [metadata]
-"checksum array_tool 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "10ef6b307cf6a0a6c1a7e3dbb4e9315cc79d2e2d27c2d9674413738686b63e62"
-"checksum libc 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "c96061f0c8a2dc27482e394d82e23073569de41d73cd736672ccd3e5c7471bfd"
+"checksum array_tool 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1a07ccb27c611e5cda99e498e99ba71b3ecdb7db5df02096cef42a3df5b84542"
+"checksum libc 0.2.30 (registry+https://github.com/rust-lang/crates.io-index)" = "2370ca07ec338939e356443dac2296f581453c35fe1e3a3ed06023c49435f915"

data/Cargo.toml

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

data/Gemfile

@@ -5,11 +5,3 @@ source 'https://rubygems.org' do
     gem 'coveralls', require: false
   end
 end
-
-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

@@ -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.0'
+gem 'faster_path', '~> 0.1.13'
 ```
 
 And then execute:
@@ -143,7 +143,6 @@ Current methods implemented:
 | `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?` | 25.5% |
 | `FasterPath.add_trailing_separator` | `Pathname#add_trailing_separator` | 46.8% |
 | `FasterPath.has_trailing_separator?` | `Pathname#has_trailing_separator` | 61.2% |
@@ -169,9 +168,11 @@ require "faster_path/optional/monkeypatches"
 FasterPath.sledgehammer_everything!
 ```
 
-## Unstable optional bits
+## Optional Rust implementations
 
-**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.
+**These are stable, not performant, and not included in `File` by default.**
+
+These will **not** be included by default in monkey-patches.  Be cautious when using the `FasterPath::RefineFile` refinement.  To try them with monkeypatching use the environment flag of `WITH_REGRESSION`.  These methods are here to be improved upon.
 
 |FasterPath Implementation|Ruby Implementation|
 |---|---|
@@ -180,9 +181,7 @@ FasterPath.sledgehammer_everything!
 | `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=true TEST_MONKEYPATCHES=true` in your testing.  You can see the resulting failures currently on TravisCI under "Allow Failures".
+performance seems to vary based on CPU cache on possibly 64bit/32bit system environmnets.  When these methods were initially written, and somewhat simplistic, they were faster than the C implementations on `File`.  After the implementations have been perfected to match the behavior in Ruby they don't perform as well and are therefore not included by default when the monkey patch method `FasterPath.sledgehammer_everything!` is executed.  If you don't want to pass the `WITH_REGRESSION` environment variable you can put any turthy parameter on the monkey patch method to include it.
 
 ## Getting Started with Development
 

data/Rakefile

@@ -57,19 +57,24 @@ task :lint do
   puts
 end
 
+desc "Run Rust Tests"
+task :cargo do
+  sh "cargo test -- --nocapture"
+end
+
 Rake::TestTask.new(minitest: :build_lib) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task test: [:minitest, :lint] do |_t|
-  exec 'mspec --format spec core/file/basename core/file/extname core/file/dirname library/pathname'
+task test: [:cargo, :minitest, :lint] 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
-  exec %(bash -c "TEST_MONKEYPATCHES=true WITH_REGRESSION=true mspec --format spec core/file/basename core/file/extname core/file/dirname library/pathname")
+  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"

data/faster_path.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   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", "~> 0.1.0"
+    spec.add_development_dependency "stop_watch", "~> 1.0.0"
     spec.add_development_dependency "gruff", "~> 0.7.0"
   end
 end

data/lib/faster_path/optional/monkeypatches.rb

@@ -57,6 +57,11 @@ module FasterPath
         def entries
           FasterPath.entries(@path)
         end
+
+        def plus(pth, pth2)
+          FasterPath.plus(pth, pth2)
+        end
+        private :plus
       end
     end
   end

data/lib/faster_path/optional/refinements.rb

@@ -54,6 +54,11 @@ module FasterPath
       def entries
         FasterPath.entries(@path)
       end
+
+      def plus(pth, pth2)
+        FasterPath.plus(pth, pth2)
+      end
+      private :plus
     end
   end
 end

data/lib/faster_path/version.rb

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

data/lib/faster_path.rb

@@ -49,6 +49,10 @@ module FasterPath
     Rust.basename(pth, ext)
   end
 
+  def self.plus(pth, pth2)
+    Rust.plus(pth, pth2)
+  end
+
   def self.add_trailing_separator(pth)
     Rust.add_trailing_separator(pth)
   end
@@ -93,6 +97,7 @@ module FasterPath
     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

data/src/basename.rs

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

data/src/chop_basename.rs

@@ -0,0 +1,56 @@
+pub mod rust {
+  use std::path::MAIN_SEPARATOR;
+  use std::str;
+
+  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 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
+    };
+
+    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,7 +1,5 @@
-use std::path::MAIN_SEPARATOR;
 use libc::c_char;
 use std::ffi::{CStr, CString};
-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 {
@@ -9,24 +7,40 @@ pub extern "C" fn dirname(path: *const c_char) -> *const c_char {
     return path
   }
   let r_str = unsafe { CStr::from_ptr(path) }.to_str().unwrap();
-  if r_str.is_empty() {
-    return CString::new(".").unwrap().into_raw();
-  }
-  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 {
-    return CString::new(MAIN_SEPARATOR.to_string()).unwrap().into_raw();
+
+  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();
+    }
   }
 }
+
+#[test]
+fn returns_dot_for_empty_string(){
+  assert_eq!(rust::dirname(""), ".".to_string());
+}

data/src/lib.rs

@@ -14,7 +14,9 @@ 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;

data/src/plus.rs

@@ -0,0 +1,131 @@
+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 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 {
+  let mut prefix2 = path2.to_string();
+  let mut index_list2: Vec<usize> = vec![];
+  let mut basename_list2: Vec<String> = vec![];
+
+  loop {
+    match chop_basename(&prefix2[..]) {
+      None => { break },
+      Some((pfx2, basename2)) => {
+        prefix2 = pfx2.clone();
+        index_list2.unshift(pfx2.len());
+        basename_list2.unshift(basename2.to_owned());
+      },
+    }
+  }
+  if !prefix2.is_empty() {
+    return path2.to_string()
+  };
+
+  let mut prefix1 = path1.to_string();
+
+  loop {
+    while !basename_list2.is_empty() && basename_list2.first().unwrap() == "." {
+      index_list2.shift();
+      basename_list2.shift();
+    }
+    match chop_basename(&prefix1[..]) {
+      None => { break },
+      Some((pfx1, basename1)) => {
+        prefix1 = pfx1.clone();
+        if basename1 == "." { continue };
+        if basename1 == ".." || basename_list2.is_empty() || basename_list2.first().unwrap() != ".." {
+          prefix1.push_str(&basename1);
+          break
+          }
+        }
+    }
+    index_list2.shift();
+    basename_list2.shift();
+  }
+
+  let result: String;
+
+  let mut r1 = if let Some((_,_)) = chop_basename(&prefix1[..]) {true} else {false};
+
+  if !r1 {
+    r1 = basename(&prefix1[..], "").contains("/");
+    if r1 {
+      while !basename_list2.is_empty() && basename_list2.first().unwrap() == ".." {
+        index_list2.shift();
+        basename_list2.shift();
+      }
+    }
+  }
+  if !basename_list2.is_empty() {
+    let suffix2 = path2.index(index_list2.first().unwrap().to_owned()..);
+    if r1 {
+      result = Path::new(&prefix1).join(Path::new(&suffix2)).to_str().unwrap().to_string();
+    } else {
+      prefix1.push_str(&suffix2);
+      result = prefix1.to_string();
+    }
+  } else {
+    if r1 {
+      result = prefix1.to_string();
+    } else {
+      result = dirname(&prefix1[..]);
+    }
+  }
+
+  String::from(result)
+}
+
+#[test]
+fn it_will_plus_same_as_ruby() {
+  assert_eq!("/"      ,       plus_paths("/"  , "/"));
+  assert_eq!("a/b"    ,       plus_paths("a"  , "b"));
+  assert_eq!("a"      ,       plus_paths("a"  , "."));
+  assert_eq!("b"      ,       plus_paths("."  , "b"));
+  assert_eq!("."      ,       plus_paths("."  , "."));
+  assert_eq!("/b"     ,       plus_paths("a"  , "/b"));
+
+  assert_eq!("/"      ,       plus_paths("/"  , ".."));
+  assert_eq!("."      ,       plus_paths("a"  , ".."));
+  assert_eq!("a"      ,       plus_paths("a/b", ".."));
+  assert_eq!("../.."  ,       plus_paths(".." , ".."));
+  assert_eq!("/c"     ,       plus_paths("/"  , "../c"));
+  assert_eq!("c"      ,       plus_paths("a"  , "../c"));
+  assert_eq!("a/c"    ,       plus_paths("a/b", "../c"));
+  assert_eq!("../../c",       plus_paths(".." , "../c"));
+
+  assert_eq!("a//b/d//e",     plus_paths("a//b/c", "../d//e"));
+
+  assert_eq!("//foo/var/bar", plus_paths("//foo/var", "bar"));
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-30 00:00:00.000000000 Z
+date: 2017-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: gruff
   requirement: !ruby/object:Gem::Requirement
@@ -177,6 +177,7 @@ files:
 - 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
@@ -188,6 +189,7 @@ files:
 - 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
@@ -211,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Reimplementation of Pathname for better performance