faster_path 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b227f5a94ba3ae27a33eab04fa65c80d95b9842
-  data.tar.gz: 6cf955a639547780ecd12279dd50c8f00343b772
+  metadata.gz: 739814304e0316723938ab4430c07c7b17d490a2
+  data.tar.gz: 108e7bcbf3ff76a25cc13abcc93139c6aa605f8b
 SHA512:
-  metadata.gz: 2571373e3f523f8db360b7b68593d192b10b4e718ba8f12cdc47292479c9e6facb74498d799dca7121aa4e895a7d2088b8d921855bd6857a3c9f1c7512617fcb
-  data.tar.gz: 3e2c243a5921e93c3e0f47e028aa2e7b10cbdf5eb304830093e869a6abca1159b6b86dc627516c548e404b5ce738ecbc8fd2f5a5b5e48ef802d8e20a7c392d34
+  metadata.gz: 87faa82ae7729a586da191ee691e41db88a24269aa26e9ab54d0f823c5ce140bd105ecc91066dc0f0d5ee8a4dd883b030a8af17e85705d250dc9f6b8a0d53785
+  data.tar.gz: 3d1861b3bd1238270820b6b1f688da630ebfc5556afab69cc37b2eb62bc02f3fe6a4538f5d3605fc97d9afb60681f561f5d3e4a4b6e08c2b7600339bee85f4d0

data/README.md

@@ -138,22 +138,22 @@ improvement result  for the `chop_basename` method.
 
 Current methods implemented:
 
-|FasterPath Rust Implementation|Ruby 2.3.1 Implementation|Performance Improvement|
+|FasterPath Rust Implementation|Ruby 2.3.4 Implementation|Time Shaved Off|
 |---|---|:---:|
-| `FasterPath.absolute?` | `Pathname#absolute?` | 93.9% |
-| `FasterPath.chop_basename` | `Pathname#chop_basename` | 50.6% |
-| `FasterPath.relative?` | `Pathname#relative?` | 93.2% |
-| `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% |
+| `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.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.relative?` | `Pathname#relative?` | 83.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
 everything everywhere.
 
-**Note:** `Pathname#chop_basename` in Ruby STDLIB has a bug with blank strings, that is the
-only difference in behavior against FasterPath's implementation.
-
 For the scoped **refinements** you will need to
 
 ```

data/lib/faster_path/optional/monkeypatches.rb

@@ -26,14 +26,20 @@ module FasterPath
       end
     end
 
+    # rubocop:disable Metrics/MethodLength
     def self._ruby_library_pathname!
       ::Pathname.class_eval do
         def absolute?
           FasterPath.absolute?(@path)
         end
 
-        def directory?
-          FasterPath.directory?(@path)
+        def add_trailing_separator(pth)
+          FasterPath.add_trailing_separator(pth)
+        end
+        private :add_trailing_separator
+
+        def children(with_dir=true)
+          FasterPath.children(@path, with_dir)
         end
 
         def chop_basename(pth)
@@ -41,28 +47,27 @@ module FasterPath
         end
         private :chop_basename
 
-        def relative?
-          FasterPath.relative?(@path)
+        def directory?
+          FasterPath.directory?(@path)
         end
 
-        def add_trailing_separator(pth)
-          FasterPath.add_trailing_separator(pth)
+        def entries
+          FasterPath.entries(@path)
         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
-
         def plus(pth, pth2)
           FasterPath.plus(pth, pth2)
         end
         private :plus
+
+        def relative?
+          FasterPath.relative?(@path)
+        end
       end
     end
   end

data/lib/faster_path/optional/refinements.rb

@@ -29,8 +29,13 @@ module FasterPath
         FasterPath.absolute?(@path)
       end
 
-      def directory?
-        FasterPath.directory?(@path)
+      def add_trailing_separator(pth)
+        FasterPath.add_trailing_separator(pth)
+      end
+      private :add_trailing_separator
+
+      def children(with_dir=true)
+        FasterPath.children(@path, with_dir)
       end
 
       def chop_basename(pth)
@@ -38,27 +43,26 @@ module FasterPath
       end
       private :chop_basename
 
-      def relative?
-        FasterPath.relative?(@path)
+      def directory?
+        FasterPath.directory?(@path)
       end
 
-      def add_trailing_separator(pth)
-        FasterPath.add_trailing_separator(pth)
+      def entries
+        FasterPath.entries(@path)
       end
-      private :add_trailing_separator
 
       def has_trailing_separator?(pth)
         FasterPath.has_trailing_separator?(pth)
       end
 
-      def entries
-        FasterPath.entries(@path)
-      end
-
       def plus(pth, pth2)
         FasterPath.plus(pth, pth2)
       end
       private :plus
+
+      def relative?
+        FasterPath.relative?(@path)
+      end
     end
   end
 end

data/lib/faster_path/version.rb

@@ -1,3 +1,3 @@
 module FasterPath
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/lib/faster_path.rb

@@ -14,14 +14,39 @@ module FasterPath
     new(library['Init_faster_pathname'], [], Fiddle::TYPE_VOIDP).
     call
 
-  FasterPathname.class_eval do
+  FasterPathname::Public.class_eval do
+    private :absolute?
     private :add_trailing_separator
     private :basename
+    private :children
     private :chop_basename
+    private :directory?
     private :dirname
     private :entries
     private :extname
+    private :has_trailing_separator?
     private :plus
+    private :relative?
+  end
+
+  FasterPathname.class_eval do
+    def initialize(arg)
+      unless arg.is_a? String
+        arg = arg.to_s
+      end
+      raise(ArgumentError, "null byte found") if arg.include?("\0")
+      @path = arg
+    end
+
+    # BAD; exposes private methods
+    # Need to reprivatize specific methods
+    def method_missing(method_name, *a, &b)
+      Public.send(method_name, @path, *a, &b)
+    end
+
+    def respond_to?(method_name, include_private = false)
+      Public.send(:respond_to?, method_name) || super
+    end
   end
 
   def self.rust_arch_bits
@@ -33,11 +58,11 @@ module FasterPath
   end
 
   def self.absolute?(pth)
-    FasterPathname.allocate.send(:absolute?, pth)
+    FasterPathname::Public.allocate.send(:absolute?, pth)
   end
 
   def self.add_trailing_separator(pth)
-    FasterPathname.allocate.send(:add_trailing_separator, pth)
+    FasterPathname::Public.allocate.send(:add_trailing_separator, pth)
   end
 
   def self.blank?(str)
@@ -45,40 +70,44 @@ module FasterPath
   end
 
   def self.basename(pth, ext="")
-    FasterPathname.allocate.send(:basename, pth, ext)
+    FasterPathname::Public.allocate.send(:basename, pth, ext)
+  end
+
+  def self.children(pth, with_directory=true)
+    FasterPathname::Public.allocate.send(:children, pth, with_directory)
   end
 
   def self.chop_basename(pth)
-    result = FasterPathname.allocate.send(:chop_basename, pth)
+    result = FasterPathname::Public.allocate.send(:chop_basename, pth)
     result unless result.empty?
   end
 
   def self.directory?(pth)
-    FasterPathname.allocate.send(:directory?, pth)
+    FasterPathname::Public.allocate.send(:directory?, pth)
   end
 
   def self.dirname(pth)
-    FasterPathname.allocate.send(:dirname, pth)
+    FasterPathname::Public.allocate.send(:dirname, pth)
   end
 
   def self.entries(pth)
-    FasterPathname.allocate.send(:entries, pth)
+    FasterPathname::Public.allocate.send(:entries, pth)
   end
 
   def self.extname(pth)
-    FasterPathname.allocate.send(:extname, pth)
+    FasterPathname::Public.allocate.send(:extname, pth)
   end
 
   def self.has_trailing_separator?(pth)
-    FasterPathname.allocate.send(:has_trailing_separator?, pth)
+    FasterPathname::Public.allocate.send(:has_trailing_separator?, pth)
   end
 
   def self.plus(pth, pth2)
-    FasterPathname.allocate.send(:plus, pth, pth2)
+    FasterPathname::Public.allocate.send(:plus, pth, pth2)
   end
 
   def self.relative?(pth)
-    FasterPathname.allocate.send(:relative?, pth)
+    FasterPathname::Public.allocate.send(:relative?, pth)
   end
 
   module Rust

data/src/lib.rs

@@ -9,6 +9,7 @@ extern crate ruru;
 
 class!(FasterPathname);
 
+mod pathname;
 mod basename;
 mod chop_basename;
 mod dirname;
@@ -18,126 +19,151 @@ pub mod rust_arch_bits;
 mod path_parsing;
 
 use ruru::{Class, Object, RString, Boolean, Array};
-use std::path::{MAIN_SEPARATOR,Path};
-use std::fs;
 
+// r_ methods are on the core class and may evaluate instance variables or self
+// pub_ methods must take all values as parameters
 methods!(
   FasterPathname,
   _itself,
 
-  fn r_add_trailing_separator(pth: RString) -> RString {
-    let p = pth.ok().unwrap();
-    let x = format!("{}{}", p.to_str(), "a");
-    match x.rsplit_terminator(MAIN_SEPARATOR).next() {
-      Some("a") => p,
-      _ => RString::new(format!("{}{}", p.to_str(), MAIN_SEPARATOR).as_str())
-    }
+  // TOPATH = :to_path
+
+  // SAME_PATHS = if File::FNM_SYSCASE.nonzero?
+  //   # Avoid #zero? here because #casecmp can return nil.
+  //   proc {|a, b| a.casecmp(b) == 0}
+  // else
+  //   proc {|a, b| a == b}
+  // end
+
+  // if File::ALT_SEPARATOR
+  //   SEPARATOR_LIST = "#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}"
+  //   SEPARATOR_PAT = /[#{SEPARATOR_LIST}]/
+  // else
+  //   SEPARATOR_LIST = "#{Regexp.quote File::SEPARATOR}"
+  //   SEPARATOR_PAT = /#{Regexp.quote File::SEPARATOR}/
+  // end
+
+  fn pub_add_trailing_separator(pth: RString) -> RString {
+    pathname::pn_add_trailing_separator(pth)
   }
 
-  fn r_is_absolute(pth: RString) -> Boolean {
-    Boolean::new(match pth.ok().unwrap_or(RString::new("")).to_str().chars().next() {
-      Some(c) => c == MAIN_SEPARATOR,
-      None => false
-    })
+  fn pub_is_absolute(pth: RString) -> Boolean {
+    pathname::pn_is_absolute(pth)
   }
 
-  fn r_basename(pth: RString, ext: RString) -> RString {
-    RString::new(
-      &basename::basename(
-        pth.ok().unwrap_or(RString::new("")).to_str(),
-        ext.ok().unwrap_or(RString::new("")).to_str()
-      )[..]
-    )
+  // fn r_ascend(){}
+
+  fn pub_basename(pth: RString, ext: RString) -> RString {
+    pathname::pn_basename(pth, ext)
   }
 
-  fn r_chop_basename(pth: RString) -> Array {
-    let mut arr = Array::with_capacity(2);
-    let results = chop_basename::chop_basename(pth.ok().unwrap_or(RString::new("")).to_str());
-    match results {
-      Some((dirname, basename)) => {
-        arr.push(RString::new(&dirname[..]));
-        arr.push(RString::new(&basename[..]));
-        arr
-      },
-      None => arr
-    }
+  fn pub_children(pth: RString, with_dir: Boolean) -> Array {
+    pathname::pn_children(pth, with_dir)
   }
 
-  fn r_is_directory(pth: RString) -> Boolean {
-    Boolean::new(
-      Path::new(
-        pth.ok().unwrap_or(RString::new("")).to_str()
-      ).is_dir()
-    )
+  fn pub_chop_basename(pth: RString) -> Array {
+    pathname::pn_chop_basename(pth)
   }
 
-  fn r_dirname(pth: RString) -> RString {
-    RString::new(
-      &dirname::dirname(
-        pth.ok().unwrap_or(RString::new("")).to_str()
-      )[..]
-    )
+  // fn r_cleanpath(){ pub_cleanpath(r_to_path()) }
+  // fn pub_cleanpath(pth: RString){}
+
+  // fn r_cleanpath_aggressive(pth: RString){}
+
+  // fn r_cleanpath_conservative(pth: RString){}
+
+  // fn r_del_trailing_separator(pth: RString){}
+
+  // fn r_descend(){}
+
+  fn pub_is_directory(pth: RString) -> Boolean {
+    pathname::pn_is_directory(pth)
   }
 
-  fn r_entries(pth: RString) -> Array {
-    let files = fs::read_dir(pth.ok().unwrap_or(RString::new("")).to_str()).unwrap();
-    let mut arr = Array::new();
+  fn pub_dirname(pth: RString) -> RString {
+    pathname::pn_dirname(pth)
+  }
 
-    arr.push(RString::new("."));
-    arr.push(RString::new(".."));
+  // fn r_each_child(){}
+  // fn pub_each_child(){}
 
-    for file in files {
-      let file_name_str = file.unwrap().file_name().into_string().unwrap();
-      arr.push(RString::new(&file_name_str[..]));
-    }
+  // fn pub_each_filename(pth: RString) -> NilClass {
+  //   pathname::pn_each_filename(pth)
+  // }
 
-    arr
+  fn pub_entries(pth: RString) -> Array {
+    pathname::pn_entries(pth)
   }
 
-  fn r_extname(pth: RString) -> RString {
-    RString::new(
-      &extname::extname(pth.ok().unwrap_or(RString::new("")).to_str())[..]
-    )
+  fn pub_extname(pth: RString) -> RString {
+    pathname::pn_extname(pth)
   }
 
-  fn r_has_trailing_separator(pth: RString) -> Boolean {
-    let v = pth.ok().unwrap_or(RString::new(""));
-    match chop_basename::chop_basename(v.to_str()) {
-      Some((a,b)) => {
-        Boolean::new(a.len() + b.len() < v.to_str().len())
-      },
-      _ => Boolean::new(false)
-    }
+  // 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)
   }
 
-  fn r_plus(pth1: RString, pth2: RString) -> RString {
-    RString::new(&plus::plus_paths(pth1.ok().unwrap().to_str(), pth2.ok().unwrap().to_str())[..])
+  // fn r_join(args: Array){}
+
+  // fn pub_mkpath(pth: RString) -> NilClass {
+  //   pathname::pn_mkpath(pth)
+  // }
+
+  // fn r_is_mountpoint(){ pub_is_mountpount(r_to_path()) }
+  // fn pub_is_mountpoint(pth: RString){}
+
+  // fn r_parent(){ pub_parent(r_to_path()) }
+  // fn pub_parent(pth: RString){}
+
+  // also need impl +
+  fn pub_plus(pth1: RString, pth2: RString) -> RString {
+    pathname::pn_plus(pth1, pth2)
   }
 
-  fn r_is_relative(pth: RString) -> Boolean {
-    Boolean::new(
-      match pth.ok().unwrap_or(RString::new(&MAIN_SEPARATOR.to_string()[..])).to_str().chars().next() {
-        Some(c) => c != MAIN_SEPARATOR,
-        None => true
-      }
-    )
+  // fn r_prepend_prefix(prefix: RString, relpath: RString){}
+
+  fn pub_is_relative(pth: RString) -> Boolean {
+    pathname::pn_is_relative(pth)
   }
+
+  // fn r_root(){ pub_root(r_to_path()) }
+  // fn pub_root(pth: RString){}
+
+  // fn r_split_names(pth: RString){}
+
+  // fn r_relative_path_from(){}
+  // fn pub_relative_path_from(){}
+
+  // fn pub_rmtree(pth: RString) -> NilClass {
+  //   pathname::pn_rmtree(pth)
+  // }
 );
 
 #[allow(non_snake_case)]
 #[no_mangle]
 pub extern "C" fn Init_faster_pathname(){
   Class::new("FasterPathname", None).define(|itself| {
-    itself.def("absolute?", r_is_absolute);
-    itself.def("add_trailing_separator", r_add_trailing_separator);
-    itself.def("basename", r_basename);
-    itself.def("chop_basename", r_chop_basename);
-    itself.def("directory?", r_is_directory);
-    itself.def("dirname", r_dirname);
-    itself.def("entries", r_entries);
-    itself.def("extname", r_extname);
-    itself.def("has_trailing_separator?", r_has_trailing_separator);
-    itself.def("plus", r_plus);
-    itself.def("relative?", r_is_relative);
+    itself.define_nested_class("Public", None);
+  });
+
+  // Public methods
+  // * 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("chop_basename", pub_chop_basename);
+    itself.def("directory?", pub_is_directory);
+    itself.def("dirname", pub_dirname);
+    itself.def("entries", pub_entries);
+    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);
   });
 }

data/src/pathname.rs

@@ -0,0 +1,179 @@
+use basename;
+use chop_basename;
+use dirname;
+use extname;
+use plus;
+
+use ruru;
+use ruru::{RString, Boolean, Array};
+use std::path::{MAIN_SEPARATOR,Path};
+use std::fs;
+
+pub fn pn_add_trailing_separator(pth: Result<ruru::RString, ruru::result::Error>) -> RString {
+  let p = pth.ok().unwrap();
+  let x = format!("{}{}", p.to_str(), "a");
+  match x.rsplit_terminator(MAIN_SEPARATOR).next() {
+    Some("a") => p,
+    _ => RString::new(format!("{}{}", p.to_str(), MAIN_SEPARATOR).as_str())
+  }
+}
+
+pub fn pn_is_absolute(pth: Result<ruru::RString, ruru::result::Error>) -> Boolean {
+  Boolean::new(match pth.ok().unwrap_or(RString::new("")).to_str().chars().next() {
+    Some(c) => c == MAIN_SEPARATOR,
+    None => false
+  })
+}
+
+// pub fn pn_ascend(){}
+
+pub fn pn_basename(pth: Result<ruru::RString, ruru::result::Error>, ext: Result<ruru::RString, ruru::result::Error>) -> RString {
+  RString::new(
+    &basename::basename(
+      pth.ok().unwrap_or(RString::new("")).to_str(),
+      ext.ok().unwrap_or(RString::new("")).to_str()
+    )[..]
+  )
+}
+
+pub fn pn_children(pth: Result<ruru::RString, ruru::result::Error>, with_dir: Result<ruru::Boolean, ruru::result::Error>) -> Array {
+  let rstring = pth.ok().unwrap_or(RString::new("."));
+  let val = rstring.to_str();
+  let mut with_directory = with_dir.ok().unwrap_or(Boolean::new(true)).to_bool();
+  if val == "." {
+    with_directory = false;
+  }
+  let mut arr = Array::new();
+
+  if let Ok(entries) = fs::read_dir(val) {
+    for entry in entries {
+      if with_directory {
+        match entry {
+          Ok(v) => { arr.push(RString::new(v.path().to_str().unwrap())); },
+          _ => {}
+        };
+      } else {
+        match entry {
+          Ok(v) => { arr.push(RString::new(v.file_name().to_str().unwrap())); },
+          _ => {}
+        };
+      }
+    }
+  }
+  arr
+}
+
+pub fn pn_chop_basename(pth: Result<ruru::RString, ruru::result::Error>) -> Array {
+  let mut arr = Array::with_capacity(2);
+  let results = chop_basename::chop_basename(pth.ok().unwrap_or(RString::new("")).to_str());
+  match results {
+    Some((dirname, basename)) => {
+      arr.push(RString::new(&dirname[..]));
+      arr.push(RString::new(&basename[..]));
+      arr
+    },
+    None => arr
+  }
+}
+
+// pub fn pn_cleanpath(pth: Result<ruru::RString, ruru::result::Error>){}
+
+// pub fn pn_cleanpath_aggressive(pth: Result<ruru::RString, ruru::result::Error>){}
+
+// pub fn pn_cleanpath_conservative(pth: Result<ruru::RString, ruru::result::Error>){}
+
+// pub fn pn_del_trailing_separator(pth: Result<ruru::RString, ruru::result::Error>){}
+
+// pub fn pn_descend(){}
+
+pub fn pn_is_directory(pth: Result<ruru::RString, ruru::result::Error>) -> Boolean {
+  Boolean::new(
+    Path::new(
+      pth.ok().unwrap_or(RString::new("")).to_str()
+    ).is_dir()
+  )
+}
+
+pub fn pn_dirname(pth: Result<ruru::RString, ruru::result::Error>) -> RString {
+  RString::new(
+    &dirname::dirname(
+      pth.ok().unwrap_or(RString::new("")).to_str()
+    )[..]
+  )
+}
+
+// pub fn pn_each_child(){}
+
+// pub fn pn_each_filename(pth: Result<ruru::RString, ruru::result::Error>) -> NilClass {
+//   NilClass::new()
+// }
+
+pub fn pn_entries(pth: Result<ruru::RString, ruru::result::Error>) -> Array {
+  let files = fs::read_dir(pth.ok().unwrap_or(RString::new("")).to_str()).unwrap();
+  let mut arr = Array::new();
+
+  arr.push(RString::new("."));
+  arr.push(RString::new(".."));
+
+  for file in files {
+    let file_name_str = file.unwrap().file_name().into_string().unwrap();
+    arr.push(RString::new(&file_name_str[..]));
+  }
+
+  arr
+}
+
+pub fn pn_extname(pth: Result<ruru::RString, ruru::result::Error>) -> RString {
+  RString::new(
+    &extname::extname(pth.ok().unwrap_or(RString::new("")).to_str())[..]
+  )
+}
+
+// pub fn pn_find(pth: Result<ruru::RString, ruru::result::Error> ,ignore_error: Boolean){}
+
+pub fn pn_has_trailing_separator(pth: Result<ruru::RString, ruru::result::Error>) -> Boolean {
+  let v = pth.ok().unwrap_or(RString::new(""));
+  match chop_basename::chop_basename(v.to_str()) {
+    Some((a,b)) => {
+      Boolean::new(a.len() + b.len() < v.to_str().len())
+    },
+    _ => Boolean::new(false)
+  }
+}
+
+// pub fn pn_join(args: Array){}
+
+// pub fn pn_mkpath(pth: Result<ruru::RString, ruru::result::Error>) -> NilClass {
+//   NilClass::new()
+// }
+
+// pub fn pn_is_mountpoint(pth: Result<ruru::RString, ruru::result::Error>){}
+
+// pub fn pn_parent(pth: Result<ruru::RString, ruru::result::Error>){}
+
+// also need impl +
+pub fn pn_plus(pth1: Result<ruru::RString, ruru::result::Error>, pth2: Result<ruru::RString, ruru::result::Error>) -> RString {
+  RString::new(&plus::plus_paths(pth1.ok().unwrap().to_str(), pth2.ok().unwrap().to_str())[..])
+}
+
+// pub fn pn_prepend_prefix(prefix: Result<ruru::RString, ruru::result::Error>, relpath: Result<ruru::RString, ruru::result::Error>){}
+
+pub fn pn_is_relative(pth: Result<ruru::RString, ruru::result::Error>) -> Boolean {
+  Boolean::new(
+    match pth.ok().unwrap_or(RString::new(&MAIN_SEPARATOR.to_string()[..])).to_str().chars().next() {
+      Some(c) => c != MAIN_SEPARATOR,
+      None => true
+    }
+  )
+}
+
+// pub fn pn_root(pth: Result<ruru::RString, ruru::result::Error>){}
+
+// pub fn pn_split_names(pth: Result<ruru::RString, ruru::result::Error>){}
+
+// pub fn pn_relative_path_from(){}
+
+// pub fn pn_rmtree(pth: Result<ruru::RString, ruru::result::Error>) -> NilClass {
+//   NilClass::new()
+// }
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-12 00:00:00.000000000 Z
+date: 2017-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -179,6 +179,7 @@ files:
 - src/extname.rs
 - src/lib.rs
 - src/path_parsing.rs
+- src/pathname.rs
 - src/plus.rs
 - src/rust_arch_bits.rs
 homepage: https://github.com/danielpclark/faster_path