Make Read trait and helpers public

Allows users of the crate to have their own Read implementations
and create the equivalent of the `from_*` functions.

Specifically, if the bytes to read are actually a continuous
stream of bencoded data (so a dictionary followed by another
dictionary for instance), then the library user can create
a reader which does not check that it reached the end
of all the bytes after reading one value.

For instance:

```
use std::{cell::RefCell, rc::Rc};

pub(crate) struct SliceReadView<'a> {
    reader: Rc<RefCell<bt_bencode::read::SliceRead<'a>>>,
}

impl<'a> SliceReadView<'a> {
    pub(crate) fn new(reader: Rc<RefCell<bt_bencode::read::SliceRead<'a>>>) -> Self {
        Self { reader }
    }
}

impl<'a> bt_bencode::read::Read<'a> for SliceReadView<'a> {
    #[inline]
    fn next(&mut self) -> Option<Result<u8, bt_bencode::Error>> {
        self.reader.borrow_mut().next()
    }

    #[inline]
    fn peek(&mut self) -> Option<Result<u8, bt_bencode::Error>> {
        self.reader.borrow_mut().peek()
    }

    #[inline]
    fn byte_offset(&self) -> usize {
        self.reader.borrow().byte_offset()
    }
}
```

To read multiple values:

```
let reader = std::rc::Rc::new(std::cell::RefCell::new(bt_bencode::read::SliceRead::new(
    &bytes[..],
)));

loop {
    let mut de = bt_bencode::Deserializer::new(SliceReadView::new(reader.clone()));

    use bt_bencode::read::Read;
    use serde::de::Deserialize;

    match bt_bencode::Value::deserialize(&mut de) {
        Ok(value) => {
            // Process the decoded `value`
        }
        Err(e) => match e {
            bt_bencode::Error::EofWhileParsingValue
                if reader.clone().borrow_mut().peek().is_none() =>
            {
                // The end of file was reached as expected
                break;
            }
            _ => {
              // An unexpected error occured during processing
              dbg!(e);
            }
        },
    }
}
```

Author: bluk

CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## v0.3.0
+
+### Added
+
+* `Read` trait and helper implementations are made public.
+
 ## v0.2.0
 
 ### Added

src/lib.rs

@@ -77,7 +77,7 @@ extern crate serde;
 
 mod de;
 mod error;
-mod read;
+pub mod read;
 #[cfg(feature = "std")]
 mod ser;
 pub mod value;

src/read.rs

@@ -1,18 +1,27 @@
+//! `Read` trait and helpers to read bytes for the deserializer.
+
 #[cfg(feature = "std")]
 use crate::error::Error;
 #[cfg(feature = "std")]
 use std::io;
 
 use crate::error::Result;
 
+/// Trait used by the `de::Deserializer` to read bytes.
 pub trait Read<'de> {
+    /// Consumes and returns the next read byte.
     fn next(&mut self) -> Option<Result<u8>>;
+    /// Returns the next byte but does not consume.
+    ///
+    /// Repeated peeks (with no `next()` call) should return the same byte.
     fn peek(&mut self) -> Option<Result<u8>>;
+    /// Returns the position in the stream of bytes.
     fn byte_offset(&self) -> usize;
 }
 
+/// A wrapper to implement this crate's `Read` trait for `std::io::Read` trait implementations.
 #[cfg(feature = "std")]
-pub(crate) struct IoRead<R>
+pub struct IoRead<R>
 where
     R: io::Read,
 {
@@ -26,6 +35,7 @@ impl<R> IoRead<R>
 where
     R: io::Read,
 {
+    /// Instantiates a new reader.
     pub fn new(reader: R) -> Self {
         IoRead {
             iter: reader.bytes(),
@@ -79,12 +89,14 @@ where
     }
 }
 
-pub(crate) struct SliceRead<'a> {
+/// A wrapper to implement this crate's `Read` trait for byte slices.
+pub struct SliceRead<'a> {
     slice: &'a [u8],
     byte_offset: usize,
 }
 
 impl<'a> SliceRead<'a> {
+    /// Instantiates a new reader.
     pub fn new(slice: &'a [u8]) -> Self {
         SliceRead {
             slice,