Add an IsReadWrite trait to expose cap_primitives::fs::is_read_write.

Author: sunfishcode

Cargo.toml

@@ -40,7 +40,14 @@ winx = "0.22.0"
 
 [features]
 default = []
-fs_utf8 = ["cap-std/fs_utf8", "cap-async-std/fs_utf8"]
+fs_utf8 = [
+    "cap-std/fs_utf8",
+    "cap-fs-ext/fs_utf8",
+]
+async_std_fs_utf8 = [
+    "cap-async-std/fs_utf8",
+    "cap-fs-ext/async_std_fs_utf8"
+]
 
 [badges]
 maintenance = { status = "actively-developed" }

cap-async-std/Cargo.toml

@@ -19,9 +19,9 @@ async-std = { version = "1.8.0", features = ["attributes"] }
 cap-primitives = { path = "../cap-primitives", version = "^0.10.1-alpha.0"}
 unsafe-io = "0.2.0"
 
-[badges]
-maintenance = { status = "actively-developed" }
-
 [features]
 default = []
 fs_utf8 = ["arf-strings"]
+
+[badges]
+maintenance = { status = "actively-developed" }

cap-fs-ext/Cargo.toml

@@ -23,9 +23,10 @@ unsafe-io = "0.2.0"
 
 [features]
 default = ["std"]
-fs_utf8 = ["arf-strings", "cap-std/fs_utf8", "cap-async-std/fs_utf8"]
+fs_utf8 = ["arf-strings", "cap-std/fs_utf8"]
 std = ["cap-std"]
 async_std = ["cap-async-std", "async-std"]
+async_std_fs_utf8 = ["cap-async-std/fs_utf8"]
 
 [badges]
 maintenance = { status = "actively-developed" }

cap-fs-ext/src/is_read_write.rs

@@ -0,0 +1,61 @@
+use cap_primitives::fs::is_read_write;
+use std::io;
+use unsafe_io::AsUnsafeFile;
+
+/// A trait for the `is_read_write` function for `File` types.
+///
+/// This is only implemented for `File` types; for arbitrary I/O handles, use
+/// [`system_interface::io::IsReadWrite`] instead.
+///
+/// [`system_interface::io::IsReadWrite`]: https://docs.rs/system-interface/latest/system_interface/io/trait.ReadReady.html
+pub trait IsReadWrite {
+    /// Test whether the given file is readable and/or writable.
+    fn is_read_write(&self) -> io::Result<(bool, bool)>;
+}
+
+impl IsReadWrite for std::fs::File {
+    #[inline]
+    fn is_read_write(&self) -> io::Result<(bool, bool)> {
+        is_read_write(self)
+    }
+}
+
+#[cfg(all(feature = "std"))]
+impl IsReadWrite for cap_std::fs::File {
+    #[inline]
+    fn is_read_write(&self) -> io::Result<(bool, bool)> {
+        is_read_write(&self.as_file_view())
+    }
+}
+
+#[cfg(all(feature = "std", feature = "fs_utf8"))]
+impl IsReadWrite for cap_std::fs_utf8::File {
+    #[inline]
+    fn is_read_write(&self) -> io::Result<(bool, bool)> {
+        is_read_write(&self.as_file_view())
+    }
+}
+
+#[cfg(all(feature = "async_std"))]
+impl IsReadWrite for async_std::fs::File {
+    #[inline]
+    fn is_read_write(&self) -> io::Result<(bool, bool)> {
+        is_read_write(&self.as_file_view())
+    }
+}
+
+#[cfg(all(feature = "async_std"))]
+impl IsReadWrite for cap_async_std::fs::File {
+    #[inline]
+    fn is_read_write(&self) -> io::Result<(bool, bool)> {
+        is_read_write(&self.as_file_view())
+    }
+}
+
+#[cfg(all(feature = "async_std", feature = "fs_utf8"))]
+impl IsReadWrite for cap_async_std::fs_utf8::File {
+    #[inline]
+    fn is_read_write(&self) -> io::Result<(bool, bool)> {
+        is_read_write(&self.as_file_view())
+    }
+}

cap-fs-ext/src/lib.rs

@@ -11,6 +11,7 @@
 
 mod dir_ext;
 mod file_type_ext;
+mod is_read_write;
 mod metadata_ext;
 mod open_options_follow_ext;
 mod reopen;
@@ -19,6 +20,7 @@ mod reopen;
 pub use dir_ext::DirExtUtf8;
 pub use dir_ext::{DirExt, SystemTimeSpec};
 pub use file_type_ext::FileTypeExt;
+pub use is_read_write::IsReadWrite;
 pub use metadata_ext::MetadataExt;
 pub use open_options_follow_ext::{FollowSymlinks, OpenOptionsFollowExt};
 pub use reopen::Reopen;

cap-fs-ext/src/reopen.rs

@@ -53,16 +53,23 @@ impl Reopen for cap_std::fs_utf8::File {
     }
 }
 
+#[cfg(feature = "async_std")]
+impl Reopen for async_std::fs::File {
+    #[inline]
+    fn reopen(&self, options: &OpenOptions) -> io::Result<Self> {
+        let file = reopen(&self.as_file_view(), options)?;
+        let unsafe_file = file.into_unsafe_file();
+        Ok(unsafe { async_std::fs::File::from_unsafe_file(unsafe_file) })
+    }
+}
+
 #[cfg(feature = "async_std")]
 impl Reopen for cap_async_std::fs::File {
     #[inline]
     fn reopen(&self, options: &OpenOptions) -> io::Result<Self> {
         let file = reopen(&self.as_file_view(), options)?;
-        Ok(unsafe {
-            Self::from_std(async_std::fs::File::from_unsafe_file(
-                file.into_unsafe_file(),
-            ))
-        })
+        let unsafe_file = file.into_unsafe_file();
+        Ok(unsafe { Self::from_std(async_std::fs::File::from_unsafe_file(unsafe_file)) })
     }
 }
 
@@ -71,10 +78,7 @@ impl Reopen for cap_async_std::fs_utf8::File {
     #[inline]
     fn reopen(&self, options: &OpenOptions) -> io::Result<Self> {
         let file = reopen(&self.as_file_view(), options)?;
-        Ok(unsafe {
-            Self::from_std(async_std::fs::File::from_unsafe_file(
-                file.into_unsafe_file(),
-            ))
-        })
+        let unsafe_file = file.into_unsafe_file();
+        Ok(unsafe { Self::from_std(async_std::fs::File::from_unsafe_file(unsafe_file)) })
     }
 }

cap-primitives/src/windows/fs/is_read_write_impl.rs

@@ -4,6 +4,7 @@ pub(crate) fn is_read_write_impl(file: &fs::File) -> io::Result<(bool, bool)> {
     let handle = file.as_raw_handle();
     let access_mode = winx::file::query_access_information(handle)?;
     let read = access_mode.contains(winx::file::AccessMode::FILE_READ_DATA);
-    let write = access_mode.contains(winx::file::AccessMode::FILE_WRITE_DATA);
+    let write = access_mode.contains(winx::file::AccessMode::FILE_WRITE_DATA)
+        || access_mode.contains(winx::file::AccessMode::FILE_APPEND_DATA);
     Ok((read, write))
 }

cap-std/Cargo.toml

@@ -18,9 +18,9 @@ arf-strings = { version = "0.3.0", optional = true }
 cap-primitives = { path = "../cap-primitives", version = "^0.10.1-alpha.0"}
 unsafe-io = "0.2.0"
 
-[badges]
-maintenance = { status = "actively-developed" }
-
 [features]
 default = []
 fs_utf8 = ["arf-strings"]
+
+[badges]
+maintenance = { status = "actively-developed" }

cap-time-ext/Cargo.toml

@@ -22,7 +22,7 @@ posish = "0.5.2"
 
 [target.'cfg(windows)'.dependencies]
 once_cell = "1.5.2"
-winx = "0.21.0"
+winx = "0.22.0"
 
 [badges]
 maintenance = { status = "actively-developed" }

tests/is-read-write.rs

@@ -0,0 +1,43 @@
+#[macro_use]
+mod sys_common;
+
+use cap_fs_ext::{IsReadWrite, OpenOptions};
+use sys_common::io::tmpdir;
+
+#[test]
+fn basic_is_read_write() {
+    let tmpdir = tmpdir();
+
+    let file = check!(tmpdir.open_with(
+        "file",
+        OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .read(true)
+    ));
+    assert_eq!(check!(file.is_read_write()), (true, true));
+
+    let file = check!(tmpdir.open_with("file", OpenOptions::new().append(true).read(true)));
+    assert_eq!(check!(file.is_read_write()), (true, true));
+
+    let file = check!(tmpdir.open_with(
+        "file",
+        OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .read(false)
+    ));
+    assert_eq!(check!(file.is_read_write()), (false, true));
+
+    let file = check!(tmpdir.open_with(
+        "file",
+        OpenOptions::new()
+            .create(false)
+            .truncate(false)
+            .write(false)
+            .read(true)
+    ));
+    assert_eq!(check!(file.is_read_write()), (true, false));
+}