Merge pull request #172 from danielpclark/update_rutie_0.3.2

Update to Rutie 0.3.2

Author: danielpclark

Cargo.lock

@@ -16,6 +16,6 @@ name = "faster_path"
 crate-type = ["dylib"]
 
 [dependencies]
-rutie = "0.1.4"
+rutie = "0.3.2"
 lazy_static = "1.0"
 memchr = "2.0.1"

Cargo.toml

@@ -28,8 +28,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'rake', '~> 12.3'
   spec.add_dependency 'thermite', '0.13.0'
   spec.add_development_dependency 'read_source', '~> 0.2.6'
-  spec.add_development_dependency 'minitest', '~> 5.10'
-  spec.add_development_dependency 'minitest-reporters', '~> 1.1'
+  spec.add_development_dependency 'minitest', '~> 5.11'
+  spec.add_development_dependency 'minitest-reporters', '1.1'
   spec.add_development_dependency 'color_pound_spec_reporter', '~> 0.0.9'
   spec.add_development_dependency 'rubocop', '0.53'
   spec.add_development_dependency 'stop_watch', '~> 1.0'

faster_path.gemspec

@@ -14,11 +14,11 @@ pub struct RubyDebugInfo {
 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();
+      try_convert_to::<RString>().unwrap_or(RString::new_utf8("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();
+      try_convert_to::<RString>().unwrap_or(RString::new_utf8("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();
+      try_convert_to::<RString>().unwrap_or(RString::new_utf8("Failed to get inspect!")).to_string();
 
     RubyDebugInfo {
       object_id: object_id,

src/debug.rs

@@ -31,7 +31,7 @@ pub fn anyobject_to_string(item: AnyObject) -> Result<String, RubyDebugInfo> {
   if Class::from_existing("Pathname").case_equals(result) {
     return Ok(result.instance_variable_get("@path").
       try_convert_to::<RString>().
-      unwrap_or(RString::new("")).
+      unwrap_or(RString::new_utf8("")).
       to_string())
   }
 

src/helpers.rs

@@ -39,7 +39,7 @@ pub struct Pathname {
 
 impl Pathname {
   pub fn new(path: &str) -> Pathname {
-    let arguments = [RString::new(path).to_any_object()];
+    let arguments = [RString::new_utf8(path).to_any_object()];
     let instance = Class::from_existing("Pathname").new_instance(Some(&arguments));
 
     Pathname { value: instance.value() }
@@ -94,7 +94,7 @@ pub fn pn_add_trailing_separator(pth: MaybeString) -> RString {
   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())
+    _ => RString::new_utf8(format!("{}{}", p.to_str(), MAIN_SEPARATOR).as_str())
   }
 }
 
@@ -105,11 +105,11 @@ pub fn pn_is_absolute(pth: MaybeString) -> Boolean {
 // pub fn pn_ascend(){}
 
 pub fn pn_basename(pth: MaybeString, ext: MaybeString) -> RString {
-  RString::new(basename::basename(to_str(&pth), to_str(&ext)))
+  RString::new_utf8(basename::basename(to_str(&pth), to_str(&ext)))
 }
 
 pub fn pn_children(pth: MaybeString, with_dir: MaybeBoolean) -> Result<AnyObject, Exception> {
-  let path = pth.unwrap_or(RString::new("."));
+  let path = pth.unwrap_or(RString::new_utf8("."));
   let path = path.to_str();
 
   if let Ok(entries) = fs::read_dir(path) {
@@ -122,12 +122,12 @@ pub fn pn_children(pth: MaybeString, with_dir: MaybeBoolean) -> Result<AnyObject
     for entry in entries {
       if with_directory {
         match entry {
-          Ok(v) => { arr.push(RString::new(v.path().to_str().unwrap())); },
+          Ok(v) => { arr.push(RString::new_utf8(v.path().to_str().unwrap())); },
           _ => {}
         };
       } else {
         match entry {
-          Ok(v) => { arr.push(RString::new(v.file_name().to_str().unwrap())); },
+          Ok(v) => { arr.push(RString::new_utf8(v.file_name().to_str().unwrap())); },
           _ => {}
         };
       }
@@ -173,8 +173,8 @@ pub fn pn_chop_basename(pth: MaybeString) -> AnyObject {
   match chop_basename::chop_basename(to_str(&pth)) {
     Some((dirname, basename)) => {
       let mut arr = Array::with_capacity(2);
-      arr.push(RString::new(&dirname));
-      arr.push(RString::new(&basename));
+      arr.push(RString::new_utf8(&dirname));
+      arr.push(RString::new_utf8(&basename));
       arr.to_any_object()
     },
     None => NilClass::new().to_any_object()
@@ -184,25 +184,25 @@ pub fn pn_chop_basename(pth: MaybeString) -> AnyObject {
 // pub fn pn_cleanpath(pth: MaybeString){}
 
 pub fn pn_cleanpath_aggressive(pth: MaybeString) -> RString {
-  RString::new(&cleanpath_aggressive::cleanpath_aggressive(to_str(&pth)))
+  RString::new_utf8(&cleanpath_aggressive::cleanpath_aggressive(to_str(&pth)))
 }
 
 pub fn pn_cleanpath_conservative(pth: MaybeString) -> RString {
-  RString::new(&cleanpath_conservative::cleanpath_conservative(to_str(&pth)))
+  RString::new_utf8(&cleanpath_conservative::cleanpath_conservative(to_str(&pth)))
 }
 
 pub fn pn_del_trailing_separator(pth: MaybeString) -> RString {
   {
     let path = to_str(&pth);
     if path.is_empty() {
-      return RString::new("/");
+      return RString::new_utf8("/");
     }
     let pos = match find_last_non_sep_pos(path.as_bytes()) {
       Some(pos) => pos,
-      None => return RString::new("/"),
+      None => return RString::new_utf8("/"),
     };
     if pos != path.len() - 1 {
-      return RString::new(&path[..pos + 1]);
+      return RString::new_utf8(&path[..pos + 1]);
     }
   }
   pth.unwrap()
@@ -215,7 +215,7 @@ pub fn pn_is_directory(pth: MaybeString) -> Boolean {
 }
 
 pub fn pn_dirname(pth: MaybeString) -> RString {
-  RString::new(dirname::dirname(to_str(&pth)))
+  RString::new_utf8(dirname::dirname(to_str(&pth)))
 }
 
 // pub fn pn_each_child(){}
@@ -229,11 +229,11 @@ pub fn pn_entries(pth: MaybeString) -> Result<AnyObject, Exception> {
   if let Ok(files) = fs::read_dir(path) {
     let mut arr = Array::with_capacity(files.size_hint().1.unwrap_or(0) + 2);
 
-    arr.push(RString::new("."));
-    arr.push(RString::new(".."));
+    arr.push(RString::new_utf8("."));
+    arr.push(RString::new_utf8(".."));
 
     for file in files {
-      arr.push(RString::new(file.unwrap().file_name().to_str().unwrap()));
+      arr.push(RString::new_utf8(file.unwrap().file_name().to_str().unwrap()));
     }
 
     Ok(arr.to_any_object())
@@ -263,7 +263,7 @@ pub fn pn_entries_compat(pth: MaybeString) -> Result<AnyObject, Exception> {
 }
 
 pub fn pn_extname(pth: MaybeString) -> RString {
-  RString::new(extname::extname(to_str(&pth)))
+  RString::new_utf8(extname::extname(to_str(&pth)))
 }
 
 // pub fn pn_find(pth: MaybeString, ignore_error: Boolean){}
@@ -298,7 +298,7 @@ pub fn pn_join(args: MaybeArray) -> AnyObject {
 // pub fn pn_parent(pth: MaybeString){}
 
 pub fn pn_plus(pth1: MaybeString, pth2: MaybeString) -> RString {
-  RString::new(&plus::plus_paths(to_str(&pth1), to_str(&pth2)))
+  RString::new_utf8(&plus::plus_paths(to_str(&pth1), to_str(&pth2)))
 }
 
 // pub fn pn_prepend_prefix(prefix: MaybeString, relpath: MaybeString){}

src/pathname.rs

@@ -1,7 +1,7 @@
 use rutie::{AnyObject, Array};
 use rutie::types::{Argc, Value};
 use rutie::util::str_to_cstring;
-use rutie::rubysys::util;
+use rutie::rubysys::class;
 use ::pathname;
 use std::mem;
 
@@ -12,7 +12,7 @@ pub extern fn pub_join(argc: Argc, argv: *const AnyObject, _: AnyObject) -> AnyO
   unsafe {
     let p_argv: *const Value = mem::transmute(argv);
 
-    util::rb_scan_args(
+    class::rb_scan_args(
       argc,
       p_argv,
       str_to_cstring("*").as_ptr(),

src/pathname_sys.rs

@@ -73,7 +73,7 @@ def assert_unhappy_compat_path(m, c)
 
   end
 
-  describe "TestForIdenticalOutput" do
+  describe "test for identical output" do
     def test_absolute?
       assert_happy_path :absolute?
       assert_unhappy_path :absolute?