feat: impl Push and LuaRead for Path and OsStr related types

Author: Egor Ivkov

CHANGELOG.md

@@ -1,9 +1,11 @@
 # Change Log
 
 
-# [?.?.?] Unreleased
+# [5.1.0] Unreleased
 
 ### Added
+- `tlua::Push` trait implementations for `OsString`, `OsStr`, `Path`, `PathBuf`
+- `tlua::LuaRead` trait implementations for `OsString`, `PathBuf`
 
 ### Changed
 

tarantool/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tarantool"
 description = "Tarantool rust bindings"
-version = "5.0.1"
+version = "5.1.0"
 authors = [
     "Dmitriy Koltsov <dkoltsov@picodata.io>",
     "Georgy Moshkin <gmoshkin@picodata.io>",

tests/src/tlua/values.rs

@@ -1,5 +1,6 @@
-use std::ffi::CString;
+use std::ffi::{CString, OsStr, OsString};
 use std::os::raw::{c_char, c_void};
+use std::path::{Path, PathBuf};
 use tarantool::tlua::{
     c_ptr, c_str, ffi, function0, AnyLuaString, AnyLuaValue, AsCData, AsLua, AsTable, CData,
     CDataOnStack, False, Lua, LuaFunction, LuaTable, Nil, Null, Strict, StringInLua, ToString,
@@ -883,13 +884,34 @@ pub fn readwrite_bools() {
 }
 
 pub fn readwrite_strings() {
+    use tarantool::tlua;
+
     let lua = Lua::new();
 
+    #[derive(tlua::Push)]
+    struct S<'a, 'b> {
+        os: &'a OsStr,
+        path: &'b Path,
+    }
+
+    #[derive(tlua::Push, tlua::LuaRead)]
+    struct OwnedS {
+        os: OsString,
+        path: PathBuf,
+    }
+
     lua.set("a", "hello");
     lua.set("b", &"hello".to_string());
     lua.set("c", c_str!("can you hear me?"));
     lua.set("d", CString::new("HELLO!!!").unwrap());
 
+    lua.checked_set("os_owned", OsString::from("OsString"))
+        .unwrap();
+    lua.checked_set("os", &OsStr::new("OsStr")).unwrap();
+    lua.checked_set("path_owned", PathBuf::from("./path/owned"))
+        .unwrap();
+    lua.checked_set("path", Path::new("./path")).unwrap();
+
     let x: String = lua.get("a").unwrap();
     assert_eq!(x, "hello");
 
@@ -899,6 +921,17 @@ pub fn readwrite_strings() {
     assert_eq!(lua.get::<String, _>("c").unwrap(), "can you hear me?");
     assert_eq!(lua.get::<String, _>("d").unwrap(), "HELLO!!!");
 
+    assert_eq!(lua.get::<OsString, _>("os_owned").unwrap(), "OsString");
+    assert_eq!(lua.get::<OsString, _>("os").unwrap(), "OsStr");
+    assert_eq!(
+        lua.get::<PathBuf, _>("path_owned").unwrap(),
+        Path::new(".").join("path").join("owned")
+    );
+    assert_eq!(
+        lua.get::<PathBuf, _>("path").unwrap(),
+        Path::new(".").join("path")
+    );
+
     assert_eq!(lua.eval::<String>("return 'abc'").unwrap(), "abc");
     assert_eq!(
         lua.eval::<CString>("return 'abc'").unwrap().as_ref(),

tlua/src/values.rs

@@ -1,10 +1,12 @@
 use std::borrow::Cow;
 use std::convert::TryFrom;
-use std::ffi::{CStr, CString};
+use std::ffi::{CStr, CString, OsStr, OsString};
 use std::mem::MaybeUninit;
 use std::num::NonZeroI32;
 use std::ops::Deref;
 use std::os::raw::{c_int, c_void};
+use std::os::unix::ffi::{OsStrExt, OsStringExt};
+use std::path::{Path, PathBuf};
 use std::ptr::null_mut;
 use std::slice;
 use std::str;
@@ -419,6 +421,46 @@ impl_push_read! { CStr,
     }
 }
 
+impl_push_read! { OsString,
+    push_to_lua(&self, lua) {
+        push_string_impl!(self, lua)
+    }
+    push_into_lua(self, lua) {
+        push_string_impl!(self, lua)
+    }
+    read_at_position(lua, index) {
+        lua_read_string_impl!(lua, index,
+            |slice: &[u8], _| Ok(OsString::from_vec(slice.to_vec()))
+        )
+    }
+}
+
+impl_push_read! { OsStr,
+    push_to_lua(&self, lua) {
+        push_string_impl!(self, lua)
+    }
+}
+
+impl_push_read! { PathBuf,
+    push_to_lua(&self, lua) {
+        self.as_path().push_to_lua(lua)
+    }
+    push_into_lua(self, lua) {
+        let s = self.into_os_string();
+        push_string_impl!(s, lua)
+    }
+    read_at_position(lua, index) {
+        OsString::lua_read_at_position(lua, index).map(Into::into)
+    }
+}
+
+impl_push_read! { Path,
+    push_to_lua(&self, lua) {
+        let s = self.as_os_str();
+        push_string_impl!(s, lua)
+    }
+}
+
 /// String on the Lua stack.
 ///
 /// It is faster -but less convenient- to read a `StringInLua` rather than a `String` because you