refactor: remove writer from main tokenizer

Author: josecelano

src/parsers/error.rs

@@ -27,16 +27,16 @@ pub enum Error {
     /// The main parser peeks one byte ahead to know what kind of bencoded value
     /// is being parsed. If the byte read after peeking does not match the
     /// peeked byte, it means the input is being consumed somewhere else.
-    #[error("Read byte after peeking does match peeked byte; {0}; {1}")]
-    ReadByteAfterPeekingDoesMatchPeekedByte(ReadContext, WriteContext),
+    #[error("Read byte after peeking does match peeked byte; {0}")]
+    ReadByteAfterPeekingDoesMatchPeekedByte(ReadContext),
 
     /// Unrecognized first byte for new bencoded value.
     ///
     /// The main parser peeks one byte ahead to know what kind of bencoded value
     /// is being parsed. This error is raised when the peeked byte is not a
     /// valid first byte for a bencoded value.
-    #[error("Unrecognized first byte for new bencoded value; {0}; {1}")]
-    UnrecognizedFirstBencodeValueByte(ReadContext, WriteContext),
+    #[error("Unrecognized first byte for new bencoded value; {0}")]
+    UnrecognizedFirstBencodeValueByte(ReadContext),
 
     // Integers
     /// Unexpected byte parsing integer.

src/parsers/mod.rs

@@ -104,10 +104,7 @@ impl<R: Read> BencodeParser<R> {
     /// - It can't read from the input or write to the output.
     /// - The input is invalid Bencode.
     fn parse<W: Writer>(&mut self, writer: &mut W) -> Result<(), error::Error> {
-        let capture_output = Vec::new();
-        let mut null_writer = ByteWriter::new(capture_output);
-
-        while let Some(token) = self.tokenizer.next_token(&mut null_writer)? {
+        while let Some(token) = self.tokenizer.next_token()? {
             match token {
                 BencodeToken::Integer(integer_bytes) => {
                     self.begin_bencoded_value(BencodeType::Integer, writer)?;

src/parsers/tokenizer/mod.rs

@@ -4,9 +4,9 @@ pub mod string;
 
 use std::io::{self, Read};
 
-use super::error::{self, ReadContext, WriteContext};
+use super::error::{self, ReadContext};
 
-use crate::rw::{byte_reader::ByteReader, byte_writer::ByteWriter, writer::Writer};
+use crate::rw::{byte_reader::ByteReader, byte_writer::ByteWriter};
 
 /* TODO:
 
@@ -50,14 +50,11 @@ impl<R: Read> BencodeTokenizer<R> {
     /// Will return an error if:
     ///
     /// - It can't read from the input.
-    pub fn next_token<W: Writer>(
-        &mut self,
-        writer: &mut W,
-    ) -> Result<Option<BencodeToken>, error::Error> {
+    pub fn next_token(&mut self) -> Result<Option<BencodeToken>, error::Error> {
         let capture_output = Vec::new();
         let mut null_writer = ByteWriter::new(capture_output);
 
-        let opt_peeked_byte = Self::peek_byte(&mut self.byte_reader, &null_writer)?;
+        let opt_peeked_byte = Self::peek_byte(&mut self.byte_reader)?;
 
         match opt_peeked_byte {
             Some(peeked_byte) => {
@@ -71,37 +68,21 @@ impl<R: Read> BencodeTokenizer<R> {
                         Ok(Some(BencodeToken::String(value)))
                     }
                     BENCODE_BEGIN_LIST => {
-                        let _byte = Self::read_peeked_byte(
-                            peeked_byte,
-                            &mut self.byte_reader,
-                            &null_writer,
-                        )?;
+                        let _byte = Self::read_peeked_byte(peeked_byte, &mut self.byte_reader)?;
                         Ok(Some(BencodeToken::BeginList))
                     }
                     BENCODE_BEGIN_DICT => {
-                        let _byte = Self::read_peeked_byte(
-                            peeked_byte,
-                            &mut self.byte_reader,
-                            &null_writer,
-                        )?;
+                        let _byte = Self::read_peeked_byte(peeked_byte, &mut self.byte_reader)?;
                         Ok(Some(BencodeToken::BeginDict))
                     }
                     BENCODE_END_LIST_OR_DICT => {
-                        let _byte = Self::read_peeked_byte(
-                            peeked_byte,
-                            &mut self.byte_reader,
-                            &null_writer,
-                        )?;
+                        let _byte = Self::read_peeked_byte(peeked_byte, &mut self.byte_reader)?;
                         Ok(Some(BencodeToken::EndListOrDict))
                     }
                     b'\n' => {
                         // todo: we should not return any token and continue to the next token.
                         // Ignore line breaks at the beginning, the end, or between values
-                        let _byte = Self::read_peeked_byte(
-                            peeked_byte,
-                            &mut self.byte_reader,
-                            &null_writer,
-                        )?;
+                        let _byte = Self::read_peeked_byte(peeked_byte, &mut self.byte_reader)?;
                         Ok(Some(BencodeToken::LineBreak))
                     }
                     _ => Err(error::Error::UnrecognizedFirstBencodeValueByte(
@@ -110,11 +91,6 @@ impl<R: Read> BencodeTokenizer<R> {
                             pos: self.byte_reader.input_byte_counter(),
                             latest_bytes: self.byte_reader.captured_bytes(),
                         },
-                        WriteContext {
-                            byte: Some(peeked_byte),
-                            pos: writer.output_byte_counter(),
-                            latest_bytes: writer.captured_bytes(),
-                        },
                     )),
                 }
             }
@@ -131,10 +107,9 @@ impl<R: Read> BencodeTokenizer<R> {
     ///
     /// - It can't read from the input.
     /// - The byte read is not the expected one (the previously peeked byte).
-    fn read_peeked_byte<W: Writer>(
+    fn read_peeked_byte(
         peeked_byte: u8,
         reader: &mut ByteReader<R>,
-        writer: &W,
     ) -> Result<Option<u8>, error::Error> {
         match reader.read_byte() {
             Ok(byte) => {
@@ -147,11 +122,6 @@ impl<R: Read> BencodeTokenizer<R> {
                         pos: reader.input_byte_counter(),
                         latest_bytes: reader.captured_bytes(),
                     },
-                    WriteContext {
-                        byte: Some(byte),
-                        pos: writer.output_byte_counter(),
-                        latest_bytes: writer.captured_bytes(),
-                    },
                 ))
             }
             Err(err) => {
@@ -169,10 +139,7 @@ impl<R: Read> BencodeTokenizer<R> {
     /// # Errors
     ///
     /// Will return and errors if it can't read from the input.
-    fn peek_byte<W: Writer>(
-        reader: &mut ByteReader<R>,
-        _writer: &W,
-    ) -> Result<Option<u8>, error::Error> {
+    fn peek_byte(reader: &mut ByteReader<R>) -> Result<Option<u8>, error::Error> {
         match reader.peek_byte() {
             Ok(byte) => Ok(Some(byte)),
             Err(err) => {