faster_path 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f459170e11712e3d18dc8937e433ea724dd7dd016b3e5cbf5a7e6da722b4dfe
-  data.tar.gz: a3c27c26aee46ca61237635c42add31fb307a787706af74b87eb62eb74c17dda
+  metadata.gz: 64eada185c9f0597ca475f6f94f77299b5ebf0458fe6de87d5a041d7a6d69dfe
+  data.tar.gz: 5d14a11a8a468eba873da3b6e4d2628e8fdbb5d88150c60575b6266a4df5f726
 SHA512:
-  metadata.gz: c7d6b3a879a2acbfe48eeb96acd9bc53674c6525e0637820c40de7d988a45647a6310dfbbaab96b9d46856a9722ed595d9b957bc8fbc1c04b1a690e2e937f73d
-  data.tar.gz: e8c3bf596e1a508647a1f21ba3323796e9fa7f29a8145275b7dc8a91aa8c852bf7438216db1f36c3d4c602b36b79a7b1c9e9f01e3e2126db4427f47dd9477809
+  metadata.gz: 2c2121f4aa08b8979818480b78980f07563483befa52c2493821f7a562d0f213a762f192ed1b7ec3c67050c9f0a72bccbb65a0dcb1d7258316ffbe0ae7480c2f
+  data.tar.gz: 0c16b9cd5e5ff583717d664228bfac6ac4b6b5e46c7a92c8a3170ae050ae9ec6974dc597a1c9aff8232e77515b3d5cd70bfccd33c5fa67402091af660dd7f502

data/Cargo.lock

@@ -1,13 +1,13 @@
 [[package]]
 name = "array_tool"
-version = "0.4.1"
+version = "1.0.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)",
+ "array_tool 1.0.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)",
@@ -26,7 +26,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "libc"
-version = "0.2.36"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -34,31 +34,31 @@ name = "memchr"
 version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.37 (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#a71d5783e92d9dfd3602f81adc96f640ff377f21"
+source = "git+https://github.com/danielpclark/ruby-sys?branch=playground#184a3cd3bd39b525ff956f7cba1770bbf1522d8b"
 dependencies = [
- "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.37 (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#e35b9dd88d86f3b8bb9cede7a74b04781bd4da89"
+source = "git+https://github.com/danielpclark/ruru?branch=playground#c9b59118ebcf034874d491a0c1f3b57ef05c183a"
 dependencies = [
  "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 array_tool 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7894b81e06d8a2376f015b34dd89770c549932ff90bba6427f7cd83243bb629b"
 "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.36 (registry+https://github.com/rust-lang/crates.io-index)" = "1e5d97d6708edaa407429faa671b942dc0f2727222fb6b6539bf1db936e4b121"
+"checksum libc 0.2.37 (registry+https://github.com/rust-lang/crates.io-index)" = "56aebce561378d99a0bb578f8cb15b6114d2a1814a6c7949bbe646d968bb4fa9"
 "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

@@ -15,6 +15,6 @@ 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"
+array_tool = "1.0"
 lazy_static = "1.0"
 memchr = "2.0.1"

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.5.svg)](https://github.com/danielpclark/faster_path/pulse)
+[![Commits Since Last Release](https://img.shields.io/github/commits-since/danielpclark/faster_path/v0.2.6.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)
@@ -151,6 +151,7 @@ Current methods implemented:
 | `FasterPath.plus` | `Pathname#join` | 66.4% |
 | `FasterPath.plus` | `Pathname#plus` | 81.4% |
 | `FasterPath.relative?` | `Pathname#relative?` | 84.1% |
+| `FasterPath.relative_path_from` | `Pathname#relative_path_from` | 69.8% |
 
 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

@@ -87,6 +87,10 @@ module FasterPath
         def relative?
           FasterPath.relative?(@path)
         end
+
+        def relative_path_from(other)
+          FasterPath.relative_path_from(@path, other)
+        end
       end
     end
   end

data/lib/faster_path/optional/refinements.rb

@@ -82,6 +82,10 @@ module FasterPath
       def relative?
         FasterPath.relative?(@path)
       end
+
+      def relative_path_from(other)
+        FasterPath.relative_path_from(@path, other)
+      end
     end
   end
 end

data/lib/faster_path/version.rb

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

data/src/chop_basename.rs

@@ -1,54 +1,31 @@
 use std::path::MAIN_SEPARATOR;
 use std::str;
 
-pub fn chop_basename(input: &str) -> Option<(String,String)> {
+pub fn chop_basename<'a>(input: &'a str) -> Option<(&'a str, &'a str)> {
   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 input = input.trim_right_matches(MAIN_SEPARATOR);
+  let end = input.rsplitn(2, MAIN_SEPARATOR).nth(0).unwrap().len();
+  let base = &input[input.len()-end..input.len()];
   let directory = &input[0..input.len()-base.len()];
 
   if directory.is_empty() && (base.is_empty() || base.chars().next().unwrap() == MAIN_SEPARATOR) {
     return None
   };
 
-  Some((directory.to_string(), base.to_string()))
+  Some((directory, base))
 }
 
 #[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()))
-  );
+  assert_eq!(chop_basename(""),           None );
+  assert_eq!(chop_basename("/"),          None );
+  assert_eq!(chop_basename("."),          Some(("", ".")) );
+  assert_eq!(chop_basename("asdf/asdf"),  Some(("asdf/",     "asdf")) );
+  assert_eq!(chop_basename("asdf.txt"),   Some(("",      "asdf.txt")) );
+  assert_eq!(chop_basename("asdf/"),      Some(("",          "asdf")) );
+  assert_eq!(chop_basename("/asdf/"),     Some(("/",         "asdf")) );
 }
 

data/src/cleanpath_aggressive.rs

@@ -10,7 +10,7 @@ pub fn cleanpath_aggressive(path: &str) -> String {
   let mut names: Vec<String> = vec![];
   let mut pre = path.to_string();
   loop {
-    match chop_basename(&pre) {
+    match chop_basename(&pre.clone()) {
       Some((ref p, ref base)) => {
         pre = p.to_string();
         match base.as_ref() {

data/src/cleanpath_conservative.rs

@@ -11,7 +11,7 @@ pub fn cleanpath_conservative(path: &str) -> String {
   let mut names: Vec<String> = vec![];
   let mut pre = path.to_string();
   loop {
-    match chop_basename(&pre) {
+    match chop_basename(&pre.clone()) {
       Some((ref p, ref base)) => {
         pre = p.to_string();
         match base.as_ref() {
@@ -90,7 +90,7 @@ fn it_conservatively_cleans_the_path() {
   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

data/src/debug.rs

@@ -0,0 +1,29 @@
+use ruru::{
+  RString,
+  AnyObject,
+  Object,
+};
+
+#[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/helpers.rs

@@ -1,5 +1,14 @@
 use ruru::{RString, Object, Class, AnyObject};
-use pathname::Pathname;
+use debug::RubyDebugInfo;
+
+#[inline]
+pub fn is_same_path(a: &str, b: &str) -> bool {
+  if cfg!(windows) {
+    a.to_uppercase() == b.to_uppercase()
+  } else {
+    a == b
+  }
+}
 
 pub fn anyobject_to_string(item: AnyObject) -> Result<String, RubyDebugInfo> {
   let result = &item;
@@ -24,40 +33,3 @@ pub fn anyobject_to_string(item: AnyObject) -> Result<String, RubyDebugInfo> {
 
   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

@@ -4,6 +4,8 @@
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
+#![feature(try_from)]
+
 #[macro_use]
 extern crate ruru;
 
@@ -12,6 +14,7 @@ extern crate lazy_static;
 
 module!(FasterPath);
 
+mod debug;
 mod helpers;
 mod pathname;
 mod basename;
@@ -25,6 +28,10 @@ mod plus;
 mod prepend_prefix;
 pub mod rust_arch_bits;
 mod path_parsing;
+mod relative_path_from;
+
+use pathname::Pathname;
+use pathname_sys::raise;
 
 use ruru::{Module, Object, RString, Boolean, Array, AnyObject};
 
@@ -139,8 +146,12 @@ methods!(
 
   // fn r_split_names(pth: RString){}
 
-  // fn r_relative_path_from(){}
-  // fn pub_relative_path_from(){}
+  fn pub_relative_path_from(itself: RString, base_directory: AnyObject) -> Pathname {
+    let to_string = |i: AnyObject| { RString::from(i.send("to_s", None).value()) };
+
+    pathname::pn_relative_path_from(itself, base_directory.map(to_string)).
+      map_err(|e| raise(e) ).unwrap()
+  }
 
   // fn pub_rmtree(pth: RString) -> NilClass {
   //   pathname::pn_rmtree(pth)
@@ -149,7 +160,7 @@ methods!(
 
 #[allow(non_snake_case)]
 #[no_mangle]
-pub extern "C" fn Init_faster_pathname(){
+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);
@@ -164,6 +175,7 @@ pub extern "C" fn Init_faster_pathname(){
     pathname_sys::define_singleton_method(itself.value(), "join", pub_join);
     itself.def_self("plus", pub_plus);
     itself.def_self("relative?", pub_is_relative);
+    itself.def_self("relative_path_from", pub_relative_path_from);
     itself.define_nested_class("Public", None);
   });
 

data/src/pathname.rs

@@ -6,9 +6,22 @@ use cleanpath_conservative;
 use dirname;
 use extname;
 use plus;
+use relative_path_from;
+use debug;
+use std::convert::TryFrom;
 
 use ruru;
-use ruru::{RString, Boolean, Array, AnyObject, NilClass, Object, Class, VerifiedObject};
+use ruru::{
+  RString,
+  Boolean,
+  Array,
+  AnyObject,
+  NilClass,
+  Object,
+  Class,
+  VerifiedObject,
+  AnyException as Exception
+};
 use ruru::types::{Value, ValueType};
 use std::path::{MAIN_SEPARATOR,Path};
 use std::fs;
@@ -40,6 +53,19 @@ impl From<Value> for Pathname {
   }
 }
 
+impl TryFrom<AnyObject> for Pathname {
+  type Error = debug::RubyDebugInfo;
+  fn try_from(obj: AnyObject) -> Result<Pathname, Self::Error> {
+    if Class::from_existing("String").case_equals(&obj) {
+      Ok(Pathname::new(&RString::from(obj.value()).to_string()))
+    } else if Class::from_existing("Pathname").case_equals(&obj) {
+      Ok(Pathname::from(obj.value()))
+    } else {
+      Err(Self::Error::from(obj))
+    }
+  }
+}
+
 impl Object for Pathname {
   #[inline]
   fn value(&self) -> Value {
@@ -151,7 +177,8 @@ pub fn pn_children_compat(pth: MaybeString, with_dir: MaybeBoolean) -> AnyObject
 
 pub fn pn_chop_basename(pth: MaybeString) -> Array {
   let mut arr = Array::with_capacity(2);
-  let results = chop_basename::chop_basename(pth.ok().unwrap_or(RString::new("")).to_str());
+  let pth = pth.ok().unwrap_or(RString::new(""));
+  let results = chop_basename::chop_basename(pth.to_str());
   match results {
     Some((dirname, basename)) => {
       arr.push(RString::new(&dirname[..]));
@@ -341,7 +368,9 @@ pub fn pn_is_relative(pth: MaybeString) -> Boolean {
 
 // pub fn pn_split_names(pth: MaybeString){}
 
-// pub fn pn_relative_path_from(){}
+pub fn pn_relative_path_from(itself: MaybeString, base_directory: MaybeString) -> Result<Pathname, Exception> {
+  relative_path_from::relative_path_from(itself, base_directory)
+}
 
 // pub fn pn_rmtree(pth: MaybeString) -> NilClass {
 //   NilClass::new()

data/src/pathname_sys.rs

@@ -1,22 +1,26 @@
-use ruru::{AnyObject, Array, Object};
+use ruru::{AnyObject, Array, Object, AnyException};
 use ruru::types::{Argc, Value, CallbackPtr};
 use ruru::util::str_to_cstring;
 extern crate ruby_sys;
-use self::ruby_sys::{class, util};
+use self::ruby_sys::{class, util, vm};
 use ::pathname;
 
+pub fn raise(exception: AnyException) {
+  unsafe { vm::rb_exc_raise(exception.value()); }
+}
+
 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>,
+  klass: Value,
+  name: &str,
+  callback: ValueCallback<I, O>,
 ) {
-    let name = str_to_cstring(name);
+  let name = str_to_cstring(name);
 
-    unsafe {
-        class::rb_define_singleton_method(klass, name.as_ptr(), callback as CallbackPtr, -1);
-    }
+  unsafe {
+    class::rb_define_singleton_method(klass, name.as_ptr(), callback as CallbackPtr, -1);
+  }
 }
 
 // ruru doesn't support splat arguments yet

data/src/plus.rs

@@ -13,10 +13,10 @@ pub fn plus_paths(path1: &str, path2: &str) -> String {
   let mut basename_list2: Vec<String> = vec![];
 
   loop {
-    match chop_basename(&prefix2[..]) {
+    match chop_basename(&prefix2.clone()[..]) {
       None => { break },
       Some((pfx2, basename2)) => {
-        prefix2 = pfx2.clone();
+        prefix2 = pfx2.to_string();
         index_list2.unshift(pfx2.len());
         basename_list2.unshift(basename2.to_owned());
       },
@@ -33,10 +33,10 @@ pub fn plus_paths(path1: &str, path2: &str) -> String {
       index_list2.shift();
       basename_list2.shift();
     }
-    match chop_basename(&prefix1[..]) {
+    match chop_basename(&prefix1.clone()[..]) {
       None => { break },
       Some((pfx1, basename1)) => {
-        prefix1 = pfx1.clone();
+        prefix1 = pfx1.to_string();
         if basename1 == "." { continue };
         if basename1 == ".." || basename_list2.is_empty() || basename_list2.first().unwrap() != ".." {
           prefix1.push_str(&basename1);

data/src/relative_path_from.rs

@@ -0,0 +1,90 @@
+use helpers::is_same_path;
+use path_parsing::SEP_STR;
+extern crate array_tool;
+use self::array_tool::vec::{Shift, Join};
+use self::array_tool::iter::ZipOpt;
+use pathname;
+use ruru;
+use chop_basename;
+use pathname::Pathname;
+use ruru::{Exception as Exc, AnyException as Exception};
+
+type MaybeString = Result<ruru::RString, ruru::result::Error>;
+
+pub fn relative_path_from(itself: MaybeString, base_directory: MaybeString) -> Result<Pathname, Exception> {
+  let dest_directory = pathname::pn_cleanpath_aggressive(itself).to_string();
+  let base_directory = pathname::pn_cleanpath_aggressive(base_directory).to_string();
+
+  let mut dest_prefix = dest_directory.clone();
+  let mut dest_names: Vec<String> = vec![];
+  loop {
+    match chop_basename::chop_basename(&dest_prefix.clone()) {
+      Some((ref dest, ref basename)) => {
+        dest_prefix = dest.to_string();
+        if basename != &"." {
+          dest_names.unshift(basename.to_string())
+        }
+      },
+      None => break,
+    }
+  }
+
+  let mut base_prefix = base_directory.clone();
+  let mut base_names: Vec<String> = vec![];
+  loop {
+    match chop_basename::chop_basename(&base_prefix.clone()) {
+      Some((ref base, ref basename)) => {
+        base_prefix = base.to_string();
+        if basename != &"." {
+          base_names.unshift(basename.to_string())
+        }
+      },
+      None => break,
+    }
+  }
+
+  if !is_same_path(&dest_prefix, &base_prefix) {
+    return Err(
+      Exception::new(
+        "ArgumentError",
+        Some(&format!("different prefix: {} and {}", dest_prefix, base_prefix)[..])
+      )
+    );
+  }
+
+  let (dest_names, base_names): (Vec<String>, Vec<String>) = dest_names.
+    iter().
+    zip_option(base_names.iter()).
+    skip_while(|&(a, b)| {
+      match (a, b) {
+        (Some(x), Some(y)) => is_same_path(x,y),
+        _ => false,
+      }
+    }).
+    fold((vec![], vec![]), |mut acc, (a, b)| {
+      if let Some(v) = a {
+        acc.0.push(v.to_string());
+      }
+      if let Some(v) = b {
+        acc.1.push(v.to_string());
+      }
+      acc
+    });
+
+  if base_names.contains(&"..".to_string()) {
+    return Err(
+      Exception::new(
+        "ArgumentError",
+        Some(&format!("base_directory has ..: {}", base_directory)[..])
+      )
+    );
+  }
+
+  let base_names: Vec<String> = base_names.into_iter().map(|_| "..".to_string()).collect();
+
+  if base_names.is_empty() && dest_names.is_empty() {
+    Ok(Pathname::new("."))
+  } else {
+    Ok(Pathname::new(&base_names.iter().chain(dest_names.iter()).collect::<Vec<&String>>().join(&SEP_STR)))
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faster_path
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Daniel P. Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-28 00:00:00.000000000 Z
+date: 2018-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -149,6 +149,7 @@ files:
 - src/chop_basename.rs
 - src/cleanpath_aggressive.rs
 - src/cleanpath_conservative.rs
+- src/debug.rs
 - src/dirname.rs
 - src/extname.rs
 - src/helpers.rs
@@ -158,6 +159,7 @@ files:
 - src/pathname_sys.rs
 - src/plus.rs
 - src/prepend_prefix.rs
+- src/relative_path_from.rs
 - src/rust_arch_bits.rs
 homepage: https://github.com/danielpclark/faster_path
 licenses: