Rework Name and Fetch to use ouroboros.

Use a helper function in `parse_many_into` to support parsing into
any container that implements Extend. Refactor Capabilities to use it.

Delete ZeroCopy and associated bits.

Move Flag into it's own module in types.

Author: mordak

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imap"
-version = "3.0.0-alpha.4"
+version = "3.0.0-alpha.5"
 authors = ["Jon Gjengset <jon@thesquareplanet.com>",
            "Matt McCoy <mattnenterprise@yahoo.com>"]
 documentation = "https://docs.rs/imap/"

src/client.rs

@@ -565,39 +565,39 @@ impl<T: Read + Write> Session<T> {
     ///  - `RFC822.HEADER`: Functionally equivalent to `BODY.PEEK[HEADER]`.
     ///  - `RFC822.SIZE`: The [RFC-2822](https://tools.ietf.org/html/rfc2822) size of the message.
     ///  - `UID`: The unique identifier for the message.
-    pub fn fetch<S1, S2>(&mut self, sequence_set: S1, query: S2) -> ZeroCopyResult<Vec<Fetch>>
+    pub fn fetch<S1, S2>(&mut self, sequence_set: S1, query: S2) -> Result<Fetches>
     where
         S1: AsRef<str>,
         S2: AsRef<str>,
     {
         if sequence_set.as_ref().is_empty() {
-            parse_fetches(vec![], &mut self.unsolicited_responses_tx)
+            Fetches::parse(vec![], &mut self.unsolicited_responses_tx)
         } else {
             self.run_command_and_read_response(&format!(
                 "FETCH {} {}",
                 validate_sequence_set(sequence_set.as_ref())?,
                 validate_str_noquote(query.as_ref())?
             ))
-            .and_then(|lines| parse_fetches(lines, &mut self.unsolicited_responses_tx))
+            .and_then(|lines| Fetches::parse(lines, &mut self.unsolicited_responses_tx))
         }
     }
 
     /// Equivalent to [`Session::fetch`], except that all identifiers in `uid_set` are
     /// [`Uid`]s. See also the [`UID` command](https://tools.ietf.org/html/rfc3501#section-6.4.8).
-    pub fn uid_fetch<S1, S2>(&mut self, uid_set: S1, query: S2) -> ZeroCopyResult<Vec<Fetch>>
+    pub fn uid_fetch<S1, S2>(&mut self, uid_set: S1, query: S2) -> Result<Fetches>
     where
         S1: AsRef<str>,
         S2: AsRef<str>,
     {
         if uid_set.as_ref().is_empty() {
-            parse_fetches(vec![], &mut self.unsolicited_responses_tx)
+            Fetches::parse(vec![], &mut self.unsolicited_responses_tx)
         } else {
             self.run_command_and_read_response(&format!(
                 "UID FETCH {} {}",
                 validate_sequence_set(uid_set.as_ref())?,
                 validate_str_noquote(query.as_ref())?
             ))
-            .and_then(|lines| parse_fetches(lines, &mut self.unsolicited_responses_tx))
+            .and_then(|lines| Fetches::parse(lines, &mut self.unsolicited_responses_tx))
         }
     }
 
@@ -834,7 +834,7 @@ impl<T: Read + Write> Session<T> {
     ///     Ok(())
     /// }
     /// ```
-    pub fn store<S1, S2>(&mut self, sequence_set: S1, query: S2) -> ZeroCopyResult<Vec<Fetch>>
+    pub fn store<S1, S2>(&mut self, sequence_set: S1, query: S2) -> Result<Fetches>
     where
         S1: AsRef<str>,
         S2: AsRef<str>,
@@ -844,12 +844,12 @@ impl<T: Read + Write> Session<T> {
             sequence_set.as_ref(),
             query.as_ref()
         ))
-        .and_then(|lines| parse_fetches(lines, &mut self.unsolicited_responses_tx))
+        .and_then(|lines| Fetches::parse(lines, &mut self.unsolicited_responses_tx))
     }
 
     /// Equivalent to [`Session::store`], except that all identifiers in `sequence_set` are
     /// [`Uid`]s. See also the [`UID` command](https://tools.ietf.org/html/rfc3501#section-6.4.8).
-    pub fn uid_store<S1, S2>(&mut self, uid_set: S1, query: S2) -> ZeroCopyResult<Vec<Fetch>>
+    pub fn uid_store<S1, S2>(&mut self, uid_set: S1, query: S2) -> Result<Fetches>
     where
         S1: AsRef<str>,
         S2: AsRef<str>,
@@ -859,7 +859,7 @@ impl<T: Read + Write> Session<T> {
             uid_set.as_ref(),
             query.as_ref()
         ))
-        .and_then(|lines| parse_fetches(lines, &mut self.unsolicited_responses_tx))
+        .and_then(|lines| Fetches::parse(lines, &mut self.unsolicited_responses_tx))
     }
 
     /// The [`COPY` command](https://tools.ietf.org/html/rfc3501#section-6.4.7) copies the
@@ -988,13 +988,13 @@ impl<T: Read + Write> Session<T> {
         &mut self,
         reference_name: Option<&str>,
         mailbox_pattern: Option<&str>,
-    ) -> ZeroCopyResult<Vec<Name>> {
+    ) -> Result<Names> {
         self.run_command_and_read_response(&format!(
             "LIST {} {}",
             quote!(reference_name.unwrap_or("")),
             mailbox_pattern.unwrap_or("\"\"")
         ))
-        .and_then(|lines| parse_names(lines, &mut self.unsolicited_responses_tx))
+        .and_then(|lines| Names::parse(lines, &mut self.unsolicited_responses_tx))
     }
 
     /// The [`LSUB` command](https://tools.ietf.org/html/rfc3501#section-6.3.9) returns a subset of
@@ -1016,13 +1016,13 @@ impl<T: Read + Write> Session<T> {
         &mut self,
         reference_name: Option<&str>,
         mailbox_pattern: Option<&str>,
-    ) -> ZeroCopyResult<Vec<Name>> {
+    ) -> Result<Names> {
         self.run_command_and_read_response(&format!(
             "LSUB {} {}",
             quote!(reference_name.unwrap_or("")),
             mailbox_pattern.unwrap_or("")
         ))
-        .and_then(|lines| parse_names(lines, &mut self.unsolicited_responses_tx))
+        .and_then(|lines| Names::parse(lines, &mut self.unsolicited_responses_tx))
     }
 
     /// The [`STATUS` command](https://tools.ietf.org/html/rfc3501#section-6.3.10) requests the

src/parse.rs

@@ -3,6 +3,7 @@ use lazy_static::lazy_static;
 use regex::Regex;
 use std::collections::HashSet;
 use std::convert::TryFrom;
+use std::iter::Extend;
 use std::sync::mpsc;
 
 use super::error::{Error, ParseError, Result};
@@ -23,105 +24,51 @@ pub fn parse_authenticate_response(line: &str) -> Result<&str> {
     )))
 }
 
-enum MapOrNot<T> {
+pub(crate) enum MapOrNot<'a, T> {
     Map(T),
-    Not(Response<'static>),
+    MapVec(Vec<T>),
+    Not(Response<'a>),
     #[allow(dead_code)]
     Ignore,
 }
 
-unsafe fn parse_many<T, F>(
-    lines: Vec<u8>,
-    mut map: F,
+/// Parse many `T` Responses with `F` and extend `into` with them.
+/// Responses other than `T` go into the `unsolicited` channel.
+pub(crate) fn parse_many_into<'input, T, F>(
+    input: &'input [u8],
+    into: &mut impl Extend<T>,
     unsolicited: &mut mpsc::Sender<UnsolicitedResponse>,
-) -> ZeroCopyResult<Vec<T>>
+    mut map: F,
+) -> Result<()>
 where
-    F: FnMut(Response<'static>) -> Result<MapOrNot<T>>,
+    F: FnMut(Response<'input>) -> Result<MapOrNot<'input, T>>,
 {
-    let f = |mut lines: &'static [u8]| {
-        let mut things = Vec::new();
-        loop {
-            if lines.is_empty() {
-                break Ok(things);
-            }
-
-            match imap_proto::parser::parse_response(lines) {
-                Ok((rest, resp)) => {
-                    lines = rest;
-
-                    match map(resp)? {
-                        MapOrNot::Map(t) => things.push(t),
-                        MapOrNot::Not(resp) => match try_handle_unilateral(resp, unsolicited) {
-                            Some(Response::Fetch(..)) => continue,
-                            Some(resp) => break Err(resp.into()),
-                            None => {}
-                        },
-                        MapOrNot::Ignore => continue,
-                    }
-                }
-                _ => {
-                    break Err(Error::Parse(ParseError::Invalid(lines.to_vec())));
-                }
-            }
+    let mut lines = input;
+    loop {
+        if lines.is_empty() {
+            break Ok(());
         }
-    };
 
-    ZeroCopy::make(lines, f)
-}
-
-pub fn parse_names(
-    lines: Vec<u8>,
-    unsolicited: &mut mpsc::Sender<UnsolicitedResponse>,
-) -> ZeroCopyResult<Vec<Name>> {
-    let f = |resp| match resp {
-        // https://github.com/djc/imap-proto/issues/4
-        Response::MailboxData(MailboxDatum::List {
-            flags,
-            delimiter,
-            name,
-        }) => Ok(MapOrNot::Map(Name {
-            attributes: flags.into_iter().map(NameAttribute::from).collect(),
-            delimiter,
-            name,
-        })),
-        resp => Ok(MapOrNot::Not(resp)),
-    };
-
-    unsafe { parse_many(lines, f, unsolicited) }
-}
+        match imap_proto::parser::parse_response(lines) {
+            Ok((rest, resp)) => {
+                lines = rest;
 
-pub fn parse_fetches(
-    lines: Vec<u8>,
-    unsolicited: &mut mpsc::Sender<UnsolicitedResponse>,
-) -> ZeroCopyResult<Vec<Fetch>> {
-    let f = |resp| match resp {
-        Response::Fetch(num, attrs) => {
-            let mut fetch = Fetch {
-                message: num,
-                flags: vec![],
-                uid: None,
-                size: None,
-                fetch: attrs,
-            };
-
-            // set some common fields eaglery
-            for attr in &fetch.fetch {
-                match attr {
-                    AttributeValue::Flags(flags) => {
-                        fetch.flags.extend(Flag::from_strs(flags));
-                    }
-                    AttributeValue::Uid(uid) => fetch.uid = Some(*uid),
-                    AttributeValue::Rfc822Size(sz) => fetch.size = Some(*sz),
-                    _ => {}
+                match map(resp)? {
+                    MapOrNot::Map(t) => into.extend(Some(t)),
+                    MapOrNot::MapVec(t) => into.extend(t),
+                    MapOrNot::Not(resp) => match try_handle_unilateral(resp, unsolicited) {
+                        Some(Response::Fetch(..)) => continue,
+                        Some(resp) => break Err(resp.into()),
+                        None => {}
+                    },
+                    MapOrNot::Ignore => continue,
                 }
             }
-
-            Ok(MapOrNot::Map(fetch))
+            _ => {
+                break Err(Error::Parse(ParseError::Invalid(lines.to_vec())));
+            }
         }
-        resp => Ok(MapOrNot::Not(resp)),
-    };
-
-    unsafe { parse_many(lines, f, unsolicited) }
+    }
 }
 
 pub fn parse_expunge(

src/types/capabilities.rs

@@ -1,5 +1,5 @@
-use crate::error::{Error, ParseError};
-use crate::parse::try_handle_unilateral;
+use crate::error::Error;
+use crate::parse::{parse_many_into, MapOrNot};
 use crate::types::UnsolicitedResponse;
 use imap_proto::{Capability, Response};
 use ouroboros::self_referencing;
@@ -52,29 +52,12 @@ impl Capabilities {
         CapabilitiesTryBuilder {
             data: owned,
             capabilities_builder: |input| {
-                let mut lines = input;
                 let mut caps = HashSet::new();
-                loop {
-                    match imap_proto::parser::parse_response(lines) {
-                        Ok((rest, Response::Capabilities(c))) => {
-                            lines = rest;
-                            caps.extend(c);
-                        }
-                        Ok((rest, data)) => {
-                            lines = rest;
-                            if let Some(resp) = try_handle_unilateral(data, unsolicited) {
-                                break Err(resp.into());
-                            }
-                        }
-                        _ => {
-                            break Err(Error::Parse(ParseError::Invalid(lines.to_vec())));
-                        }
-                    }
-
-                    if lines.is_empty() {
-                        break Ok(caps);
-                    }
-                }
+                parse_many_into(input, &mut caps, unsolicited, |response| match response {
+                    Response::Capabilities(c) => Ok(MapOrNot::MapVec(c)),
+                    resp => Ok(MapOrNot::Not(resp)),
+                })?;
+                Ok(caps)
             },
         }
         .try_build()