Make the BufferedReader a (private) top-level module.

7 files changed, 47 insertions, 22 deletions

diff --git a/src/openpgp/parse/buffered-reader-test.txt b/src/buffered_reader/buffered-reader-test.txt
index 77dbaaa8..77dbaaa8 100644
--- a/src/openpgp/parse/buffered-reader-test.txt
+++ b/src/buffered_reader/buffered-reader-test.txt
diff --git a/src/openpgp/parse/buffered_reader.rs b/src/buffered_reader/buffered_reader.rs
index ab6f96c6..6118b3ce 100644
--- a/src/openpgp/parse/buffered_reader.rs
+++ b/src/buffered_reader/buffered_reader.rs
@@ -1,5 +1,3 @@
-//! An improved `BufRead` interface.
-
 use std;
 use std::str;
 use std::io;
@@ -10,6 +8,9 @@ use std::fmt;
 // The default buffer size.
 const DEFAULT_BUF_SIZE: usize = 8 * 1024;
 
+pub mod buffered_reader_decompress;
+pub mod buffered_reader_partial_body;
+
 /// A `BufferedReader` is a type of `Read`er that has an internal
 /// buffer, and allows working directly from that buffer.  Like a
 /// `BufRead`er, the internal buffer amortizes system calls.  And,
@@ -475,7 +476,7 @@ fn buffered_reader_generic_test() {
         use std::fs::File;
 
         let path : PathBuf = [env!("CARGO_MANIFEST_DIR"),
-                              "src", "openpgp", "parse", "buffered-reader-test.txt"]
+                              "src", "buffered_reader", "buffered-reader-test.txt"]
             .iter().collect();
         let mut f = File::open(&path).expect(&path.to_string_lossy());
         let mut bio = BufferedReaderGeneric::new(&mut f, None);
@@ -829,7 +830,7 @@ mod test {
             use std::fs::File;
 
             let path : PathBuf = [env!("CARGO_MANIFEST_DIR"),
-                                  "src", "openpgp", "parse",
+                                  "src", "buffered_reader",
                                   "buffered-reader-test.txt"]
                 .iter().collect();
 
diff --git a/src/openpgp/parse/buffered_reader_decompress.rs b/src/buffered_reader/buffered_reader_decompress.rs
index 774275c2..648037fc 100644
--- a/src/openpgp/parse/buffered_reader_decompress.rs
+++ b/src/buffered_reader/buffered_reader_decompress.rs
@@ -5,7 +5,7 @@ use flate2::read::DeflateDecoder;
 use flate2::read::ZlibDecoder;
 use bzip2::read::BzDecoder;
 
-use super::buffered_reader::*;
+use super::*;
 
 pub struct BufferedReaderDeflate<R: BufferedReader> {
     reader: BufferedReaderGeneric<DeflateDecoder<R>>,
diff --git a/src/openpgp/parse/buffered_reader_partial_body.rs b/src/buffered_reader/buffered_reader_partial_body.rs
index db476626..7ce10aa8 100644
--- a/src/openpgp/parse/buffered_reader_partial_body.rs
+++ b/src/buffered_reader/buffered_reader_partial_body.rs
@@ -3,9 +3,9 @@ use std::cmp;
 use std::io;
 use std::io::{Error,ErrorKind};
 
-use super::buffered_reader;
-use super::buffered_reader::BufferedReader;
-use super::super::BodyLength;
+use super::*;
+use ::openpgp::BodyLength;
+use ::openpgp::parse::body_length_new_format;
 
 /// A `BufferedReader` that transparently handles OpenPGP's chunking
 /// scheme.  This implicitly implements a limitor.
@@ -115,7 +115,7 @@ impl<T: BufferedReader> BufferedReaderPartialBodyFilter<T> {
             // Read the next partial body length header.
             assert_eq!(self.partial_body_length, 0);
 
-            match super::body_length_new_format(&mut self.reader) {
+            match body_length_new_format(&mut self.reader) {
                 Ok(BodyLength::Full(len)) => {
                     //println!("Last chuck: {} bytes", len);
                     self.last = true;
@@ -248,7 +248,7 @@ impl<T: BufferedReader> BufferedReaderPartialBodyFilter<T> {
 
 impl<T: BufferedReader> std::io::Read for BufferedReaderPartialBodyFilter<T> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
-        return buffered_reader::buffered_reader_generic_read_impl(self, buf);
+        return super::buffered_reader_generic_read_impl(self, buf);
     }
 }
 
diff --git a/src/buffered_reader/mod.rs b/src/buffered_reader/mod.rs
new file mode 100644
index 00000000..856a295b
--- /dev/null
+++ b/src/buffered_reader/mod.rs
@@ -0,0 +1,4 @@
+//! An improved `BufRead` interface.
+
+// Hack so that the file doesn't have to be named mod.rs.
+include!("buffered_reader.rs");
diff --git a/src/lib.rs b/src/lib.rs
index e3890089..49132e82 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,6 +17,8 @@ pub mod net;
 pub mod ffi;
 pub mod armor;
 
+mod buffered_reader;
+
 use std::env;
 use std::fs;
 use std::io;
diff --git a/src/openpgp/parse/parse.rs b/src/openpgp/parse/parse.rs
index 2c9f3192..b5756d09 100644
--- a/src/openpgp/parse/parse.rs
+++ b/src/openpgp/parse/parse.rs
@@ -5,17 +5,11 @@ use num::FromPrimitive;
 
 use super::*;
 
-pub mod buffered_reader;
-use self::buffered_reader::*;
-pub use self::buffered_reader::BufferedReader;
-
-mod buffered_reader_partial_body;
-use self::buffered_reader_partial_body::*;
-
-mod buffered_reader_decompress;
-use self::buffered_reader_decompress::BufferedReaderDeflate;
-use self::buffered_reader_decompress::BufferedReaderZlib;
-use self::buffered_reader_decompress::BufferedReaderBzip;
+use ::buffered_reader::*;
+use ::buffered_reader::buffered_reader_partial_body::*;
+use ::buffered_reader::buffered_reader_decompress::BufferedReaderDeflate;
+use ::buffered_reader::buffered_reader_decompress::BufferedReaderZlib;
+use ::buffered_reader::buffered_reader_decompress::BufferedReaderBzip;
 
 /// The default amount of acceptable nesting.  Typically, we expect a
 /// message to looking like:
@@ -62,7 +56,7 @@ named!(
             (r))));
 
 /// Decode a new format body length as described in Section 4.2.2 of RFC 4880.
-fn body_length_new_format<T: BufferedReader> (bio: &mut T)
+pub fn body_length_new_format<T: BufferedReader> (bio: &mut T)
       -> Result<BodyLength, std::io::Error> {
     let octet1 = bio.data_consume_hard(1)?[0];
     if octet1 < 192 {
@@ -918,6 +912,30 @@ fn deserialize_test_2 () {
 }
 
 #[test]
+fn deserialize_test_3 () {
+    use std::path::PathBuf;
+    use std::fs::File;
+
+    let path : PathBuf = [env!("CARGO_MANIFEST_DIR"),
+                          "src", "openpgp", "parse",
+                          "signed.gpg"]
+        .iter().collect();
+    let mut f = File::open(&path).expect(&path.to_string_lossy());
+    let bio = BufferedReaderGeneric::new(&mut f, None);
+    let message = Message::deserialize(bio, None).unwrap();
+    eprintln!("Message has {} top-level packets.", message.packets.len());
+    eprintln!("Message: {:?}", message);
+
+    let mut count = 0;
+    for (i, p) in message.iter().enumerate() {
+        count += 1;
+        eprintln!("{}: {:?}", i, p);
+    }
+    // We expect 6 packets.
+    assert_eq!(count, 6);
+}
+
+#[test]
 fn compression_quine_test_1 () {
     // Use the Message::deserialize interface to parse an OpenPGP
     // quine.