faster_path 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa3f9dba549d669279573d0241b6d2c682f79662
-  data.tar.gz: aa054bab991c3002071a7ec48d73088294f2b01d
+  metadata.gz: b2f9feadf34476752439130f2871285f20bd67d5
+  data.tar.gz: 184c00898cdca31bc822bf9c0023ca24f729c839
 SHA512:
-  metadata.gz: ea433ac9b113962f898e229af0a466f0b6c37136fcc709ed9ff0c07659c5515537c3747fffd518a88051c919c08757aada3b1b47f714af42aee15e85eccd9d6a
-  data.tar.gz: e813af21a48a83b4b278663a2e2ef4c7ce9874e682651ce3ef529165c923a4a84830c53341d9725757573e75e63ff0e6f1c921d5382d8ed67bd957fbcaf4d7a7
+  metadata.gz: 963c1a8874494f241daeb36c791c0136107be377df03739276b1e1c3b354a352616972c72ac137192cade9d8168ec5f863d1aaeb2c7974a949887f018652ce53
+  data.tar.gz: f66e104da591aa1b690eedbc5dca48eb636c0cdb27d5d150b3425d67e6e6c568932cf0474fd80915fae6d477715af85337d54a93065561db9fb03d404d0910ee

data/Cargo.toml

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

data/README.md

@@ -3,6 +3,8 @@
 [![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%20load%20time%20by%20switching%20to%20the%20FasterPath%20gem.)
 
+_Build is currently failing is for the monkey-patch tests only._
+
 #### As of gem version 0.0.9 this shaves off 66% of my Rails applications page load time.
 
 The primary **GOAL** of this project is to improve performance in the most heavily used areas of Ruby as
@@ -85,6 +87,7 @@ 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` | 46.7% |
 | `FasterPath.relative?` | `Pathname#relative?` | 1262.3% |
 | `FasterPath.blank?` | | |

data/lib/faster_path/optional/monkeypatches.rb

@@ -3,8 +3,8 @@ module FasterPath
     ::File.class_eval do
       def basename(pth)
         FasterPath.basename(pth)
-      end if FasterPath.respond_to? :basename
-    end unless true # No need to open class when we're not using it yet
+      end 
+    end 
 
     ::Pathname.class_eval do
       def absolute?

data/lib/faster_path/optional/refinements.rb

@@ -3,9 +3,9 @@ module FasterPath
     refine File do
       def basename(pth)
         FasterPath.basename(pth)
-      end if FasterPath.respond_to? :basename
+      end
     end
-  end unless true # No need to open class when we're not using it yet
+  end 
 
   module RefinePathname
     refine Pathname do

data/lib/faster_path/version.rb

@@ -1,3 +1,3 @@
 module FasterPath
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/faster_path.rb

@@ -28,7 +28,7 @@ module FasterPath
 
   def self.basename(pth, ext="")
     Rust.basename(pth, ext)
-  end unless true # WAY_TOO_SLOW! 5600X slower
+  end 
 
   # EXAMPLE
   #def self.one_and_two
@@ -56,7 +56,7 @@ module FasterPath
     attach_function :is_relative, [ :string ], :bool
     attach_function :is_blank, [ :string ], :bool
     attach_function :both_are_blank, [ :string, :string ], :bool
-    #attach_function :basename, [ :string, :string ], :string
+    attach_function :basename, [ :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,22 +1,93 @@
-#[no_mangle]
-pub extern fn basename(string: *const c_char, comp_ext: *const c_char) -> *const c_char {
+#[allow(dead_code)]
+fn rubyish_basename(string: &str, globish_string: &str) -> String {
+  let result = if globish_string.chars().next().unwrap_or("muffins".chars().next().unwrap()).eq(&".".chars().next().unwrap()) {
+    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("")
+    }
+  } 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()
+}
+
+#[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.");
+}
+
+//#[no_mangle]
+pub extern fn basename(str_pth: *const c_char, comp_ext: *const c_char) -> *const c_char {
   let c_str1 = unsafe {
-    assert!(!string.is_null());
-    CStr::from_ptr(string)
+    assert!(!str_pth.is_null());
+    CStr::from_ptr(str_pth)
   };
   let c_str2 = unsafe {
     assert!(!comp_ext.is_null());
     CStr::from_ptr(comp_ext)
   };
-  let r_str = str::from_utf8(c_str1.to_bytes()).unwrap();
-  let r_str_chomp = str::from_utf8(c_str2.to_bytes()).unwrap();
-
-  let r_str = if !r_str_chomp.is_empty() {
-    chomp_pathish_regex(r_str, r_str_chomp)
-  } else { r_str.to_string() };
+  let string         = str::from_utf8(c_str1.to_bytes()).unwrap();
+  let globish_string = str::from_utf8(c_str2.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()
+  let result = if globish_string.chars().next().unwrap_or("muffins".chars().next().unwrap()).eq(&".".chars().next().unwrap()) {
+    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("")
+    }
+  } 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()
 }

data/src/lib.rs

@@ -5,7 +5,6 @@
 // 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;
@@ -13,18 +12,13 @@ use std::ffi::{CStr,CString,OsStr};
 use std::str;
 use std::mem;
 
-// Not including regex in current build so chomp_pathish_regex
-// and basename will be excluded in build
-//include!("tools/chomp_pathish_regex.rs");
-//include!("basename.rs");
-
-
 include!("ruby_string.rs");
 include!("ruby_array.rs");
 include!("is_absolute.rs");
 include!("is_relative.rs");
 include!("is_blank.rs");
 include!("both_are_blank.rs");
+include!("basename.rs");
 include!("dirname.rs");
 include!("basename_for_chop.rs");
 include!("dirname_for_chop.rs");

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Daniel P. Clark
@@ -143,7 +143,6 @@ files:
 - src/lib.rs
 - src/ruby_array.rs
 - src/ruby_string.rs
-- src/tools/chomp_pathish_regex.rs
 homepage: https://github.com/danielpclark/faster_path
 licenses:
 - MIT OR Apache-2.0

data/src/tools/chomp_pathish_regex.rs

@@ -1,38 +0,0 @@
-fn chomp_pathish_regex(string: &str, globish_string: &str) -> String {
-  use regex::Regex;
-  // Keep first match of Regex pattern
-  // \A(?:(.*)(?:\.{1}\w+)|(.*))\z
-  let mut reg_builder: String = String::with_capacity(globish_string.len()+30); // need 29 chars + gs
-  reg_builder.push_str(r"\A(?:(.*)");
-  if globish_string.len() != 0 {
-    let mut gs = globish_string.chars();
-    loop {
-      match gs.next() {
-        Some('.') => { reg_builder.push_str(r"(?:\.{1}") },
-        Some('*') => { reg_builder.push_str(r"\w+")   },
-        Some(x)   => { reg_builder.push(x)            },
-        None      => {
-          reg_builder.push_str(r")|(.*)");
-          break
-        },
-      }
-    }
-  }
-  reg_builder.push_str(r")\z");
-
-  let re = Regex::new(&reg_builder[..]).unwrap();
-  let caps = re.captures(string).unwrap();
-  caps.at(1).unwrap_or(caps.at(0).unwrap_or("")).to_string()
-}
-
-#[test]
-fn it_chomps_strings_correctly(){
-  assert_eq!(chomp_pathish_regex("",""), "");
-  assert_eq!(chomp_pathish_regex("ruby",""), "ruby");
-  assert_eq!(chomp_pathish_regex("ruby.rb",".rb"), "ruby");
-  assert_eq!(chomp_pathish_regex("ruby.rb",".*"), "ruby");
-  assert_eq!(chomp_pathish_regex(".ruby/ruby.rb",".rb"), ".ruby/ruby");
-  assert_eq!(chomp_pathish_regex(".ruby/ruby.rb.swp",".rb"), ".ruby/ruby.rb.swp");
-  assert_eq!(chomp_pathish_regex(".ruby/ruby.rb.swp",".swp"), ".ruby/ruby.rb");
-  assert_eq!(chomp_pathish_regex(".ruby/ruby.rb.swp",".*"), ".ruby/ruby.rb");
-}