Add ReaderWithContext

Author: willchet

src/io/mod.rs

@@ -306,3 +306,72 @@ where
         Self::writer_with_context(self, format!("{msg}: '{path}'", path = file.as_ref().display()))
     }
 }
+
+/// A wrapper around a reader of type `R` such that error context is added to
+/// any failed reads.
+pub struct ReaderWithContext<R> {
+    /// The inner reader.
+    reader:      R,
+    /// The context to add to any failed reads.
+    description: String,
+}
+
+impl<R> Read for ReaderWithContext<R>
+where
+    R: Read,
+{
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        Ok(self.reader.read(buf).with_context(&self.description)?)
+    }
+
+    fn read_vectored(&mut self, bufs: &mut [std::io::IoSliceMut<'_>]) -> std::io::Result<usize> {
+        Ok(self.reader.read_vectored(bufs).with_context(&self.description)?)
+    }
+
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> std::io::Result<usize> {
+        Ok(self.reader.read_to_end(buf).with_context(&self.description)?)
+    }
+
+    fn read_to_string(&mut self, buf: &mut String) -> std::io::Result<usize> {
+        Ok(self.reader.read_to_string(buf).with_context(&self.description)?)
+    }
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
+        Ok(self.reader.read_exact(buf).with_context(&self.description)?)
+    }
+}
+
+/// An extension trait for [`Read`] allowing additional context to be added to
+/// each failed read (via [`ReaderWithContext`]).
+pub trait ReaderWithErrorContext: Sized {
+    /// Wraps any errors that get produced during reading in an
+    /// [`ErrorWithContext`] with the given description.
+    ///
+    /// The `description` field may be anything implementing `Into<String>`.
+    /// Passing an owned `String` avoids an extra allocation.
+    ///
+    /// [`ErrorWithContext`]: zoe::data::err::ErrorWithContext
+    fn reader_with_context(self, description: impl Into<String>) -> ReaderWithContext<Self>;
+
+    /// Convenience function for adding file context to any produced errors.
+    ///
+    /// The context will be formatted as `msg: file`. The `msg` field may be
+    /// anything implementing [`Display`].
+    fn reader_with_file_context(self, msg: impl Display, file: impl AsRef<Path>) -> ReaderWithContext<Self>;
+}
+
+impl<R> ReaderWithErrorContext for R
+where
+    R: Read,
+{
+    fn reader_with_context(self, description: impl Into<String>) -> ReaderWithContext<Self> {
+        ReaderWithContext {
+            reader:      self,
+            description: description.into(),
+        }
+    }
+
+    fn reader_with_file_context(self, msg: impl Display, file: impl AsRef<Path>) -> ReaderWithContext<Self> {
+        Self::reader_with_context(self, format!("{msg}: '{path}'", path = file.as_ref().display()))
+    }
+}

src/io/open_options/context.rs

@@ -1,8 +1,13 @@
 use crate::io::{
-    IterWithContext, IterWithErrorContext, PairedWriters, RecordReaders, RecordWriters, WriterWithContext,
-    WriterWithErrorContext,
+    IterWithContext, IterWithErrorContext, PairedWriters, ReaderWithContext, ReaderWithErrorContext, RecordReaders,
+    RecordWriters, WriterWithContext, WriterWithErrorContext,
+};
+use std::{
+    error::Error,
+    fmt::Display,
+    io::{Read, Write},
+    path::Path,
 };
-use std::{error::Error, fmt::Display, io::Write, path::Path};
 use zoe::data::err::{ErrorWithContext, WithErrorContext};
 
 /// An enum to represent the possible reader types for [`InputOptions`], for the
@@ -231,7 +236,7 @@ impl InputContext<'_> {
     }
 
     /// Wrap the fallible iterators contained in a [`RecordReaders`] so that
-    /// failed reads have context added.
+    /// items that are errors have context added.
     pub fn add_paired_iter_context<I>(&self, iters: RecordReaders<I>) -> RecordReaders<IterWithContext<I>>
     where
         I: IterWithErrorContext, {
@@ -242,6 +247,31 @@ impl InputContext<'_> {
                 .map(|iter| InputContext::add_iter_context(iter, self.reader2, self.input2)),
         }
     }
+
+    /// Adds context to a reader, so that failed reads have context.
+    ///
+    /// `reader` and `input` should be corresponding fields in an
+    /// [`InputContext`] struct. The context will include the path if available
+    /// and the record type.
+    pub fn add_reader_context<R>(reader: R, input: InputType) -> ReaderWithContext<R>
+    where
+        R: Read, {
+        match input {
+            InputType::File(path) => reader.reader_with_file_context("Failed to read from file", path),
+            InputType::Stdin => reader.reader_with_context("Failed to read from stdin"),
+        }
+    }
+
+    /// Wrap the readers contained in a [`RecordReaders`] so that failed reads
+    /// have context added.
+    pub fn add_paired_reader_context<R>(&self, readers: RecordReaders<R>) -> RecordReaders<ReaderWithContext<R>>
+    where
+        R: Read, {
+        RecordReaders {
+            reader1: InputContext::add_reader_context(readers.reader1, self.input1),
+            reader2: readers.reader2.map(|r| InputContext::add_reader_context(r, self.input2)),
+        }
+    }
 }
 
 /// The complete context for [`OutputOptions`] necessary for displaying any