Merge pull request #139 from danielpclark/relative_path_from

Relative path from

Author: danielpclark

Cargo.lock

@@ -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"

Cargo.toml

@@ -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

README.md

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

lib/faster_path/optional/monkeypatches.rb

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

lib/faster_path/optional/refinements.rb

@@ -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")) );
 }
 

src/chop_basename.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() {

src/cleanpath_aggressive.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

src/cleanpath_conservative.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,
+    }
+  }
+}

src/debug.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,
-    }
-  }
-}

src/helpers.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);
   });