notes
* i tried to avoid the term "async", because that term is very
overloaded and we're not using e.g. tokio/async-io here
* i'm a little unhappy having to string the channel through the
parser, because that seems rather a part of the client logic than
parsing. on the other hand it's better than passing the whole
client, so there's that at least.
* First stab at structured types (#28)
Tests currently fail due to djc/imap-proto#2.
LSUB is also broken due to djc/imap-proto#4 (but we don't have tests for
that atm).
* Also parse out RFC822 fetch responses
* Make all the things zero-copy
* Also delegate IntoIterator for ZeroCopy ref
* Fix UNSEEN and LSUB
All tests now pass
* Address @sanmai-NL comments
* Correctly handle incomplete parser responses
* No need for git dep anymore
Some notable exceptions: messagebox names are defined as `INBOX / astring`, but with this change, INBOX is also quoted.
The `list-mailbox` token is not quoted, as it is not `astring`.
In particular, the API for `IdleHandle` now reflects that it is only
really meant for single-use. It mutably borrows the `Client`, so once
`wait` returns there isn't really a good reason to keep the `IdleHandle`
around (because you'll likely want to issue some other commands).
There is something to be said for being able to operate on the IDLE
stream, but we'll leave that for later.
This also avoids some unfortunate unavoidable panics when the connection
fails while the client is IDLEing.
* Use bufstream for better read/write
* Read with length 0 == EOF
* Adapt read_delay test to write one chat at a time
* Add test for eof reads
* Neater interface for MockStream
* Add IMAP IDLE support
This patch adds support for the IMAP IDLE command specified in RFC 2177.
It allows clients to block while waiting for changes to a selected
mailbox, without having to poll the server. This is especially useful
for monitoring a mailbox for new messages.
The API is currently somewhat primitive: users can call `Client::idle()`
to get an IDLE "handle", which they can then call `wait()` on to block
until a change is detected. The implementation also provides
`wait_keepalive()` (which tries to avoid connection timeouts) and
`wait_timeout()` (which allows the user to specify the maximum time to
block).
Further down the line, the handle should probably also implement
`Iterator` to allow clients to watch new events as they happen. This
*could* be implemented today, but given that most other `Client` methods
just return unparsed strings at the moment, I didn't feel like that
enhancement was a high priority. For now, users will have to manually
query the mailbox for what changed.
Fixes#26.
* Avoid unnecessary as_bytes()
* Make wait_keepalive interval configurable
* Avoid ?, which requires Rust 1.13
