refactor: duplicate integer and strig parser before removing writer

Remove the writer without affecting other parts of the code.

Author: josecelano

src/parsers/tokenizer/integer.rs

@@ -0,0 +1,369 @@
+//! Bencoded integer parser.
+//!
+//! It reads bencoded bytes from the input and writes JSON bytes to the output.
+use std::io::{self, Read};
+
+use crate::rw::{byte_reader::ByteReader, writer::Writer};
+
+use super::{
+    error::{Error, ReadContext, WriteContext},
+    BENCODE_END_INTEGER,
+};
+
+/// The current state parsing the integer.
+#[derive(PartialEq)]
+#[allow(clippy::enum_variant_names)]
+enum StateExpecting {
+    Start,          // S
+    DigitOrSign,    // DoS
+    DigitAfterSign, // DaS
+    DigitOrEnd,     // DoE
+}
+
+/// It parses an integer bencoded value.
+///
+/// # Errors
+///
+/// Will return an error if it can't read from the input or write to the
+/// output.
+///
+/// # Panics
+///
+/// Will panic if we reach the end of the input without completing the integer
+/// (without reaching the end of the integer `e`).
+pub fn parse<R: Read, W: Writer>(
+    reader: &mut ByteReader<R>,
+    writer: &mut W,
+) -> Result<Vec<u8>, Error> {
+    let mut state = StateExpecting::Start;
+    let mut first_digit_is_zero = false;
+    let mut value = vec![];
+
+    loop {
+        let byte = next_byte(reader, writer)?;
+
+        let char = byte as char;
+
+        state = match state {
+            StateExpecting::Start => {
+                // Discard the 'i' byte
+                StateExpecting::DigitOrSign
+            }
+            StateExpecting::DigitOrSign => {
+                if char == '-' {
+                    writer.write_byte(byte)?;
+                    value.push(byte);
+
+                    StateExpecting::DigitAfterSign
+                } else if char.is_ascii_digit() {
+                    writer.write_byte(byte)?;
+                    value.push(byte);
+
+                    if char == '0' {
+                        first_digit_is_zero = true;
+                    }
+
+                    StateExpecting::DigitOrEnd
+                } else {
+                    return Err(Error::UnexpectedByteParsingInteger(
+                        ReadContext {
+                            byte: Some(byte),
+                            pos: reader.input_byte_counter(),
+                            latest_bytes: reader.captured_bytes(),
+                        },
+                        WriteContext {
+                            byte: Some(byte),
+                            pos: writer.output_byte_counter(),
+                            latest_bytes: writer.captured_bytes(),
+                        },
+                    ));
+                }
+            }
+            StateExpecting::DigitAfterSign => {
+                if char.is_ascii_digit() {
+                    writer.write_byte(byte)?;
+                    value.push(byte);
+
+                    if char == '0' {
+                        first_digit_is_zero = true;
+                    }
+
+                    StateExpecting::DigitOrEnd
+                } else {
+                    return Err(Error::UnexpectedByteParsingInteger(
+                        ReadContext {
+                            byte: Some(byte),
+                            pos: reader.input_byte_counter(),
+                            latest_bytes: reader.captured_bytes(),
+                        },
+                        WriteContext {
+                            byte: Some(byte),
+                            pos: writer.output_byte_counter(),
+                            latest_bytes: writer.captured_bytes(),
+                        },
+                    ));
+                }
+            }
+            StateExpecting::DigitOrEnd => {
+                if char.is_ascii_digit() {
+                    writer.write_byte(byte)?;
+                    value.push(byte);
+
+                    if char == '0' && first_digit_is_zero {
+                        return Err(Error::LeadingZerosInIntegersNotAllowed(
+                            ReadContext {
+                                byte: Some(byte),
+                                pos: reader.input_byte_counter(),
+                                latest_bytes: reader.captured_bytes(),
+                            },
+                            WriteContext {
+                                byte: Some(byte),
+                                pos: writer.output_byte_counter(),
+                                latest_bytes: writer.captured_bytes(),
+                            },
+                        ));
+                    }
+
+                    StateExpecting::DigitOrEnd
+                } else if byte == BENCODE_END_INTEGER {
+                    return Ok(value);
+                } else {
+                    return Err(Error::UnexpectedByteParsingInteger(
+                        ReadContext {
+                            byte: Some(byte),
+                            pos: reader.input_byte_counter(),
+                            latest_bytes: reader.captured_bytes(),
+                        },
+                        WriteContext {
+                            byte: Some(byte),
+                            pos: writer.output_byte_counter(),
+                            latest_bytes: writer.captured_bytes(),
+                        },
+                    ));
+                }
+            }
+        };
+    }
+}
+
+/// It reads the next byte from the input.
+///
+/// # Errors
+///
+/// Will return an error if the end of input was reached.
+fn next_byte<R: Read, W: Writer>(reader: &mut ByteReader<R>, writer: &W) -> Result<u8, Error> {
+    match reader.read_byte() {
+        Ok(byte) => Ok(byte),
+        Err(err) => {
+            if err.kind() == io::ErrorKind::UnexpectedEof {
+                return Err(Error::UnexpectedEndOfInputParsingInteger(
+                    ReadContext {
+                        byte: None,
+                        pos: reader.input_byte_counter(),
+                        latest_bytes: reader.captured_bytes(),
+                    },
+                    WriteContext {
+                        byte: None,
+                        pos: writer.output_byte_counter(),
+                        latest_bytes: writer.captured_bytes(),
+                    },
+                ));
+            }
+            Err(err.into())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        parsers::{error::Error, integer::parse},
+        rw::{byte_reader::ByteReader, string_writer::StringWriter},
+    };
+
+    fn bencode_to_json_unchecked(input_buffer: &[u8]) -> String {
+        let mut output = String::new();
+
+        parse_bencode(input_buffer, &mut output).expect("Bencode to JSON conversion failed");
+
+        output
+    }
+
+    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 parse_bencode(input_buffer: &[u8], output: &mut String) -> Result<Vec<u8>, Error> {
+        let mut reader = ByteReader::new(input_buffer);
+
+        let mut writer = StringWriter::new(output);
+
+        parse(&mut reader, &mut writer)
+    }
+
+    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());
+        }
+
+        #[test]
+        fn bencode_to_json_wrapper_fails() {
+            assert!(try_bencode_to_json(b"i").is_err());
+        }
+    }
+
+    #[test]
+    fn zero() {
+        assert_eq!(bencode_to_json_unchecked(b"i0e"), "0".to_string());
+    }
+
+    #[test]
+    fn one_digit_integer() {
+        assert_eq!(bencode_to_json_unchecked(b"i1e"), "1".to_string());
+    }
+
+    #[test]
+    fn two_digits_integer() {
+        assert_eq!(bencode_to_json_unchecked(b"i42e"), "42".to_string());
+    }
+
+    #[test]
+    fn negative_integer() {
+        assert_eq!(bencode_to_json_unchecked(b"i-1e"), "-1".to_string());
+    }
+
+    mod it_should_fail {
+        use std::io::{self, Read};
+
+        use crate::{
+            parsers::{
+                error::Error,
+                tokenizer::integer::{parse, tests::try_bencode_to_json},
+            },
+            rw::{byte_reader::ByteReader, string_writer::StringWriter},
+        };
+
+        #[test]
+        fn when_it_cannot_read_more_bytes_from_input() {
+            let unfinished_int = b"i42";
+
+            let result = try_bencode_to_json(unfinished_int);
+
+            assert!(matches!(
+                result,
+                Err(Error::UnexpectedEndOfInputParsingInteger { .. })
+            ));
+        }
+
+        #[test]
+        fn when_it_finds_an_invalid_byte() {
+            let int_with_invalid_byte = b"iae";
+
+            let result = try_bencode_to_json(int_with_invalid_byte);
+
+            assert!(matches!(
+                result,
+                Err(Error::UnexpectedByteParsingInteger { .. })
+            ));
+        }
+
+        #[test]
+        fn when_it_finds_leading_zeros() {
+            // Leading zeros are not allowed.Only the zero integer can start with zero.
+
+            let int_with_invalid_byte = b"i00e";
+
+            let result = try_bencode_to_json(int_with_invalid_byte);
+
+            assert!(matches!(
+                result,
+                Err(Error::LeadingZerosInIntegersNotAllowed { .. })
+            ));
+        }
+
+        #[test]
+        fn when_it_finds_leading_zeros_in_a_negative_integer() {
+            // Leading zeros are not allowed.Only the zero integer can start with zero.
+
+            let int_with_invalid_byte = b"i-00e";
+
+            let result = try_bencode_to_json(int_with_invalid_byte);
+
+            assert!(matches!(
+                result,
+                Err(Error::LeadingZerosInIntegersNotAllowed { .. })
+            ));
+        }
+
+        mod when_it_receives_a_unexpected_byte {
+            use crate::parsers::{error::Error, tokenizer::integer::tests::try_bencode_to_json};
+
+            #[test]
+            fn while_expecting_a_digit_or_sign() {
+                let int_with_invalid_byte = b"ia";
+
+                let result = try_bencode_to_json(int_with_invalid_byte);
+
+                assert!(matches!(
+                    result,
+                    Err(Error::UnexpectedByteParsingInteger { .. })
+                ));
+            }
+
+            #[test]
+            fn while_expecting_digit_after_the_sign() {
+                let int_with_invalid_byte = b"i-a";
+
+                let result = try_bencode_to_json(int_with_invalid_byte);
+
+                assert!(matches!(
+                    result,
+                    Err(Error::UnexpectedByteParsingInteger { .. })
+                ));
+            }
+
+            #[test]
+            fn while_expecting_digit_or_end() {
+                let int_with_invalid_byte = b"i-1a";
+
+                let result = try_bencode_to_json(int_with_invalid_byte);
+
+                assert!(matches!(
+                    result,
+                    Err(Error::UnexpectedByteParsingInteger { .. })
+                ));
+            }
+        }
+
+        #[test]
+        fn when_it_receives_a_non_eof_io_error() {
+            struct FaultyReader;
+
+            impl Read for FaultyReader {
+                fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
+                    Err(io::Error::new(
+                        io::ErrorKind::PermissionDenied,
+                        "Permission denied",
+                    ))
+                }
+            }
+
+            let mut reader = ByteReader::new(FaultyReader);
+
+            let mut output = String::new();
+            let mut writer = StringWriter::new(&mut output);
+
+            let result = parse(&mut reader, &mut writer);
+
+            assert!(matches!(result, Err(Error::Io(_))));
+        }
+    }
+}

src/parsers/tokenizer.rs src/parsers/tokenizer/mod.rssrc/parsers/tokenizer.rs renamed to src/parsers/tokenizer/mod.rs

@@ -1,10 +1,10 @@
 //! Bencode tokenizer. Given an input stream, it returns a stream of tokens.
+pub mod integer;
+pub mod string;
+
 use std::io::{self, Read};
 
-use super::{
-    error::{self, ReadContext, WriteContext},
-    integer, string,
-};
+use super::error::{self, ReadContext, WriteContext};
 
 use crate::rw::{byte_reader::ByteReader, byte_writer::ByteWriter, writer::Writer};