refactor: remove writer from tokenizer string parser

Author: josecelano

src/parsers/error.rs

@@ -62,20 +62,20 @@ pub enum Error {
     ///
     /// The string parser found an invalid byte for the string length. The
     /// length can only be made of digits (0-9).
-    #[error("Invalid string length byte, expected a digit; {0}; {1}")]
-    InvalidStringLengthByte(ReadContext, WriteContext),
+    #[error("Invalid string length byte, expected a digit; {0}")]
+    InvalidStringLengthByte(ReadContext),
 
     /// Unexpected end of input parsing string length.
     ///
     /// The input ends before the string length ends.
-    #[error("Unexpected end of input parsing string length; {0}; {1}")]
-    UnexpectedEndOfInputParsingStringLength(ReadContext, WriteContext),
+    #[error("Unexpected end of input parsing string length; {0}")]
+    UnexpectedEndOfInputParsingStringLength(ReadContext),
 
     /// Unexpected end of input parsing string value.
     ///
     /// The input ends before the string value ends.
-    #[error("Unexpected end of input parsing string value; {0}; {1}")]
-    UnexpectedEndOfInputParsingStringValue(ReadContext, WriteContext),
+    #[error("Unexpected end of input parsing string value; {0}")]
+    UnexpectedEndOfInputParsingStringValue(ReadContext),
 
     // Lists
     /// Unexpected end of input parsing list. Expecting first list item or list end.

src/parsers/mod.rs

@@ -4,9 +4,7 @@
 //! ``BencodeParser`` is the main parser. It is generic over the type of the
 //! input buffer.
 pub mod error;
-pub mod integer;
 pub mod stack;
-pub mod string;
 pub mod tokenizer;
 
 /* TODO:

src/parsers/tokenizer/integer.rs

@@ -134,42 +134,30 @@ fn next_byte<R: Read>(reader: &mut ByteReader<R>) -> Result<u8, Error> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        parsers::{error::Error, integer::parse},
-        rw::{byte_reader::ByteReader, string_writer::StringWriter},
-    };
+    use crate::{parsers::error::Error, rw::byte_reader::ByteReader};
 
-    fn bencode_to_json_unchecked(input_buffer: &[u8]) -> String {
-        let mut output = String::new();
+    use super::parse;
 
-        parse_bencode(input_buffer, &mut output).expect("Bencode to JSON conversion failed");
-
-        output
+    fn bencode_to_json_unchecked(input_buffer: &[u8]) -> Vec<u8> {
+        parse_bencode(input_buffer).expect("Bencode to JSON conversion failed")
     }
 
-    fn try_bencode_to_json(input_buffer: &[u8]) -> Result<String, Error> {
-        let mut output = String::new();
-
-        match parse_bencode(input_buffer, &mut output) {
-            Ok(_value) => Ok(output),
-            Err(err) => Err(err),
-        }
+    fn try_bencode_to_json(input_buffer: &[u8]) -> Result<Vec<u8>, Error> {
+        parse_bencode(input_buffer)
     }
 
-    fn parse_bencode(input_buffer: &[u8], output: &mut String) -> Result<Vec<u8>, Error> {
+    fn parse_bencode(input_buffer: &[u8]) -> Result<Vec<u8>, Error> {
         let mut reader = ByteReader::new(input_buffer);
 
-        let mut writer = StringWriter::new(output);
-
-        parse(&mut reader, &mut writer)
+        parse(&mut reader)
     }
 
     mod for_helpers {
         use crate::parsers::tokenizer::integer::tests::try_bencode_to_json;
 
         #[test]
         fn bencode_to_json_wrapper_succeeds() {
-            assert_eq!(try_bencode_to_json(b"i0e").unwrap(), "0".to_string());
+            assert_eq!(try_bencode_to_json(b"i0e").unwrap(), "0".as_bytes());
         }
 
         #[test]
@@ -180,22 +168,22 @@ mod tests {
 
     #[test]
     fn zero() {
-        assert_eq!(bencode_to_json_unchecked(b"i0e"), "0".to_string());
+        assert_eq!(bencode_to_json_unchecked(b"i0e"), "0".as_bytes());
     }
 
     #[test]
     fn one_digit_integer() {
-        assert_eq!(bencode_to_json_unchecked(b"i1e"), "1".to_string());
+        assert_eq!(bencode_to_json_unchecked(b"i1e"), "1".as_bytes());
     }
 
     #[test]
     fn two_digits_integer() {
-        assert_eq!(bencode_to_json_unchecked(b"i42e"), "42".to_string());
+        assert_eq!(bencode_to_json_unchecked(b"i42e"), "42".as_bytes());
     }
 
     #[test]
     fn negative_integer() {
-        assert_eq!(bencode_to_json_unchecked(b"i-1e"), "-1".to_string());
+        assert_eq!(bencode_to_json_unchecked(b"i-1e"), "-1".as_bytes());
     }
 
     mod it_should_fail {

src/parsers/tokenizer/mod.rs

@@ -6,11 +6,10 @@ use std::io::{self, Read};
 
 use super::error::{self, ReadContext};
 
-use crate::rw::{byte_reader::ByteReader, byte_writer::ByteWriter};
+use crate::rw::byte_reader::ByteReader;
 
 /* TODO:
 
-- Remove writer from tokenizer.
 - Implement trait Iterator for tokenizer.
 
 */
@@ -51,20 +50,15 @@ impl<R: Read> BencodeTokenizer<R> {
     ///
     /// - It can't read from the input.
     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)?;
-
-        match opt_peeked_byte {
+        match Self::peek_byte(&mut self.byte_reader)? {
             Some(peeked_byte) => {
                 match peeked_byte {
                     BENCODE_BEGIN_INTEGER => {
                         let value = integer::parse(&mut self.byte_reader)?;
                         Ok(Some(BencodeToken::Integer(value)))
                     }
                     b'0'..=b'9' => {
-                        let value = string::parse(&mut self.byte_reader, &mut null_writer)?;
+                        let value = string::parse(&mut self.byte_reader)?;
                         Ok(Some(BencodeToken::String(value)))
                     }
                     BENCODE_BEGIN_LIST => {