From 8a98d4fee2172d5ac53e74bcc95cd39aa68492a3 Mon Sep 17 00:00:00 2001 From: Jesse Luehrs Date: Fri, 3 Dec 2021 19:43:06 -0500 Subject: remove async stuff, clean up everything else will reintroduce the async stuff in a future commit --- src/creator.rs | 20 ++++++++------ src/error.rs | 28 ++++++++------------ src/frame.rs | 3 +-- src/lib.rs | 8 ------ src/parser.rs | 4 +++ src/reader.rs | 56 --------------------------------------- src/writer.rs | 83 ---------------------------------------------------------- 7 files changed, 28 insertions(+), 174 deletions(-) delete mode 100644 src/reader.rs delete mode 100644 src/writer.rs (limited to 'src') diff --git a/src/creator.rs b/src/creator.rs index fac57bb..f4745cc 100644 --- a/src/creator.rs +++ b/src/creator.rs @@ -11,6 +11,7 @@ pub struct Creator { impl Creator { /// Creates a new `Creator` instance. + #[must_use] pub fn new() -> Self { Self::default() } @@ -29,15 +30,20 @@ impl Creator { /// Note that this is not guaranteed to do the correct thing unless the /// `cur_time` parameters given in each `frame_at` call are /// non-decreasing. + #[allow(clippy::missing_panics_doc)] pub fn frame_at( &mut self, cur_time: std::time::Instant, data: &[u8], ) -> crate::frame::Frame { + // this is triggering incorrectly - the code transformation it + // suggests doesn't work due to lifetime issues + #[allow(clippy::option_if_let_else)] let base_time = if let Some(base_time) = &self.base_time { base_time } else { self.base_time = Some(cur_time); + // this unwrap is safe because we just set the value to Some self.base_time.as_ref().unwrap() }; crate::frame::Frame { @@ -63,16 +69,14 @@ mod test { let base_time = std::time::Instant::now(); let zero_frame: Vec = - std::convert::TryFrom::try_from(creator.frame_at(base_time, b"")) - .unwrap(); + TryFrom::try_from(creator.frame_at(base_time, b"")).unwrap(); assert_eq!(zero_frame, vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); - let data_frame: Vec = - std::convert::TryFrom::try_from(creator.frame_at( - base_time + std::time::Duration::new(38, 123_456_000), - b"\x1b[2Jfoobar", - )) - .unwrap(); + let data_frame: Vec = TryFrom::try_from(creator.frame_at( + base_time + std::time::Duration::new(38, 123_456_000), + b"\x1b[2Jfoobar", + )) + .unwrap(); assert_eq!( data_frame, vec![ diff --git a/src/error.rs b/src/error.rs index c106d02..9ca35a8 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,30 +1,24 @@ /// Errors potentially returned by this crate. -#[derive(Debug, snafu::Snafu)] -#[snafu(visibility(pub))] +#[derive(Debug)] pub enum Error { - /// eof - #[snafu(display("eof"))] - EOF, - /// failed to create ttyrec frame: got N bytes of data but ttyrec frames /// can be at most M bytes - #[snafu(display("failed to create ttyrec frame: got {} bytes of data, but ttyrec frames can be at most {} bytes", input, u32::max_value()))] FrameTooBig { input: usize }, /// failed to create ttyrec frame: got N seconds but ttyrec frames can be /// at most M seconds - #[snafu(display("failed to create ttyrec frame: got {} seconds, but ttyrecs can be at most {} seconds", input, u32::max_value()))] FrameTooLong { input: u64 }, +} - /// failed to read from file - #[cfg(feature = "async")] - #[snafu(display("failed to read from file: {}", source))] - ReadFile { source: tokio::io::Error }, - - /// failed to write to file - #[cfg(feature = "async")] - #[snafu(display("failed to write to file: {}", source))] - WriteFile { source: tokio::io::Error }, +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::FrameTooBig { input } => write!(f, "failed to create ttyrec frame: got {} bytes of data, but ttyrec frames can be at most {} bytes", input, u32::max_value()), + Self::FrameTooLong { input } => write!(f, "failed to create ttyrec frame: got {} seconds, but ttyrecs can be at most {} seconds", input, u32::max_value()), + } + } } +impl std::error::Error for Error {} + pub type Result = std::result::Result; diff --git a/src/frame.rs b/src/frame.rs index c617056..71b3988 100644 --- a/src/frame.rs +++ b/src/frame.rs @@ -18,7 +18,7 @@ pub struct Frame { pub data: Vec, } -impl std::convert::TryFrom for Vec { +impl TryFrom for Vec { type Error = crate::error::Error; fn try_from(frame: Frame) -> crate::error::Result { @@ -45,7 +45,6 @@ impl std::convert::TryFrom for Vec { #[cfg(test)] mod test { use super::*; - use std::convert::TryFrom as _; #[test] fn test_basic() { diff --git a/src/lib.rs b/src/lib.rs index b0d6296..d774aa3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -24,11 +24,3 @@ mod frame; pub use frame::Frame; mod parser; pub use parser::Parser; -#[cfg(feature = "async")] -mod reader; -#[cfg(feature = "async")] -pub use reader::Reader; -#[cfg(feature = "async")] -mod writer; -#[cfg(feature = "async")] -pub use writer::Writer; diff --git a/src/parser.rs b/src/parser.rs index 45b900e..126eae3 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -34,6 +34,7 @@ pub struct Parser { impl Parser { /// Create a new `Parser`. + #[must_use] pub fn new() -> Self { Self::default() } @@ -48,6 +49,7 @@ impl Parser { /// If a complete frame is found, the bytes for that frame will be removed /// from the internal buffer and the frame object will be returned. If a /// complete frame is not found, this method will return `None`. + #[allow(clippy::missing_panics_doc)] pub fn next_frame(&mut self) -> Option { let header = if let Some(header) = &self.read_state { header @@ -56,6 +58,7 @@ impl Parser { return None; } + // these unwraps are guaranteed safe by the length check above let secs1 = self.reading.pop_front().unwrap(); let secs2 = self.reading.pop_front().unwrap(); let secs3 = self.reading.pop_front().unwrap(); @@ -106,6 +109,7 @@ impl Parser { /// each frame timestamp after that should be offset by that same amount. /// /// Returns `None` if no frames have been read yet. + #[must_use] pub fn offset(&self) -> Option { self.offset } diff --git a/src/reader.rs b/src/reader.rs deleted file mode 100644 index ff5f7f9..0000000 --- a/src/reader.rs +++ /dev/null @@ -1,56 +0,0 @@ -use snafu::ResultExt as _; - -/// Reads ttyrec frames from a `tokio::io::AsyncRead` instance. -pub struct Reader { - reader: R, - parser: crate::parser::Parser, - read_buf: [u8; 4096], - done_reading: bool, -} - -impl Reader { - /// Creates a new `Reader` from a `tokio::io::AsyncRead` instance. - pub fn new(reader: R) -> Self { - Self { - reader, - parser: crate::parser::Parser::new(), - read_buf: [0; 4096], - done_reading: false, - } - } - - /// Polls to see if a new frame can be read. - /// - /// Returns `Ok(Async::Ready(Some(frame)))` if a frame is available, - /// `Ok(Async::Ready(None))` if the underlying reader is done, and - /// `Ok(Async::NotReady)` if not enough bytes have been read for a full - /// frame. - pub fn poll_read( - &mut self, - ) -> futures::Poll, crate::error::Error> { - loop { - if let Some(frame) = self.parser.next_frame() { - return Ok(futures::Async::Ready(Some(frame))); - } else if self.done_reading { - return Ok(futures::Async::Ready(None)); - } - - let n = futures::try_ready!(self - .reader - .poll_read(&mut self.read_buf) - .context(crate::error::ReadFile)); - if n > 0 { - self.parser.add_bytes(&self.read_buf[..n]); - } else { - self.done_reading = true; - } - } - } - - /// How much the timestamps in this file should be offset by. - /// - /// See `Parser::offset`. - pub fn offset(&self) -> Option { - self.parser.offset() - } -} diff --git a/src/writer.rs b/src/writer.rs deleted file mode 100644 index 8f79737..0000000 --- a/src/writer.rs +++ /dev/null @@ -1,83 +0,0 @@ -use snafu::ResultExt as _; - -/// Writes ttyrec frames to a `tokio::io::AsyncWrite` instance. -pub struct Writer { - writer: W, - creator: crate::creator::Creator, - to_write: std::collections::VecDeque, -} - -impl Writer { - /// Creates a new `Writer` from a `tokio::io::AsyncWrite` instance. - pub fn new(writer: W) -> Self { - Self { - writer, - creator: crate::creator::Creator::new(), - to_write: std::collections::VecDeque::new(), - } - } - - /// Generates a new ttyrec frame with the given data. - /// - /// Equivalent to calling `frame_at` and passing - /// `std::time::Instant::now()` as the `time` parameter. - pub fn frame(&mut self, data: &[u8]) -> crate::error::Result<()> { - self.frame_at(std::time::Instant::now(), data) - } - - /// Generates a new ttyrec frame with the given data at the given time. - /// - /// The frame data will be stored on this object until written out by - /// calls to `poll_write`. - /// - /// Note that this is not guaranteed to do the correct thing unless the - /// `cur_time` parameters given in each `frame_at` call are - /// non-decreasing. - pub fn frame_at( - &mut self, - time: std::time::Instant, - data: &[u8], - ) -> crate::error::Result<()> { - let frame = self.creator.frame_at(time, data); - let bytes: Vec = std::convert::TryFrom::try_from(frame)?; - self.to_write.extend(bytes.iter()); - Ok(()) - } - - /// Attempt to write serialized ttyrec frames to the underlying writer. - /// - /// Writes data from the previous calls to `frame` and `frame_at`. Returns - /// `Ok(Async::Ready(()))` if all bytes were written, and - /// `Ok(Async::NotReady)` otherwise. - pub fn poll_write(&mut self) -> futures::Poll<(), crate::error::Error> { - loop { - if self.to_write.is_empty() { - return Ok(futures::Async::Ready(())); - } - - let (a, b) = self.to_write.as_slices(); - let buf = if a.is_empty() { b } else { a }; - - let n = futures::try_ready!(self - .writer - .poll_write(buf) - .context(crate::error::WriteFile)); - - if n > 0 { - for _ in 0..n { - self.to_write.pop_front(); - } - } else { - return Err(crate::error::Error::EOF); - } - } - } - - /// Returns `true` if there are still bytes that need to be written. - /// - /// It is only necessary to call `poll_write` if this method returns - /// `true`. - pub fn needs_write(&self) -> bool { - !self.to_write.is_empty() - } -} -- cgit v1.2.3-54-g00ecf