faster_path 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95885428dc6e619ea1069fd3473cd68ffd762eca29d09f1185ebfafc7cbcbebf
-  data.tar.gz: 4ad3a157841d4003e7314295fb955a01565c903c05942b112527a95818664f7c
+  metadata.gz: 1f459170e11712e3d18dc8937e433ea724dd7dd016b3e5cbf5a7e6da722b4dfe
+  data.tar.gz: a3c27c26aee46ca61237635c42add31fb307a787706af74b87eb62eb74c17dda
 SHA512:
-  metadata.gz: 881379d959fcadeaf9e23236327b9b2da8315a3e95307718cc4ff763002eb1ea11134b7607518f98a6b20a9d5b9db3b38d31174d85b8c5bbc3fdca6a3f8c8aac
-  data.tar.gz: 961dd0da7cff5e3ac96aa3745dfe803464d748784fabe51a49988afb254e6995d168e640abc25b7cae64379b1c1b53b6faa5f299ee74adcc2d01ad11cf05153a
+  metadata.gz: c7d6b3a879a2acbfe48eeb96acd9bc53674c6525e0637820c40de7d988a45647a6310dfbbaab96b9d46856a9722ed595d9b957bc8fbc1c04b1a690e2e937f73d
+  data.tar.gz: e8c3bf596e1a508647a1f21ba3323796e9fa7f29a8145275b7dc8a91aa8c852bf7438216db1f36c3d4c602b36b79a7b1c9e9f01e3e2126db4427f47dd9477809

data/Cargo.lock

@@ -10,12 +10,13 @@ dependencies = [
  "array_tool 0.4.1 (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)",
+ "ruby-sys 0.3.0 (git+https://github.com/danielpclark/ruby-sys?branch=playground)",
  "ruru 0.9.3 (git+https://github.com/danielpclark/ruru?branch=playground)",
 ]
 
 [[package]]
 name = "lazy_static"
-version = "0.2.8"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -25,7 +26,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "libc"
-version = "0.2.30"
+version = "0.2.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -33,31 +34,31 @@ 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)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "ruby-sys"
 version = "0.3.0"
-source = "git+https://github.com/danielpclark/ruby-sys?branch=playground#08c96179e46ce8a5fec25e1b4aeb5d9c63a2245e"
+source = "git+https://github.com/danielpclark/ruby-sys?branch=playground#a71d5783e92d9dfd3602f81adc96f640ff377f21"
 dependencies = [
- "libc 0.2.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "ruru"
 version = "0.9.3"
-source = "git+https://github.com/danielpclark/ruru?branch=playground#aa4a08c48374bb13983cf6de5df7125a18ea1169"
+source = "git+https://github.com/danielpclark/ruru?branch=playground#e35b9dd88d86f3b8bb9cede7a74b04781bd4da89"
 dependencies = [
- "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "ruby-sys 0.3.0 (git+https://github.com/danielpclark/ruby-sys?branch=playground)",
 ]
 
 [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 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"
 "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 libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)" = "1e5d97d6708edaa407429faa671b942dc0f2727222fb6b6539bf1db936e4b121"
 "checksum memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "796fba70e76612589ed2ce7f45282f5af869e0fdd7cc6199fa1aa1f1d591ba9d"
 "checksum ruby-sys 0.3.0 (git+https://github.com/danielpclark/ruby-sys?branch=playground)" = "<none>"
 "checksum ruru 0.9.3 (git+https://github.com/danielpclark/ruru?branch=playground)" = "<none>"

data/Cargo.toml

@@ -13,6 +13,7 @@ name = "faster_path"
 crate-type = ["dylib"]
 
 [dependencies]
+ruby-sys = { git = "https://github.com/danielpclark/ruby-sys", branch = "playground" }
 ruru = { git = "https://github.com/danielpclark/ruru", branch = "playground" }
 array_tool = "0.4.1"
 lazy_static = "1.0"

data/MIT-LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016-2017 Daniel P. Clark & FasterPath Contributors
+Copyright (c) 2016-2018 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.3.svg)](https://github.com/danielpclark/faster_path/pulse)
+[![Commits Since Last Release](https://img.shields.io/github/commits-since/danielpclark/faster_path/v0.2.5.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)
@@ -136,18 +136,21 @@ improvement result  for the `chop_basename` method.
 
 Current methods implemented:
 
-|FasterPath Rust Implementation|Ruby 2.3.4 Implementation|Time Shaved Off|
+|FasterPath Rust Implementation|Ruby 2.5.0 Implementation|Time Shaved Off|
 |---|---|:---:|
-| `FasterPath.absolute?` | `Pathname#absolute?` | 88.5% |
-| `FasterPath.add_trailing_separator` | `Pathname#add_trailing_separator` | 31.1% |
-| `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.9% |
-| `FasterPath.relative?` | `Pathname#relative?` | 83.1% |
+| `FasterPath.absolute?` | `Pathname#absolute?` | 91.9% |
+| `FasterPath.add_trailing_separator` | `Pathname#add_trailing_separator` | 31.2% |
+| `FasterPath.children` | `Pathname#children` | 13.2% |
+| `FasterPath.chop_basename` | `Pathname#chop_basename` | 54.5% |
+| `FasterPath.cleanpath_aggressive` | `Pathname#cleanpath_aggressive` | 73.8% |
+| `FasterPath.cleanpath_conservative` | `Pathname#cleanpath_conservative` | 70.7% |
+| `FasterPath.del_trailing_separator` | `Pathname#del_trailing_separator` | 80.6% |
+| `FasterPath.directory?` | `Pathname#directory?` | 11.3% |
+| `FasterPath.entries` | `Pathname#entries` | 8.4% |
+| `FasterPath.has_trailing_separator?` | `Pathname#has_trailing_separator` | 67.6% |
+| `FasterPath.plus` | `Pathname#join` | 66.4% |
+| `FasterPath.plus` | `Pathname#plus` | 81.4% |
+| `FasterPath.relative?` | `Pathname#relative?` | 84.1% |
 
 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

data/lib/faster_path/optional/monkeypatches.rb

@@ -52,6 +52,16 @@ module FasterPath
         end
         private :cleanpath_aggressive
 
+        def cleanpath_conservative
+          Pathname.new(FasterPath.cleanpath_conservative(@path))
+        end
+        private :cleanpath_conservative
+
+        def del_trailing_separator(pth)
+          FasterPath.del_trailing_separator(pth)
+        end
+        private :del_trailing_separator
+
         def directory?
           FasterPath.directory?(@path)
         end
@@ -65,6 +75,10 @@ module FasterPath
         end
         private :has_trailing_separator?
 
+        def join(*args)
+          FasterPath.join(self, *args)
+        end
+
         def plus(pth, pth2)
           FasterPath.plus(pth, pth2)
         end

data/lib/faster_path/optional/refinements.rb

@@ -48,6 +48,16 @@ module FasterPath
       end
       private :cleanpath_aggressive
 
+      def cleanpath_conservative
+        Pathname.new(FasterPath.cleanpath_conservative(@path))
+      end
+      private :cleanpath_conservative
+
+      def del_trailing_separator(pth)
+        FasterPath.del_trailing_separator(pth)
+      end
+      private :del_trailing_separator
+
       def directory?
         FasterPath.directory?(@path)
       end
@@ -60,6 +70,10 @@ module FasterPath
         FasterPath.has_trailing_separator?(pth)
       end
 
+      def join(*args)
+        FasterPath.join(self, *args)
+      end
+
       def plus(pth, pth2)
         FasterPath.plus(pth, pth2)
       end

data/lib/faster_path/version.rb

@@ -1,3 +1,3 @@
 module FasterPath
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/faster_path.rb

@@ -1,7 +1,6 @@
 require "faster_path/version"
 require 'pathname'
 require 'faster_path/platform'
-require 'faster_path/asset_resolution'
 require 'fiddle'
 require 'fiddle/import'
 

data/src/cleanpath_conservative.rs

@@ -0,0 +1,110 @@
+use prepend_prefix::prepend_prefix;
+use basename::basename;
+use dirname::dirname;
+use chop_basename::chop_basename;
+extern crate array_tool;
+use self::array_tool::vec::Shift;
+use std::path::MAIN_SEPARATOR;
+
+pub fn cleanpath_conservative(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()),
+        }
+      },
+      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
+      }
+    }
+  }
+
+  if names.is_empty() {
+    return dirname(&pre).to_string();
+  }
+
+  if names.last() != Some(&"..".to_string()) && basename(&path, "") == &".".to_string() {
+    names.push(".".to_string());
+  }
+
+  let result = prepend_prefix(&pre, &names.join(&sep)[..]);
+  let last = names.last();
+
+  if !(last == Some(&".".to_string()) || last == Some(&"..".to_string())) &&
+    chop_basename(path).map(|(a, b)| a.len() + b.len()).unwrap() < path.len() {
+    format!("{}{}", last.unwrap(), MAIN_SEPARATOR)
+  } else {
+    result
+  }
+}
+
+#[test]
+fn it_conservatively_cleans_the_path() {
+  assert_eq!(cleanpath_conservative("/"),      "/");
+  assert_eq!(cleanpath_conservative(""),      ".");
+  assert_eq!(cleanpath_conservative("."),      ".");
+  assert_eq!(cleanpath_conservative(".."),     "..");
+  assert_eq!(cleanpath_conservative("a"),      "a");
+  assert_eq!(cleanpath_conservative("/."),      "/");
+  assert_eq!(cleanpath_conservative("/.."),      "/");
+  assert_eq!(cleanpath_conservative("/a"),     "/a");
+  assert_eq!(cleanpath_conservative("./"),      ".");
+  assert_eq!(cleanpath_conservative("../"),     "..");
+  assert_eq!(cleanpath_conservative("a/"),     "a/");
+  assert_eq!(cleanpath_conservative("a//b"),    "a/b");
+  assert_eq!(cleanpath_conservative("a/."),    "a/.");
+  assert_eq!(cleanpath_conservative("a/./"),    "a/.");
+  assert_eq!(cleanpath_conservative("a/../"),   "a/..");
+  assert_eq!(cleanpath_conservative("/a/."),   "/a/.");
+  assert_eq!(cleanpath_conservative("./.."),     "..");
+  assert_eq!(cleanpath_conservative("../."),     "..");
+  assert_eq!(cleanpath_conservative("./../"),     "..");
+  assert_eq!(cleanpath_conservative(".././"),     "..");
+  assert_eq!(cleanpath_conservative("/./.."),      "/");
+  assert_eq!(cleanpath_conservative("/../."),      "/");
+  assert_eq!(cleanpath_conservative("/./../"),      "/");
+  assert_eq!(cleanpath_conservative("/.././"),      "/");
+  assert_eq!(cleanpath_conservative("a/b/c"),  "a/b/c");
+  assert_eq!(cleanpath_conservative("./b/c"),    "b/c");
+  assert_eq!(cleanpath_conservative("a/./c"),    "a/c");
+  assert_eq!(cleanpath_conservative("a/b/."),  "a/b/.");
+  assert_eq!(cleanpath_conservative("a/../."),   "a/..");
+  assert_eq!(cleanpath_conservative("/../.././../a"),     "/a");
+  assert_eq!(cleanpath_conservative("a/b/../../../../c/../d"), "a/b/../../../../c/../d");
+;
+// Future Windows Support
+//
+// DOSISH = File::ALT_SEPARATOR != nil
+// DOSISH_DRIVE_LETTER = File.dirname("A:") == "A:."
+// DOSISH_UNC = File.dirname("//") == "//"
+//
+// 
+//   if DOSISH
+//     assert_eq!(cleanpath_conservative, 'c:/foo/bar', 'c:\\foo\\bar')
+//   end
+// 
+//   if DOSISH_UNC
+//     assert_eq!(cleanpath_conservative, '//',     '//')
+//   else
+//     assert_eq!(cleanpath_conservative, '/',      '//')
+//   end
+}

data/src/helpers.rs

@@ -1,13 +1,63 @@
-use ruru::{RString, Object, Class};
-
-pub fn new_pathname_instance(path: &str) -> Class {
-  let mut path_instance = Class::from(
-    Class::from_existing("Pathname").send("allocate", None).value()
-  );
-  path_instance.instance_variable_set(
-    "@path",
-    RString::new(path).to_any_object()
-  );
-
-  path_instance
+use ruru::{RString, Object, Class, AnyObject};
+use pathname::Pathname;
+
+pub fn anyobject_to_string(item: AnyObject) -> Result<String, RubyDebugInfo> {
+  let result = &item;
+  if Class::from_existing("String").case_equals(result) {
+    return Ok(RString::from(result.value()).to_string())
+  }
+  
+  if Class::from_existing("Pathname").case_equals(result) {
+    return Ok(result.instance_variable_get("@path").
+      try_convert_to::<RString>().
+      unwrap_or(RString::new("")).
+      to_string())
+  }
+  
+  if result.respond_to("to_path") {
+    return Ok(Class::from(result.send("to_path", None).value()).
+      instance_variable_get("@path").
+      try_convert_to::<RString>().
+      unwrap_or(RString::new("")).
+      to_string())
+  }
+
+  Ok(RString::from(result.send("to_s", None).value()).to_string())
+}
+
+#[allow(dead_code)]
+pub fn into_pathname(itself: AnyObject) -> Result<AnyObject, RubyDebugInfo> {
+  if Class::from_existing("String").case_equals(&itself) {
+    Ok(Pathname::new(
+        &RString::from(itself.value()).to_string()
+    ).to_any_object())
+  } else if Class::from_existing("Pathname").case_equals(&itself) {
+    Ok(itself)
+  } else {
+    Err(RubyDebugInfo::from(itself))
+  }
+}
+
+#[derive(Debug)]
+pub struct RubyDebugInfo {
+  object_id: String,
+  class: String,
+  inspect: String,
+}
+
+impl From<AnyObject> for RubyDebugInfo {
+  fn from(ao: AnyObject) -> Self {
+    let object_id = ao.send("object_id", None).send("to_s", None).
+      try_convert_to::<RString>().unwrap_or(RString::new("Failed to get object_id!")).to_string();
+    let class = ao.send("class", None).send("to_s", None).
+      try_convert_to::<RString>().unwrap_or(RString::new("Failed to get class!")).to_string();
+    let inspect = ao.send("inspect", None).
+      try_convert_to::<RString>().unwrap_or(RString::new("Failed to get inspect!")).to_string();
+
+    RubyDebugInfo {
+      object_id: object_id,
+      class: class,
+      inspect: inspect,
+    }
+  }
 }

data/src/lib.rs

@@ -17,8 +17,10 @@ mod pathname;
 mod basename;
 mod chop_basename;
 mod cleanpath_aggressive;
+mod cleanpath_conservative;
 mod dirname;
 mod extname;
+mod pathname_sys;
 mod plus;
 mod prepend_prefix;
 pub mod rust_arch_bits;
@@ -26,8 +28,8 @@ mod path_parsing;
 
 use ruru::{Module, Object, RString, Boolean, Array, AnyObject};
 
-// r_ methods are on the core class and may evaluate instance variables or self
-// pub_ methods must take all values as parameters
+use pathname_sys::*;
+
 methods!(
   FasterPath,
   _itself,
@@ -65,9 +67,13 @@ methods!(
     pathname::pn_cleanpath_aggressive(pth)
   }
 
-  // fn r_cleanpath_conservative(pth: RString){}
+  fn pub_cleanpath_conservative(pth: RString) -> RString {
+    pathname::pn_cleanpath_conservative(pth)
+  }
 
-  // fn r_del_trailing_separator(pth: RString){}
+  fn pub_del_trailing_separator(pth: RString) -> RString {
+    pathname::pn_del_trailing_separator(pth)
+  }
 
   // fn r_descend(){}
 
@@ -107,8 +113,6 @@ methods!(
     pathname::pn_has_trailing_separator(pth)
   }
 
-  // fn r_join(args: Array){}
-
   // fn pub_mkpath(pth: RString) -> NilClass {
   //   pathname::pn_mkpath(pth)
   // }
@@ -149,11 +153,15 @@ pub extern "C" fn Init_faster_pathname(){
   Module::from_existing("FasterPath").define(|itself| {
     itself.def_self("absolute?", pub_is_absolute);
     itself.def_self("add_trailing_separator", pub_add_trailing_separator);
+    itself.def_self("del_trailing_separator", pub_del_trailing_separator);
     itself.def_self("cleanpath_aggressive", pub_cleanpath_aggressive);
+    itself.def_self("cleanpath_conservative", pub_cleanpath_conservative);
     itself.def_self("directory?", pub_is_directory);
     itself.def_self("dirname", pub_dirname);
     itself.def_self("extname", pub_extname);
     itself.def_self("has_trailing_separator?", pub_has_trailing_separator);
+    //itself.def_self("join", pub_join);
+    pathname_sys::define_singleton_method(itself.value(), "join", pub_join);
     itself.def_self("plus", pub_plus);
     itself.def_self("relative?", pub_is_relative);
     itself.define_nested_class("Public", None);

data/src/pathname.rs

@@ -1,19 +1,63 @@
-use helpers::new_pathname_instance;
+use helpers::*;
 use basename;
 use chop_basename;
 use cleanpath_aggressive;
+use cleanpath_conservative;
 use dirname;
 use extname;
 use plus;
 
 use ruru;
-use ruru::{RString, Boolean, Array, AnyObject, NilClass, Object};
+use ruru::{RString, Boolean, Array, AnyObject, NilClass, Object, Class, VerifiedObject};
+use ruru::types::{Value, ValueType};
 use std::path::{MAIN_SEPARATOR,Path};
 use std::fs;
 
+type MaybeArray = Result<ruru::Array, ruru::result::Error>;
 type MaybeString = Result<ruru::RString, ruru::result::Error>;
 type MaybeBoolean = Result<ruru::Boolean, ruru::result::Error>;
 
+pub struct Pathname {
+  value: Value
+}
+
+impl Pathname {
+  pub fn new(path: &str) -> Pathname {
+    let mut instance = Class::from_existing("Pathname").allocate();
+    instance.instance_variable_set("@path", RString::new(path).to_any_object());
+    
+    Pathname { value: instance.value() }
+  }
+
+  pub fn to_any_object(&self) -> AnyObject {
+    AnyObject::from(self.value())
+  }
+}
+
+impl From<Value> for Pathname {
+  fn from(value: Value) -> Self {
+    Pathname { value: value }
+  }
+}
+
+impl Object for Pathname {
+  #[inline]
+  fn value(&self) -> Value {
+    self.value
+  }
+}
+
+impl VerifiedObject for Pathname {
+  fn is_correct_type<T: Object>(object: &T) -> bool {
+    object.value().ty() == ValueType::Class &&
+      Class::from_existing("Pathname").case_equals(object)
+  }
+
+  fn error_message() -> &'static str {
+    "Error converting to Pathname"
+  }
+}
+
 pub fn pn_add_trailing_separator(pth: MaybeString) -> RString {
   let p = pth.ok().unwrap();
   let x = format!("{}{}", p.to_str(), "a");
@@ -42,7 +86,6 @@ pub fn pn_basename(pth: MaybeString, ext: MaybeString) -> RString {
 }
 
 pub fn pn_children(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject {
-  let mut arr = Array::new();
   let val = pth.ok().unwrap_or(RString::new("."));
   let val = val.to_str();
 
@@ -52,6 +95,7 @@ pub fn pn_children(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject {
       with_directory = false;
     }
 
+    let mut arr = Array::new();
     for entry in entries {
       if with_directory {
         match entry {
@@ -75,7 +119,6 @@ pub fn pn_children(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject {
 }
 
 pub fn pn_children_compat(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject {
-  let mut arr = Array::new();
   let val = pth.ok().unwrap_or(RString::new("."));
   let val = val.to_str();
 
@@ -85,14 +128,15 @@ pub fn pn_children_compat(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject
       with_directory = false;
     }
 
+    let mut arr = Array::new();
     for entry in entries {
       if with_directory {
         if let Ok(v) = entry {
-          arr.push(new_pathname_instance(v.path().to_str().unwrap()));
+          arr.push(Pathname::new(v.path().to_str().unwrap()));
         };
       } else {
         if let Ok(v) = entry {
-          arr.push(new_pathname_instance(v.file_name().to_str().unwrap()));
+          arr.push(Pathname::new(v.file_name().to_str().unwrap()));
         };
       }
     }
@@ -128,9 +172,33 @@ pub fn pn_cleanpath_aggressive(pth: MaybeString) -> RString {
   RString::new(&path)
 }
 
-// pub fn pn_cleanpath_conservative(pth: MaybeString){}
+pub fn pn_cleanpath_conservative(pth: MaybeString) -> RString {
+  let path = cleanpath_conservative::cleanpath_conservative(
+    pth.ok().unwrap_or(RString::new("")).to_str()
+  );
+
+  RString::new(&path)
+}
 
-// pub fn pn_del_trailing_separator(pth: MaybeString){}
+pub fn pn_del_trailing_separator(pth: MaybeString) -> RString {
+  if let &Ok(ref path) = &pth {
+    let path = path.to_str();
+
+    if !path.is_empty() {
+      let path = path.trim_right_matches('/');
+
+      if path.is_empty() {
+        return RString::new("/");
+      } else {
+        return RString::new(path);
+      }
+    }
+  } else {
+    return RString::new("");
+  }
+
+  pth.unwrap()
+}
 
 // pub fn pn_descend(){}
 
@@ -157,9 +225,9 @@ pub fn pn_dirname(pth: MaybeString) -> RString {
 // }
 
 pub fn pn_entries(pth: MaybeString) -> AnyObject {
-  let mut arr = Array::new();
-
   if let Ok(files) = fs::read_dir(pth.ok().unwrap_or(RString::new("")).to_str()) {
+    let mut arr = Array::new();
+
     arr.push(RString::new("."));
     arr.push(RString::new(".."));
 
@@ -177,15 +245,15 @@ pub fn pn_entries(pth: MaybeString) -> AnyObject {
 }
 
 pub fn pn_entries_compat(pth: MaybeString) -> AnyObject {
-  let mut arr = Array::new();
-
   if let Ok(files) = fs::read_dir(pth.ok().unwrap_or(RString::new("")).to_str()) {
-    arr.push(new_pathname_instance("."));
-    arr.push(new_pathname_instance(".."));
+    let mut arr = Array::new();
+
+    arr.push(Pathname::new("."));
+    arr.push(Pathname::new(".."));
 
     for file in files {
       let file_name_str = file.unwrap().file_name().into_string().unwrap();
-      arr.push(new_pathname_instance(&file_name_str));
+      arr.push(Pathname::new(&file_name_str));
     }
 
     arr.to_any_object()
@@ -202,7 +270,7 @@ pub fn pn_extname(pth: MaybeString) -> RString {
   )
 }
 
-// pub fn pn_find(pth: MaybeString ,ignore_error: Boolean){}
+// pub fn pn_find(pth: MaybeString, ignore_error: Boolean){}
 
 pub fn pn_has_trailing_separator(pth: MaybeString) -> Boolean {
   let v = pth.ok().unwrap_or(RString::new(""));
@@ -214,7 +282,32 @@ pub fn pn_has_trailing_separator(pth: MaybeString) -> Boolean {
   }
 }
 
-// pub fn pn_join(args: Array){}
+pub fn pn_join(args: MaybeArray) -> AnyObject {
+  let mut args = args.unwrap();
+  let path_self = anyobject_to_string(args.shift()).unwrap();
+  let mut qty = args.length();
+  if qty <= 0 {
+    return Pathname::new(&path_self).to_any_object();
+  }
+
+  let mut result = String::new();
+
+  loop {
+    if qty == 0 { break; }
+
+    let item = args.pop();
+    result = plus::plus_paths(&anyobject_to_string(item).unwrap(), &result);
+    if result.chars().next() == Some(MAIN_SEPARATOR) {
+      return Pathname::new(&result).to_any_object()
+    }
+
+    qty -= 1;
+  }
+  
+  let result = plus::plus_paths(&path_self, &result);
+
+  Pathname::new(&result).to_any_object()
+}
 
 // pub fn pn_mkpath(pth: MaybeString) -> NilClass {
 //   NilClass::new()
@@ -224,7 +317,6 @@ pub fn pn_has_trailing_separator(pth: MaybeString) -> Boolean {
 
 // pub fn pn_parent(pth: MaybeString){}
 
-// also need impl +
 pub fn pn_plus(pth1: MaybeString, pth2: MaybeString) -> RString {
   RString::new(
     &plus::plus_paths(

data/src/pathname_sys.rs

@@ -0,0 +1,36 @@
+use ruru::{AnyObject, Array, Object};
+use ruru::types::{Argc, Value, CallbackPtr};
+use ruru::util::str_to_cstring;
+extern crate ruby_sys;
+use self::ruby_sys::{class, util};
+use ::pathname;
+
+pub type ValueCallback<I, O> = extern "C" fn(Argc, *const Value, I) -> O;
+
+pub fn define_singleton_method<I: Object, O: Object>(
+    klass: Value,
+    name: &str,
+    callback: ValueCallback<I, O>,
+) {
+    let name = str_to_cstring(name);
+
+    unsafe {
+        class::rb_define_singleton_method(klass, name.as_ptr(), callback as CallbackPtr, -1);
+    }
+}
+
+// ruru doesn't support splat arguments yet
+pub extern fn pub_join(argc: Argc, argv: *const Value, _: AnyObject) -> AnyObject {
+  let args = Value::from(0);
+
+  unsafe {
+    util::rb_scan_args(
+      argc,
+      argv,
+      str_to_cstring("*").as_ptr(),
+      &args
+    )
+  };
+  
+  pathname::pn_join(Ok(Array::from(args)))
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-20 00:00:00.000000000 Z
+date: 2018-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -141,7 +141,6 @@ files:
 - ext/faster_path/extconf.rb
 - faster_path.gemspec
 - lib/faster_path.rb
-- lib/faster_path/asset_resolution.rb
 - lib/faster_path/optional/monkeypatches.rb
 - lib/faster_path/optional/refinements.rb
 - lib/faster_path/platform.rb
@@ -149,12 +148,14 @@ files:
 - src/basename.rs
 - src/chop_basename.rs
 - src/cleanpath_aggressive.rs
+- src/cleanpath_conservative.rs
 - src/dirname.rs
 - src/extname.rs
 - src/helpers.rs
 - src/lib.rs
 - src/path_parsing.rs
 - src/pathname.rs
+- src/pathname_sys.rs
 - src/plus.rs
 - src/prepend_prefix.rs
 - src/rust_arch_bits.rs

data/lib/faster_path/asset_resolution.rb

@@ -1,60 +0,0 @@
-# This is a redundancy check for the rust compiled library needed for this gem.
-# If the asset is not available and we can't compile it from this code then FAIL
-# on require of 'faster_path' with a very clear message as to why."
-
-require_relative './platform'
-
-module FasterPath
-  module AssetResolution # BREAK IN CASE OF EMERGENCY ;-)
-    class << self
-      def verify!
-        return lib_file if file?
-
-        if rust?
-          compile!
-          raise "Rust failed to compile asset! The dynamic library for this package was not found." unless file?
-          return lib_file
-        end
-
-        raise "The dynamic library for this package was not found nor was Rust's cargo executable found. This package will not work without it!"
-      end
-
-      private
-
-      def compile!
-        require 'open3'
-        Dir.chdir(File.expand_path('../../', __dir__)) do
-          Open3.popen3("rake build_lib") do |stdin, stdout, stderr, wait_thr|
-            stdin.close
-
-            wait_thr && wait_thr.value.exitstatus
-            out = Thread.new { stdout.read }.value.strip
-            Thread.new { stderr.read }.value
-            out
-          end
-        end
-        File.exist? lib_file
-      end
-
-      def rust?
-        require 'mkmf'
-        MakeMakefile::Logging.instance_variable_set(:@log, File.open(File::NULL, 'w'))
-        MakeMakefile.instance_eval "undef :message; def message(*); end"
-        MakeMakefile.find_executable('cargo')
-      end
-
-      def file?
-        File.exist? lib_file
-      end
-
-      def lib_dir
-        File.expand_path("../../target/release/", __dir__)
-      end
-
-      def lib_file
-        Platform.ffi_library()
-      end
-    end
-  end
-end
-FasterPath::AssetResolution.verify! unless ENV['TEST']