feat(fs)!: Reader now supports non-utf8 files

- reader() now returns a Result
- Reader::as_str() now returns a Result
- Reader::lines() now returns a Result

examples/get.rs

@@ -89,7 +89,7 @@ fn read_file(file: &FileHandle) -> kxio::Result<()> {
 
     // Creates a `Reader` which loaded the file into memory.
     let reader: kxio::fs::Reader = file.reader()?;
-    let contents: &str = reader.as_str();
+    let contents: &str = reader.as_str()?;
     println!("{contents}");
 
     Ok(())
@@ -106,6 +106,7 @@ fn delete_file(file: FileHandle) -> kxio::Result<()> {
 
 #[cfg(test)]
 mod tests {
+    use assert2::let_assert;
     use http::StatusCode;
 
     use super::*;
@@ -146,7 +147,7 @@ mod tests {
         // Read the file
         let file = fs.file(&file_path);
         let reader = file.reader().expect("reader");
-        let contents = reader.as_str();
+        let_assert!(Ok(contents) = reader.as_str());
 
         assert_eq!(contents, "contents");
 

src/fs/reader.rs

@@ -8,13 +8,13 @@ use super::Error;
 /// A reader for a file.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct Reader {
-    contents: String,
+    contents: Vec<u8>,
 }
 impl Reader {
     #[tracing::instrument]
     pub(super) fn new(path: &Path) -> Result<Self> {
         tracing::debug!("std::fs::read_to_string");
-        let contents = std::fs::read_to_string(path).map_err(Error::Io)?;
+        let contents = std::fs::read(path).map_err(Error::Io)?;
         tracing::debug!(len = contents.len(), "contents");
         Ok(Self { contents })
     }
@@ -32,8 +32,8 @@ impl Reader {
     /// #    Ok(())
     /// # }
     /// ```
-    pub fn as_str(&self) -> &str {
-        &self.contents
+    pub fn as_str(&self) -> Result<&str> {
+        std::str::from_utf8(&self.contents).map_err(Error::Utf8Error)
     }
 
     /// Returns an iterator over the lines in the file.
@@ -49,8 +49,8 @@ impl Reader {
     /// #    Ok(())
     /// # }
     /// ```
-    pub fn lines(&self) -> Lines<'_> {
-        self.contents.lines()
+    pub fn lines(&self) -> Result<Lines<'_>> {
+        self.as_str().map(|s| s.lines())
     }
 
     /// Returns the contents of the file as bytes.
@@ -67,11 +67,11 @@ impl Reader {
     /// # }
     /// ```
     pub fn bytes(&self) -> &[u8] {
-        self.contents.as_bytes()
+        &self.contents
     }
 }
 impl Display for Reader {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.contents)
+        write!(f, "{}", self.as_str().map_err(|_| std::fmt::Error)?)
     }
 }

src/fs/result.rs

@@ -12,6 +12,8 @@ pub enum Error {
 
     IoString(String),
 
+    Utf8Error(std::str::Utf8Error),
+
     #[display("Path access attempted outside of base ({base:?}): {path:?}")]
     PathTraversal {
         base: PathBuf,
@@ -34,6 +36,7 @@ impl Clone for Error {
         match self {
             Error::Io(err) => Error::IoString(err.to_string()),
             Error::IoString(err) => Error::IoString(err.clone()),
+            Error::Utf8Error(err) => Error::Utf8Error(*err),
             Error::PathTraversal { base, path } => Error::PathTraversal {
                 base: base.clone(),
                 path: path.clone(),

tests/fs.rs

@@ -723,7 +723,7 @@ mod file {
                 file.write(&contents).expect("write");
 
                 let reader = file.reader().expect("reader");
-                let string = reader.as_str();
+                let string = reader.as_str().expect("as_str");
 
                 assert_eq!(string, contents);
             }
@@ -743,7 +743,7 @@ mod file {
                 file.write(&contents).expect("write");
 
                 let reader = file.reader().expect("reader");
-                let lines = reader.lines().collect::<Vec<_>>();
+                let lines = reader.lines().expect("lines").collect::<Vec<_>>();
 
                 assert_eq!(lines, vec!["line 1", "line 2", &line3]);
             }
@@ -759,7 +759,7 @@ mod file {
                 file.write("line 1\nline 2").expect("write");
 
                 let reader = file.reader().expect("reader");
-                let lines = reader.lines().collect::<Vec<_>>();
+                let lines = reader.lines().expect("lines").collect::<Vec<_>>();
 
                 assert_eq!(lines, vec!["line 1", "line 2"]);