Kolab Groupware OBS

Changes of Revision 6

debian.tar.gz/.erlang Added

debian.tar.gz/.gitignore Added

debian.tar.gz/Makefile Added

debian.tar.gz/README.md Added

@@ -0,0 +1,200 @@
+This is a basic IMAP client implementation written in Erlang.
+
+The API is not finalized, and is currently limited to the eimap module. Its
+current and only recognized use case is software intended to interact with a
+Kolab server environment which are written in Erlang. Expansion of that scope
+is welcome through community participation. However, currently the following
+disclaimer should be taken with seriousness:
+
+    USE AT YOUR OWN RISK. THINGS WILL CHANGE.
+
+The following is equally true, however:
+
+    CONTRIBUTIONS WELCOME. USAGE WELCOME.
+
+Usage
+=====
+
+To use eimap from your imap application add the following line to your rebar
+config:
+
+    { eimap, "*", {git, "git://git.kolab.org/diffusion/EI/eimap.git" } }
+
+There is no need to start the eimap application as it does not have any process
+or startup routines related to its usage. eimap does rely on lager being avilable,
+however.
+
+eimap Module
+============
+The eimap erlang module is the home of the primary API for the eimap library. It
+is a gen_fsm and should be started as a process in the normal Erlang/OTP manner for
+use.
+
+An eimap instance represents a single IMAP connection to a single IMAP server
+and is stateful: commands that are started may change the selected folder, for
+instance, and commands that are sent may be put into a command queue for subsequent
+execution depeding on the current state of the connection.
+
+Once started, an eimap process may be directed to connect to an imap server
+and then start with functions such as fetching path tokens:
+
+    ImapServerArgs = [ { host, "imap.acme.com" }, { port, 143 }, { tls, starttls } ]
+    { ok, Imap } = eimap:start_link(ImapServerArgs),
+    eimap_imap:starttls(),
+    eimap_imap:login(Imap, self(), undefined, "username", "password"),
+    eimap_imap:connect(Imap),
+    eimap_imap:get_path_tokens(Imap, self(), get_path_tokens)
+
+The Imap server args is a simple proplist which allows one to set
+host, port and TLS settings. For TLS, the following values are supported:
+
+    * true: start a TLS session when opening the socket ("implicit TLS")
+    * starttls: start TLS via the STARTTLS IMAP command auomagically
+    * false: just open a regular connection; this is what you usually want, and
+             the client will call eimap:starttls/3 when it wishes to switch to
+             an encrypted connection
+
+The starttls, login and even get_path_tokens commands will be
+queued and sent to the IMAP server only when the connection has been established.
+This prevents having to wait for connection signals and lets you write what you
+intend to be executed with as few issues as possible.
+
+Commands are executed in the order they are queued, and they follow a consistent
+parametic pattern:
+
+    * the first parameter is the eimap PID returned by eimap:start_link/1
+    * the second parameter is the PID the response should be sent to as a message
+    * the third parameter is a token to send back with the response, allowing users
+      of eimap to track responses to specific commands; undefined is allowed and will
+      surpress the use of a response token
+    * .. additional parameters specific to the command, such as username and
+      password in the case of login
+
+Responses are sent as a normal message with the form:
+
+    Response
+    { Token, Resposne }
+
+The Token is the resposne token provided as the third parameter and may be anything.
+The Response depends on the given command, but will be a properly formed Erlang term
+representing the content of the response.
+
+Passthrough Mode
+================
+eimap supports a mode of operation which simply passes data between the user
+and the imap server blindly. This is known as "passthrough" mode and can be
+started and stopped with the start_passthrough/2 and stop_passthrough/1
+functions.
+
+Data is queued up for sending with the passthrough_data/2 function, and will be
+sent to the server as soon as possible.
+
+Responses are similarly sent back to the initiator of the passthrough mode
+for dispatch in the form of { imap_server_response, Data } messages. The receiver
+is the PID passed to start_passthrough/2 as the second parameter.
+
+As the user is entirely responsible for the traffic and thereby the state
+of the IMAP conenction during passthrough, exercise caution while using
+this mode.
+
+Any commands which are queued using eimap's command functions (logini/5,
+logout/3, etc) will interupt passthrough to run those commands. Once the queued
+commands have been cleared passthrough will restart auomatically.
+
+Commands
+========
+
+Individual commands are implemented in individual modules in the src/commands/
+directory, and this is the prefered mechanism for adding features to eimap.
+
+The API for commands is defined in src/eimap_command.erl as a behavior. Commands
+are expected to provide at least two functions:
+
+    new_command(Args) -> { Command, ResponseType }
+        create a command bitstring to be passed to the imap server and defines
+        the type of response for this command. Response types include
+        single_line_response, multiline_response, all_multiline_response
+        and blob_response.
+
+        Args is specific to the command, and some commands
+        ignore this parameter
+
+Single line response
+--------------------
+Commands which the IMAP server will respond to with a single line in return
+should use single_line_response and must implement formulate_response/2 which
+is passed the Data and the command Tag. This usually returns one of
+{ fini, Result } or { error, Reason }, though some special commands may return
+atoms which the eimap module responds to such as starttls.
+
+Multiline Response
+------------------
+This is the most common response type and is used when the IMAP server may
+respond with zero or more untagged responses and a final tagged response.
+
+Such commands must implement:
+
+    process_line/2 which is passed one line at a time (minus newlines)
+        and a list accumulator to add responses to
+
+    formulate_response/2 which is passed ok on success or an error tuple of 
+     { [no|bad], Reason }. This should return either { fini, Response } or
+     { error, Reason } in most cases; and for that there is
+     eimap_command:formulate_response. Which means that for most commands
+     formulate_response/2 is implemented as:
+
+        formulate_response(Result, Response) -> eimap_command:formulate(Result, Response).
+
+Commands which are all_multiline_responses also must implement process_tagged_line/2
+which behaves exactly like process_line but which accepts the tagged response line
+from the IMAP server. This is useful for commands where useful information is also
+passed in the tagged response line. An example of this is the select/exmine
+commands.
+
+Unstructured (blob) responses
+-----------------------------
+Responses that do not follow the usual untagged/tagged line response pattern
+may use the blog_response type and implement parse/2 which will be passed
+the data as it arrives. The command is responsible for all buffer stitching
+across network packets, etc.
+
+In the case of partial responses, parse/2 may return { more, fun/3, State }.
+The State object allows preserving the parsing state and will be passed back to
+fun/3 in addition to the Data and Tag parameters.
+
+parse/2 (or the continuation fun/3) should return { fini, Result } when 
+successfully completed, or { error, Reason } when it fails. Only once either a
+fini or error tuple are returned will the eimap process move on to the next
+command queued.
+
+IMAP Utils
+==========
+
+eimap_utils provides a set of handy helpers for use when IMAP'ing your way
+across the network. These include folder path and UID set extractors, IMAP
+server response manipulators and misc utilities.
+
+Testing
+=======
+Tests can be run with `make tests` or `rebar eunit`.
+
+All new commands must be accompanied by tests in the test/ directory.
+
+Contributing
+============
+Maintainer: Aaron Seigo <aseigo@kolabsystems.com>
+Mailing list: devel@lists.kolab.com
+Project page: https://git.kolab.org/tag/eimap/
+
+This project uses the git flow workflow as described here:
+
+    http://nvie.com/posts/a-successful-git-branching-model/
+
+You can installed git flow from here:
+
+    https://github.com/nvie/gitflow
+
+Then initialize your local clone with `git flow init -d`.
+
+You can find the list of open tasks on the project page's workboard. Anything
+in the backlog is open to be worked on.

debian.tar.gz/compat Deleted

debian.tar.gz/copyright Deleted

@@ -1,24 +0,0 @@
-Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: erlang-eimap
-Source: https://git.kolab.org/diffusion/EI/eimap.git
-
-Files: *
-Copyright: 2016 Kolab Systems AG <contact@kolabsys.com>
-License: GPL-3.0+
-
-License: GPL-3.0+
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
- .
- This package is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- .
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
- .
- On Debian systems, the complete text of the GNU General
- Public License version 3 can be found in "/usr/share/common-licenses/GPL-3".

debian.tar.gz/rebar Added

debian.tar.gz/rebar.config Added

debian.tar.gz/source Deleted

debian.tar.gz/source/format Deleted

debian.tar.gz/src Added

debian.tar.gz/src/commands Added

debian.tar.gz/src/commands/eimap_command_annotation.erl Added

@@ -0,0 +1,49 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_annotation).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% Public API
+new_command(Folder) when is_list(Folder) -> new_command(list_to_binary(Folder));
+new_command(Folder) -> { <<"GETANNOTATION \"", Folder/binary, "\" \"*\" \"value.shared\"">>, multiline_response }.
+
+process_line(<<" ", Data/binary>>, Acc) ->
+    process_line(Data, Acc);
+process_line(<<"* ANNOTATION ", Data/binary>>, Acc) ->
+    Pieces = binary:split(Data, <<"\"">>, [global]),
+    process_pieces(Pieces, Acc);
+process_line(<<>>, Acc) ->
+    Acc.
+
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
+
+%% Private API
+process_pieces([MBox, Key, _, _, _, Value, _], Acc) when MBox =/= <<>> -> [ { Key, translate(Value) } | Acc ];
+process_pieces([_, _MBox, _, Key, _, _, _, Value, _], Acc) -> [ { Key, translate(Value) } | Acc ];
+process_pieces(_, Acc) -> Acc.
+
+translate(<<"false">>) -> false;
+translate(<<"true">>) -> true;
+translate(Value) ->
+    try list_to_integer(binary_to_list(Value)) of
+        Number -> Number
+    catch
+        _:_ -> Value
+    end.
+

debian.tar.gz/src/commands/eimap_command_capability.erl Added

@@ -0,0 +1,50 @@
+%% Copyright 2015 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_capability).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command(parse_serverid) -> { <<"CAPABILITY">>, single_line_response };
+new_command(_Args) -> { <<"CAPABILITY">>, multiline_response }.
+
+process_line(<<"* CAPABILITY ", Data/binary>>, Acc) ->
+    [Data|Acc];
+process_line(_Data, Acc) -> Acc.
+
+formulate_response(ok, Response) -> { fini, Response };
+formulate_response({ _, Reason }, _Data) -> { error, Reason };
+formulate_response(Data, Tag) -> parse_oneliner(eimap_utils:check_response_for_failure(Data, Tag),
+                                                eimap_utils:remove_tag_from_response(Data, Tag, check)).
+
+%% Private API
+% TODO: probably way too cyrus imap specific on the responses (capitalization, etc)
+% make generic with a nicer parser
+parse_oneliner(ok, <<"* OK [CAPABILITY ", Data/binary>>) ->
+    % this is a server response on connect
+    { End, _ } = binary:match(Data, <<"]">>),
+    { TextEnd, _ } = binary:match(Data, <<"\r\n">>),
+    Capabilities = binary:part(Data, { 0, End }),
+    ServerID = binary:part(Data, { End + 2, TextEnd - End  - 2}),
+    { fini, { Capabilities, ServerID } };
+parse_oneliner({ _, Reason }, _Data) -> { error, Reason };
+parse_oneliner(_, Data) -> { fini, Data }.
+
+

debian.tar.gz/src/commands/eimap_command_compress.erl Added

@@ -0,0 +1,32 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_compress).
+-behavior(eimap_command).
+-export([new_command/1, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command(_Args) -> { <<"COMPRESS DEFLATE">>, single_line_response }.
+
+formulate_response(Data, Tag) ->
+    case eimap_utils:check_response_for_failure(Data, Tag) of
+        ok -> compression_active;
+        { _, Reason } -> { error, Reason }
+    end.
+

debian.tar.gz/src/commands/eimap_command_getmetadata.erl Added

@@ -0,0 +1,117 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_getmetadata).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command({ Folder }) -> new_command({ Folder, [] });
+new_command({ Folder, Attributes }) -> new_command({ Folder, Attributes, infinity, nomax });
+
+%% Depth and MaxSize are both optional arguments, so we have a 4-tuple version of new_command to accomodate this
+%% "Depth, Maxsize" could be replaced with a proplist of the form [ { depth, Depth }, { maxsize, MaxSize } ] but
+%% as this is an internal (to eimap) API there is little benefit for the performance cost
+new_command({ Folder, Attributes, Depth, MaxSize }) when is_list(Folder) -> new_command({ list_to_binary(Folder), Attributes, Depth, MaxSize });
+new_command({ Folder, Attributes, Depth, MaxSize }) ->
+    AttributesString = format_attributes(Attributes, <<>>),
+    DepthString = depth_param(Depth),
+    MaxSizeString = maxsize_param(MaxSize),
+    Command = metadata_command(DepthString, MaxSizeString, Folder, AttributesString),
+    { Command, multiline_response }.
+
+process_line(<<"* METADATA ", Details/binary>>, Acc) ->
+    Results = parse_folder(Details),
+    [Results|Acc];
+process_line(_Line, Acc) -> Acc.
+
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
+
+%% Private API
+depth_param(infinity) -> <<"DEPTH infinity">>;
+depth_param(Depth) when is_integer(Depth) -> Bin = integer_to_binary(Depth), <<"DEPTH ", Bin/binary>>;
+depth_param(_) -> <<>>.
+
+maxsize_param(Size) when is_integer(Size) -> Bin = integer_to_binary(Size), <<"MAXSIZE ", Bin/binary>>;
+maxsize_param(_) -> <<>>.
+
+metadata_command(<<>>, <<>>, Folder, Attributes) -> <<"GETMETADATA \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(Depth, <<>>, Folder, Attributes) -> <<"GETMETADATA (", Depth/binary, ") \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(<<>>, MaxSize, Folder, Attributes) -> <<"GETMETADATA (", MaxSize/binary, ") \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(Depth, MaxSize, Folder, Attributes) -> <<"GETMETADATA (", Depth/binary, " ", MaxSize/binary, ") \"", Folder/binary, "\"", Attributes/binary>>.
+
+format_attributes([], <<>>) -> <<>>;
+format_attributes([], String) -> <<" (", String/binary, ")">>;
+format_attributes([Attribute|Attributes], String) ->
+    AttrBin = case is_list(Attribute) of
+                true -> list_to_binary(Attribute);
+                false -> Attribute
+              end,
+    case String of
+        <<>> -> format_attributes(Attributes, AttrBin);
+        _ -> format_attributes(Attributes, <<String/binary, " ", AttrBin/binary>>)
+    end;
+format_attributes(_, _String) -> <<>>.
+
+parse_folder(<<"\"", Rest/binary>>) ->
+    { Folder, RemainingBuffer } = until_closing_quote(Rest),
+    Properties = parse_properties(RemainingBuffer),
+    { Folder, Properties };
+parse_folder(Buffer) ->
+    { FolderEnd, _ } = binary:match(Buffer, <<" ">>),
+    Folder = binary:part(Buffer, 0, FolderEnd),
+    Properties = parse_properties(binary:part(Buffer, FolderEnd, size(Buffer) - FolderEnd)),
+    { Folder, Properties }.
+
+parse_properties(Buffer) ->
+    { Start, _ } = binary:match(Buffer, <<"(">>),
+    { End, _ } = binary:match(Buffer, <<")">>),
+    Properties = binary:part(Buffer, Start + 1, End - Start - 1),
+    next_property(Properties, []).
+
+next_property(<<>>, Acc) -> Acc;
+next_property(Buffer, Acc) ->
+    { KeyEnd, _ } = binary:match(Buffer, <<" ">>),
+    Key = binary:part(Buffer, 0, KeyEnd),
+    { Value, RemainingBuffer } = 
+        case next_value(binary:part(Buffer, KeyEnd + 1, size(Buffer) - KeyEnd - 1)) of
+            { <<"NIL">>, RBuffer } -> { null, RBuffer };
+            Rv -> Rv
+        end,
+    next_property(RemainingBuffer, [{ Key, Value }|Acc]).
+
+next_value(<<"\"", Rest/binary>>) ->
+    until_closing_quote(Rest);
+next_value(Buffer) ->
+    case binary:match(Buffer, <<" ">>) of
+        nomatch -> { Buffer, <<>> };
+        { ValueEnd , _ } -> { binary:part(Buffer, 0, ValueEnd - 1), binary:part(Buffer, ValueEnd, size(Buffer) - ValueEnd) }
+    end.
+
+until_closing_quote(Buffer) -> until_closing_quote(Buffer, 0, binary:at(Buffer, 0), 0, <<>>).
+
+until_closing_quote(Buffer, Start, $\\, Pos, Acc) ->
+    Escaped = binary:at(Buffer, Pos + 1 ),
+    until_closing_quote(Buffer, Start, binary:at(Buffer, Pos + 2), Pos + 2, <<Acc/binary, Escaped>>);
+until_closing_quote(Buffer, Start, $", Pos, Acc) ->
+    { Acc, binary:part(Buffer, Start + Pos + 1, size(Buffer) - Start - Pos - 1) };
+until_closing_quote(Buffer, _Start, Char, Pos, Acc) when Pos =:= size(Buffer) - 1 ->
+    { <<Acc/binary, Char>>, <<>> };
+until_closing_quote(Buffer, Start, Char, Pos, Acc) ->
+    until_closing_quote(Buffer, Start, binary:at(Buffer, Pos + 1), Pos + 1, <<Acc/binary, Char>>).

debian.tar.gz/src/commands/eimap_command_login.erl Added

@@ -0,0 +1,35 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_login).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command({ User, Password }) ->
+    UserBin = eimap_utils:ensure_binary(User),
+    PasswordBin = eimap_utils:ensure_binary(Password),
+    { <<"LOGIN ", UserBin/binary, " ", PasswordBin/binary>>, multiline_response }.
+
+process_line(_Data, Acc) -> Acc.
+
+%% Private API
+formulate_response(ok, _Acc) -> { fini, authed };
+formulate_response({ _, Reason }, _Acc) -> { error, Reason }.
+

debian.tar.gz/src/commands/eimap_command_logout.erl Added

@@ -0,0 +1,29 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_logout).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% Public API
+new_command(_Args) -> { <<"LOGOUT">>, multiline_response }.
+
+process_line(_Data, Acc) -> Acc.
+
+formulate_response(ok, _Data) -> { close_socket, ok };
+formulate_response({ _, Reason }, _Data) -> { close_socket, { error, Reason } }.
+

debian.tar.gz/src/commands/eimap_command_namespace.erl Added

@@ -0,0 +1,74 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_namespace).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command(_Args) -> { <<"NAMESPACE">>, multiline_response }.
+
+process_line(<<"* NAMESPACE ", Data/binary>>, Acc) -> [process_shared_prefix_parts(Data, 1)|Acc];
+process_line(_Line, Acc) -> Acc.
+
+
+formulate_response(ok, [Acc]) -> { fini, relevant_shared_prefix_parts(Acc) };
+formulate_response({ _, Reason }, _Acc) -> { error, Reason }.
+
+% Private API
+relevant_shared_prefix_parts([]) -> { none, none};
+relevant_shared_prefix_parts([[], [], _]) -> { none, none };
+relevant_shared_prefix_parts([[], Delim]) -> { none, Delim };
+relevant_shared_prefix_parts([SharedPrefix, [], _]) -> { SharedPrefix, "/" };
+relevant_shared_prefix_parts([SharedPrefix, Delim]) -> { SharedPrefix, Delim }.
+
+process_shared_prefix_parts(<<"NIL ", Data/binary>>, PartNumber) ->
+    process_shared_prefix_parts(Data, PartNumber + 1);
+process_shared_prefix_parts(<<"NIL", Data/binary>>, PartNumber) ->
+    process_shared_prefix_parts(Data, PartNumber + 1);
+process_shared_prefix_parts(<<"((", Data/binary>>, PartNumber) ->
+    process_shared_prefix_parts_inner(Data, [], PartNumber);
+process_shared_prefix_parts(<<>>, _PartNumber) -> [].
+
+process_shared_prefix_parts_inner(<<"))", _/binary>>, Acc, 3) ->
+    parse_shared_prefix_fields(lists:reverse(Acc), []);
+process_shared_prefix_parts_inner(<<")) ", Data/binary>>, _Acc, N) ->
+    process_shared_prefix_parts(Data, N + 1);
+process_shared_prefix_parts_inner(<<Char, Data/binary>>, Acc, 3) ->
+    process_shared_prefix_parts_inner(Data, [Char|Acc], 3);
+process_shared_prefix_parts_inner(<<_Char, Data/binary>>, Acc, N) ->
+    process_shared_prefix_parts_inner(Data, Acc, N);
+process_shared_prefix_parts_inner(<<>>, _Acc, _N) ->
+    [].
+
+%%FIXME: naively assumes no "s in the values are allowed. is this correct?
+parse_shared_prefix_fields([$"|Tail], Acc) ->
+    parse_shared_prefix_field_inner(Tail, [], Acc);
+parse_shared_prefix_fields([_|Tail], Acc) ->
+    parse_shared_prefix_fields(Tail, Acc);
+parse_shared_prefix_fields([], Acc) ->
+    lists:reverse(Acc).
+
+parse_shared_prefix_field_inner([$"|Tail], PartAcc, Acc) ->
+    parse_shared_prefix_fields(Tail, [lists:reverse(PartAcc)|Acc]);
+parse_shared_prefix_field_inner([Char|Tail], PartAcc, Acc) ->
+    parse_shared_prefix_field_inner(Tail, [Char|PartAcc], Acc);
+parse_shared_prefix_field_inner([], _PartAcc, Acc) ->
+    Acc.
+

debian.tar.gz/src/commands/eimap_command_noop.erl Added

@@ -0,0 +1,30 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_noop).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+%% https://tools.ietf.org/html/rfc3501#section-6.3.2
+
+%% Public API
+new_command(_) -> { <<"NOOP">>, multiline_response }.
+
+process_line(Data, Acc) -> eimap_command:process_status_line(Data, Acc).
+
+formulate_response(Response, Acc) -> eimap_command:formulate_response(Response, Acc).
+

debian.tar.gz/src/commands/eimap_command_peek_message.erl Added

@@ -0,0 +1,137 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_peek_message).
+-behavior(eimap_command).
+-export([new_command/1, parse/2, continue_parse/3]).
+-record(parse_state, { body_size, parts, data }).
+-record(parts, { headers = <<"">>, body = <<"">>, flags = <<"">> }).
+
+%% https://tools.ietf.org/html/rfc3501#section-6.4.5
+
+%% Public API
+new_command(MessageID) when is_integer(MessageID) -> new_command(integer_to_binary(MessageID));
+new_command(MessageID) when is_binary(MessageID) -> { <<"UID FETCH ",  MessageID/binary, " (FLAGS BODY.PEEK[HEADER] BODY.PEEK[TEXT])">>, blob_response }.
+
+continue_parse(Data, _Tag, #parse_state{ body_size = Size, parts = Parts, data = PrevData }) ->
+    try_body_parse(<<PrevData/binary, Data/binary>>, Size, Parts).
+
+parse(Data, Tag) when is_binary(Data) ->
+    case eimap_utils:check_response_for_failure(Data, Tag) of
+        ok -> process_parts(get_past_headers(Data));
+        { _, Reason } -> { error, Reason }
+    end.
+
+%% Private API
+process_parts(#parts{ headers = Headers, flags = Flags, body = Body }) ->
+    { fini, [ { flags, binary:split(Flags, <<" ">>, [global]) },
+              { headers, filter_headers(binary:split(Headers, <<"\r\n">>, [global])) },
+              { message, <<Headers/binary, Body/binary>> } ] };
+process_parts(Result) ->
+    Result.
+
+get_past_headers(<<" OK ", _Data/binary>>) -> #parts{};
+get_past_headers(<<" FETCH ", Data/binary>>) -> find_open_parens(Data);
+get_past_headers(<<_, Data/binary>>) -> get_past_headers(Data);
+get_past_headers(<<>>) -> { error, <<"Unparsable">> }.
+
+find_open_parens(<<$(, Data/binary>>) -> parse_next_component(Data, #parts{});
+find_open_parens(<<_, Data/binary>>) -> find_open_parens(Data).
+
+parse_next_component(<<"FLAGS (", Data/binary>>, Parts) ->
+    parse_flags(Data, Parts);
+parse_next_component(<<"BODY[HEADER] {", Data/binary>>, Parts) ->
+    parse_header(Data, Parts);
+parse_next_component(<<"BODY[TEXT] {", Data/binary>>, Parts) ->
+    parse_body(Data, Parts);
+parse_next_component(<<_, Data/binary>>, Parts) -> parse_next_component(Data, Parts);
+parse_next_component(<<"OK Completed", _/binary>>, Parts) -> Parts;
+parse_next_component(<<>>, Parts) -> Parts.
+
+parse_flags(Data, Parts) -> parse_flags(Data, Parts, Data, 0).
+parse_flags(OrigData, Parts, <<$), Rest/binary>>, Length) ->
+    FlagsString = binary:part(OrigData, 0, Length),
+    parse_next_component(Rest, Parts#parts{ flags = FlagsString });
+parse_flags(OrigData, Parts, <<_, Data/binary>>, Length) ->
+    parse_flags(OrigData, Parts, Data, Length + 1);
+parse_flags(_OrigData, Parts, <<>>, _Length) ->
+    Parts.
+
+parse_header(Data, Parts) -> parse_header(Data, Parts, Data, 0).
+parse_header(_OrigData, Parts, <<$}, Rest/binary>>, 0) ->
+    parse_next_component(Rest, Parts);
+parse_header(OrigData, Parts, <<$}, Rest/binary>>, Length) ->
+    ByteSizeString = binary:part(OrigData, 0, Length),
+    Size = binary_to_integer(ByteSizeString),
+    HeaderString = binary:part(Rest, 2, Size), %% the 2 is for \r\n
+    %%FIXME: make sure we have enough data loaded, otherwise continue
+    Remainder = binary:part(Rest, Size, byte_size(Rest) - Size),
+    parse_next_component(Remainder, Parts#parts{ headers = HeaderString });
+parse_header(OrigData, Parts, <<_, Rest/binary>>, Length) ->
+    parse_header(OrigData, Parts, Rest, Length + 1);
+parse_header(_OrigData, Parts, <<>>, _Length) ->
+    Parts.
+
+parse_body(Data, Parts) -> parse_body(Data, Parts, Data, 0).
+parse_body(_OrigData, Parts, <<$}, Rest/binary>>, 0) ->
+    parse_next_component(Rest, Parts);
+parse_body(OrigData, Parts, <<$}, Rest/binary>>, Length) ->
+    ByteSizeString = binary:part(OrigData, 0, Length),
+    Size = binary_to_integer(ByteSizeString),
+    %%lager:info("We have ... ~p ~p ~p", [ByteSizeString, Size, byte_size(Rest)]),
+    try_body_parse(Rest, Size, Parts);
+parse_body(OrigData, Parts, <<_, Rest/binary>>, Length) ->
+    parse_body(OrigData, Parts, Rest, Length + 1);
+parse_body(_OrigData, Parts, <<>>, _Length) ->
+    Parts.
+
+try_body_parse(Data, Size, Parts) ->
+    case Size > byte_size(Data) of
+        true ->
+            { more, fun ?MODULE:continue_parse/3, #parse_state{ body_size = Size, parts = Parts, data = Data } };
+        false ->
+            Body = binary:part(Data, 2, Size), %% the 2 is for \r\n
+            Remainder = binary:part(Data, Size, byte_size(Data) - Size),
+            process_parts(parse_next_component(Remainder, Parts#parts{ body = Body }))
+    end.
+
+filter_headers(RawHeaders) ->
+    filter_headers(RawHeaders, none, none, []).
+
+filter_headers([], CurrentKey, CurrentValue, Acc) ->
+    filter_header_add(CurrentKey, CurrentValue, Acc);
+filter_headers([<<>>|Headers], CurrentKey, CurrentValue, Acc) ->
+    filter_headers(Headers, CurrentKey, CurrentValue, Acc);
+filter_headers([Header|Headers], CurrentKey, CurrentValue, Acc) ->
+    filter_header(Headers, CurrentKey, CurrentValue, Acc, binary:split(Header, <<": ">>)).
+
+filter_header(Headers, CurrentKey, CurrentValue, Acc, [Key, Value]) ->
+    Added = filter_header_add(CurrentKey, CurrentValue, Acc),
+    filter_headers(Headers, Key, Value, Added);
+filter_header(Headers, none, _CurrentValue, Acc, _Value) ->
+    filter_headers(Headers, none, none, Acc);
+filter_header(Headers, CurrentKey, CurrentValue, Acc, [Value]) ->
+    %%TODO: get rid of tab, ensure "proper" whitespace
+    NewValue = <<CurrentValue/binary, Value/binary>>,
+    filter_headers(Headers, CurrentKey, NewValue, Acc).
+
+filter_header_add(CurrentKey, CurrentValue, Acc) when CurrentKey =/= none, CurrentValue =/= none ->
+    %%TODO: split CurrentValue on ','
+    [ { CurrentKey, CurrentValue } | Acc ];
+filter_header_add(_, _, Acc) ->
+    Acc.
+

debian.tar.gz/src/commands/eimap_command_starttls.erl Added

@@ -0,0 +1,32 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_starttls).
+-behavior(eimap_command).
+-export([new_command/1, formulate_response/2]).
+
+%% http://tools.ietf.org/html/rfc2342
+
+%% Public API
+new_command(_Args) -> { <<"STARTTLS">>, single_line_response }.
+
+formulate_response(Data, Tag) ->
+    case eimap_utils:check_response_for_failure(Data, Tag) of
+        ok -> starttls;
+        { _, Reason } -> { error, Reason }
+    end.
+

debian.tar.gz/src/commands/eimap_command_status.erl Added

@@ -0,0 +1,78 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_status).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, formulate_response/2]).
+
+% https://tools.ietf.org/html/rfc5464
+
+% supported attributes: messages, recent, uidnext, uidvalidity, unseen, annotate
+% Public API
+new_command({ Folder, Attributes }) when is_list(Folder) -> new_command({ list_to_binary(Folder), Attributes });
+new_command({ <<>>, Attributes}) -> new_command({ <<"INBOX">>, Attributes });
+new_command({ Folder, []}) -> new_command({ Folder, [messages] });
+new_command({ Folder, Attributes }) when is_list(Attributes) ->
+            AttributesString = attribute_string(Attributes, <<>>),
+            { <<"STATUS ", Folder/binary, " (", AttributesString/binary, ")">>, multiline_response }.
+
+process_line(<<"* STATUS ", Data/binary>>, Acc) ->
+    process_status_items(binary:match(Data, <<"(">>),
+                         binary:match(Data, <<")">>),
+                         Data, Acc);
+process_line(_, Acc) -> Acc.
+
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
+
+%% Private API
+attribute_string([], <<>>) -> attribute_string(messages);
+attribute_string([], String) -> String;
+attribute_string([Attribute|Attributes], <<>>) -> 
+    Attr = attribute_string(Attribute),
+    attribute_string(Attributes, Attr);
+attribute_string([Attribute|Attributes], String) -> 
+    case attribute_string(Attribute) of
+        <<>> -> attribute_string(Attributes, String);
+        Attr -> attribute_string(Attributes, <<String/binary, " ", Attr/binary>>)
+    end.
+
+% Private API
+process_status_items(nomatch, _, _Data, Acc) -> Acc;
+process_status_items(_, nomatch, _Data, Acc) -> Acc;
+process_status_items({ Start, _ }, { End, _ }, Data, Acc) ->
+    Parts = binary:split(binary:part(Data, Start + 1, End - Start - 1), <<" ">>, [global]),
+    process_next_status_item(Parts, Acc).
+
+process_next_status_item([], Acc) -> Acc;
+process_next_status_item([_], Acc) -> Acc;
+process_next_status_item([Token, Value|Parts], Acc) ->
+    Tuple = { attribute_atom(Token), binary_to_integer(Value) },
+    process_next_status_item(Parts, [Tuple|Acc]).
+
+attribute_string(messages) -> <<"MESSAGES">>;
+attribute_string(recent) -> <<"RECENT">>;
+attribute_string(uidnext) -> <<"UIDNEXT">>;
+attribute_string(uidvalidity) -> <<"UIDVALIDITY">>;
+attribute_string(unseen) -> <<"UNSEEN">>;
+attribute_string(_) -> <<>>.
+
+attribute_atom(<<"MESSAGES">>) -> messages;
+attribute_atom(<<"RECENT">>) -> recent;
+attribute_atom(<<"UIDNEXT">>) -> uidnext;
+attribute_atom(<<"UIDVALIDITY">>) -> uidvalidity;
+attribute_atom(<<"UNSEEN">>) -> unseen.
+

debian.tar.gz/src/commands/eimap_command_switch_folder.erl Added

@@ -0,0 +1,65 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_switch_folder).
+-behavior(eimap_command).
+-export([new_command/1, process_line/2, process_tagged_line/2, formulate_response/2]).
+
+%% https://tools.ietf.org/html/rfc3501#section-6.3.2
+
+%% Public API
+new_command({ MBox, Mechanism }) when is_list(MBox) -> new_command({ list_to_binary(MBox), Mechanism });
+new_command({ MBox, select }) -> new_command(MBox);
+new_command({ MBox, examine }) -> { <<"EXAMINE \"", MBox/binary, "\"">>, all_multiline_response };
+new_command(MBox) when is_list(MBox) -> new_command(list_to_binary(MBox));
+new_command(MBox) when is_binary(MBox) -> { <<"SELECT \"", MBox/binary, "\"">>, all_multiline_response }.
+
+%TODO: parse:
+% REQUIRED untagged responses: FLAGS, EXISTS, RECENT
+% REQUIRED OK untagged responses:  UNSEEN,  PERMANENTFLAGS, UIDNEXT, UIDVALIDITY
+process_line(<<"* OK [", Info/binary>>, Acc) ->
+    case binary:match(Info, <<"]">>) of
+        nomatch -> Acc;
+        { ClosingBracket, _ } -> process_ok_response(binary:part(Info, 0, ClosingBracket), Acc)
+    end;
+process_line(<<"* FLAGS ", FlagString/binary>>, Acc) ->
+    Flags = eimap_utils:parse_flags(FlagString),
+    [{ flags, Flags }|Acc];
+process_line(<<"* ", Info/binary>>, Acc) ->
+    case binary:split(Info, <<" ">>) of
+        [ Value, Key ] -> [{ eimap_utils:binary_to_atom(Key), binary_to_integer(Value) }|Acc];
+        _ ->Acc
+    end;
+process_line(_Data, Acc) -> Acc.
+
+process_tagged_line(Data, Acc) ->
+    case binary:match(Data, <<"[READ-WRITE]">>) of
+        nomatch -> [{ writeable, false }|Acc];
+        _ -> [{ writeable, true}|Acc]
+    end.
+
+formulate_response(Response, Acc) -> eimap_command:formulate_response(Response, Acc).
+
+%PRIVATE
+process_ok_response(<<"PERMANENTFLAGS ", FlagString/binary>>, Acc) -> [{ permanent_flags, eimap_utils:parse_flags(FlagString) }|Acc];
+process_ok_response(<<"UIDVALIDITY ", String/binary>>, Acc) -> [{ uid_validity, binary_to_integer(String) }|Acc];
+process_ok_response(<<"UIDNEXT ", String/binary>>, Acc) -> [{ uid_next, binary_to_integer(String) }|Acc];
+process_ok_response(<<"HIGHESTMODSEQ ", String/binary>>, Acc) -> [{ highest_mod_seq, binary_to_integer(String) }|Acc];
+process_ok_response(<<"URLMECH ", String/binary>>, Acc) -> [{ url_mech, eimap_utils:binary_to_atom(String) }|Acc]; %TODO: this is very ugly
+process_ok_response(<<"ANNOTATIONS ", String/binary>>, Acc) -> [{ annotations, binary_to_integer(String) }|Acc];
+process_ok_response(String, Acc) -> lager:warning("eimap_command_select_folder: Unknown untagged OK response ~s~n", [String]), Acc.
+

debian.tar.gz/src/eimap.app.src Added

debian.tar.gz/src/eimap.erl Added

@@ -0,0 +1,479 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap).
+-behaviour(gen_fsm).
+
+%% API
+-export([start_link/1,
+         %% passthrough mode, where data is just sent to the server blindly and
+         %% responses passed back equally blindly. in this mode the user is on
+         %% their own and better know what they are doing. can only be activated
+         %% when disconnected or idle
+         start_passthrough/2, stop_passthrough/1, passthrough_data/2,
+         %% connection management
+         connect/1, connect/3, disconnect/1,
+         %% commands
+         starttls/3,
+         capabilities/3,
+         login/5, logout/3,
+         compress/1,
+         get_server_metadata/4, get_server_metadata/6,
+         get_folder_status/5,
+         get_folder_metadata/5, get_folder_metadata/7,
+         get_folder_annotations/4,
+         peek_message_headers_and_body/5,
+         get_path_tokens/3,
+         noop/3]).
+
+%% gen_fsm callbacks
+-export([disconnected/2, idle/2, passthrough/2, wait_response/2, startingtls/2]).
+-export([init/1, handle_event/3, handle_sync_event/4, handle_info/3, terminate/3, code_change/4]).
+
+%% state record definition
+-record(state, { host, port, tls, tls_state = false, socket, server_id = <<>>,
+                 command_serial = 1, command_queue = queue:new(),
+                 current_command, current_mbox,
+                 passthrough = false, passthrough_recv, passthrough_send_buffer = <<>>,
+                 inflator, deflator}).
+-record(command, { tag, mbox, message, from, response_type, response_token, parse_state }).
+
+-define(SSL_UPGRADE_TIMEOUT, 5000).
+-define(TCP_CONNECT_TIMEOUT, 5000).
+
+%% public API
+start_link(Options) when is_list(Options) -> gen_fsm:start_link(?MODULE, Options, []).
+
+start_passthrough(PID, Receiver) when is_pid(Receiver)  -> gen_fsm:send_all_state_event(PID, { start_passthrough, Receiver } ).
+stop_passthrough(PID) -> gen_fsm:send_all_state_event(PID, stop_passthrough).
+passthrough_data(PID, Data) when is_binary(Data) -> gen_fsm:send_all_state_event(PID, { passthrough, Data }).
+connect(PID) -> connect(PID, undefined, undefined).
+connect(PID, From, ResponseToken) -> gen_fsm:send_all_state_event(PID, { connect, From, ResponseToken }).
+disconnect(PID) -> gen_fsm:send_all_state_event(PID, disconnect).
+
+-spec compress(EImap :: pid()) -> ok.
+compress(EImap) when is_pid(EImap) ->
+    send_command_to_queue(EImap, EImap, compress, eimap_command_compress, ok).
+
+-spec starttls(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+starttls(EImap, From, ResponseToken) when is_pid(EImap) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_starttls, ok).
+
+-spec capabilities(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+capabilities(EImap, From, ResponseToken) when is_pid(EImap) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_capability, ok).
+
+-spec login(EImap :: pid(), From :: pid(), ResponseToken :: any(), User :: list() | binary(), Pass :: list() | binary()) -> ok.
+login(EImap, From, ResponseToken, User, Pass) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_login, { User, Pass }).
+
+-spec logout(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+logout(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_logout, ok).
+
+-type status_property() :: messages | recent | uidnext | uidvalidity | unseen.
+-type status_properties() :: [status_property()].
+-spec get_folder_status(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: status_properties()) -> ok.
+get_folder_status(EImap, From, ResponseToken, Folder, Properties) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_status, { Folder, Properties }).
+
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()]) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties) ->
+    get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, infinity, nomax).
+
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, Depth, MaxSize) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { Folder, Properties, Depth, MaxSize }).
+
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()]) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, infinity, nomax }).
+
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties, Depth, MaxSize) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, Depth, MaxSize }).
+
+-spec get_folder_annotations(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()]) -> ok.
+get_folder_annotations(EImap, From, ResponseToken, Folder) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_annotation, Folder).
+
+-spec peek_message_headers_and_body(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()], MessageID :: [integer() | binary()]) -> ok.
+peek_message_headers_and_body(EImap, From, ResponseToken, Folder, MessageID) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_peek_message, MessageID, Folder).
+
+-spec get_path_tokens(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+get_path_tokens(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_namespace, ok).
+
+-spec noop(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+noop(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_noop, ok).
+
+
+%% gen_server API
+init(Options) ->
+    Host = proplists:get_value(host, Options, "127.0.0.1"),
+    Port = proplists:get_value(port, Options, 143),
+    TLS = proplists:get_value(tls, Options, false),
+    State = #state { host = Host, port = Port, tls  = TLS },
+    { ok, disconnected, State }.
+
+disconnected({ connect, Receiver, ResponseToken }, #state{ command_queue = CommandQueue, host = Host, port = Port, tls = TLS, socket = undefined } = State) ->
+    %lager:debug("CONNECTING! ~p ~p", [Receiver, ResponseToken]),
+    { {ok, Socket}, TlsState, SendCapabilitiesTo, NewCommandQueue } = create_socket(Host, Port, TLS, Receiver, ResponseToken, CommandQueue),
+    { Message, ResponseType } = eimap_command_capability:new_command(parse_serverid),
+    Command = #command{ message = Message, response_type = ResponseType,
+                        from = SendCapabilitiesTo, response_token = { connected, Receiver, ResponseToken },
+                        parse_state = eimap_command_capability },
+    { next_state, wait_response, State#state { socket = Socket, tls_state = TlsState, current_command = Command, command_queue = NewCommandQueue } };
+disconnected(Command, State) when is_record(Command, command) ->
+    { next_state, disconnected, enque_command(Command, State) }.
+
+passthrough(flush_passthrough_buffer, #state{ passthrough_send_buffer = Buffer } = State) ->
+    %lager:info("Passing through ~p", [Buffer]),
+    passthrough({ passthrough, Buffer }, State#state{ passthrough_send_buffer = <<>> });
+passthrough({ passthrough, Data }, #state{ socket = Socket, tls_state = true } = State) ->
+    %lager:info("Passing through ssl \"~s\"", [Data]),
+    ssl:send(Socket, deflated(Data, State)),
+    { next_state, passthrough, State };
+passthrough({ passthrough, Data }, #state{ socket = Socket } = State) ->
+    %lager:info("Passing through tcp \"~s\"", [Data]),
+    gen_tcp:send(Socket, deflated(Data, State)),
+    { next_state, passthrough, State };
+passthrough({ data, Data }, #state{ passthrough_recv = Receiver } = State) ->
+    %lager:info("Passing back ~p", [Data]),
+    Receiver ! { imap_server_response, Data },
+    { next_state, passthrough, State };
+passthrough(Command, State) when is_record(Command, command) ->
+    gen_fsm:send_event(self(), process_command_queue),
+    { next_state, idle, enque_command(Command, State) }.
+
+idle(process_command_queue, #state{ command_queue = Queue } = State) ->
+    case queue:out(Queue) of
+       { { value, Command }, ModifiedQueue } when is_record(Command, command) ->
+            %lager:info("Clearing queue of ~p", [Command]),
+            NewState = send_command(Command, State#state{ command_queue = ModifiedQueue }),
+            { next_state, wait_response, NewState };
+       { empty, ModifiedQueue } ->
+            NextState = next_state_after_emptied_queue(State),
+            %lager:info("Queue was empty moving on to ... ~p", [NextState]),
+            { next_state, NextState, State#state{ command_queue = ModifiedQueue } }
+    end;
+idle({ data, _Data }, State) ->
+    %%lager:info("Idling, server sent: ~p", [_Data]),
+    { next_state, idle, State };
+idle(Command, State) when is_record(Command, command) ->
+    %%lager:info("Idling"),
+    NewState = send_command(Command, State),
+    { next_state, wait_response, NewState };
+idle(_Event, State) ->
+    { next_state, idle, State }.
+
+next_state_after_emptied_queue(#state{ passthrough = true }) ->
+    gen_fsm:send_event(self(), flush_passthrough_buffer),
+    passthrough;
+next_state_after_emptied_queue(_State) ->
+    idle.
+
+
+%%TODO a variant that checks "#command{ from = undefined }" to avoid parsing responses which will go undelivered?
+wait_response(Command, State) when is_record(Command, command) ->
+    { next_state, wait_response, enque_command(Command, State) };
+wait_response({ data, _Data }, #state{ current_command = #command{ parse_state = undefined } } = State) ->
+    gen_fsm:send_event(self(), process_command_queue),
+    { next_state, idle, State };
+wait_response({ data, Data }, #state{ current_command = #command{ response_type = ResponseType, parse_state = CommandState , tag = Tag } } = State) ->
+    Response = eimap_command:parse_response(ResponseType, Data, Tag, CommandState),
+    %%lager:info("Response from parser was ~p ~p, size of queue ~p", [More, Response, queue:len(State#state.command_queue)]),
+    next_command_after_response(Response, State);
+wait_response(process_command_queue, State) ->
+    % ignore this one, we'll get to it when the response comes
+    { next_state, wait_response, State }.
+
+startingtls({ passthrough, Data }, #state{ passthrough = true, passthrough_send_buffer = Buffer } = State) ->
+    { next_state, startingtls, State#state{ passthrough_send_buffer = <<Buffer/binary, Data>> } };
+startingtls(Command, State) when is_record(Command, command) ->
+    { next_state, startingtls, enque_command(Command, State) };
+startingtls({ data, Data }, #state{ current_command = #command{ response_type = ResponseType, parse_state = CommandState, tag = Tag } } = State) ->
+    Response = eimap_command:parse_response(ResponseType, Data, Tag, CommandState),
+    %%lager:info("Response from parser was ~p ~p, size of queue ~p", [More, Response, queue:len(State#state.command_queue)]),
+    next_command_after_response(Response, State).
+
+handle_event({ connect, _From, _ResponseToken } = Event, disconnected, State) ->
+    gen_fsm:send_event(self(), Event),
+    { next_state, disconnected, State };
+handle_event({ connect, _From, _ResponseToken }, _Statename, State) ->
+    %%lager:info("Already connected to IMAP server!"),
+    { next_state, _Statename, State };
+handle_event(disconnect, _StateName, State) ->
+    close_socket(State),
+    { next_state, disconnected, reset_state(State) };
+handle_event({ ready_command, Command }, StateName, State) when is_record(Command, command) ->
+    ?MODULE:StateName(Command, State);
+handle_event({ start_passthrough, Receiver }, StateName, State) ->
+    { next_state, StateName, State#state{ passthrough = true, passthrough_recv = Receiver } };
+handle_event(stop_passthrough, StateName, State) ->
+    NextState = case StateName of
+                    passthrough ->
+                        gen_fsm:send_event(self(), process_command_queue),
+                        idle;
+                    State -> State
+                end,
+    { next_state, NextState, State#state{ passthrough = false } };
+handle_event({ passthrough, Data }, passthrough, #state{ passthrough = true } = State) ->
+    ?MODULE:passthrough({ passthrough, Data }, State);
+handle_event({ passthrough, Data }, StateName, #state{ passthrough = true, passthrough_send_buffer = Buffer } = State) ->
+    NewBuffer = <<Buffer/binary, Data/binary>>,
+    case StateName of
+        idle -> gen_fsm:send_event(self(), process_command_queue);
+        _ -> ok
+    end,
+    { next_state, StateName, State#state{ passthrough_send_buffer = NewBuffer } };
+handle_event(_Event, StateName, State) -> { next_state, StateName, State}.
+
+handle_sync_event(_Event, _From, StateName, State) -> { next_state, StateName, State}.
+
+handle_info({ ssl, Socket, Bin }, StateName, #state{ socket = Socket } = State) ->
+    % Flow control: enable forwarding of next TCP message
+    ssl:setopts(Socket, [{ active, once }]),
+    Data = inflated(Bin, State),
+    %lager:info("Received from server over ssl: ~s", [Data]),
+    ?MODULE:StateName({ data, Data }, State);
+handle_info({ tcp, Socket, Bin }, StateName, #state{ socket = Socket } = State) ->
+    % Flow control: enable forwarding of next TCP message
+    inet:setopts(Socket, [{ active, once }]),
+    Data = inflated(Bin, State),
+    %lager:info("Received from server plaintext: ~s", [Data]),
+    ?MODULE:StateName({ data, Data }, State);
+handle_info({ ssl_closed, Socket }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
+    lager:debug("~p Disconnected from ~p:~p .\n", [self(), Host, Port]),
+    { stop, normal, State };
+handle_info({ ssl_error, Socket, _Reason }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
+    lager:info("~p Disconnected due to socket error from ~p:~p .\n", [self(), Host, Port]),
+    { stop, normal, State };
+handle_info({ tcp_closed, Socket }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
+    lager:debug("~p Disconnected from ~p:~p .\n", [self(), Host, Port]),
+    { stop, normal, State };
+handle_info({ tcp_error, Socket, _Reason }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
+    lager:info("~p Disconnected due to socket error from ~p:~p .\n", [self(), Host, Port]),
+    { stop, normal, State };
+handle_info({ { connected, Receiver, ResponseToken }, { Capabilities, ServerID } }, _StateName, #state{ passthrough = Passthrough, passthrough_recv = PassthroughReceiver, tls = TLS } = State) ->
+    case TLS of
+        starttls ->
+            % we do not pass through or notifty when we are going to automatically do a starttls
+            % this allows us to send the post-starttls capabilities triggering client activity
+            % only AFTER we have completely set up the connectiona, as that usually tends to
+            % alter the capabilities
+            %
+            % if the user of eimap does not want this behavior, they can starttls themselves
+            % explicitly
+            ok;
+        _ ->
+            %lager:debug("Connected, capabilities are: ~s; ServerID is ~s", [Capabilities, ServerID]),
+            send_hello_string(Capabilities, ServerID, Receiver, ResponseToken, Passthrough, PassthroughReceiver)
+    end,
+    { next_state, idle, State#state{ current_command = undefined, server_id = ServerID } };
+handle_info({ { posttls_capabilities, Receiver, ResponseToken }, Capabilities }, _StateName, #state{ server_id = ServerID, passthrough = Passthrough, passthrough_recv = PassthroughReceiver } = State) ->
+    OurCapabilities =
+        case binary:match(Capabilities, <<"STARTTLS">>) of
+            nomatch -> <<Capabilities/binary, " STARTTLS">>;
+            _ -> Capabilities
+        end,
+    send_hello_string(OurCapabilities, ServerID, Receiver, ResponseToken, Passthrough, PassthroughReceiver),
+    { next_state, idle, State#state{ current_command = none } };
+handle_info({ { selected, MBox }, ok }, StateName, State) ->
+    %%lager:info("~p Selected mbox ~p", [self(), MBox]),
+    { next_state, StateName, State#state{ current_mbox = MBox } };
+handle_info({ { selected, MBox }, { error, Reason } }, StateName, State) ->
+    lager:info("Failed to select mbox ~p: ~p", [MBox, Reason]),
+    NewQueue = queue:filter(fun(Command) -> notify_of_mbox_failure_during_filter(Command, Command#command.mbox =:= MBox) end, State#state.command_queue),
+    { next_state, StateName, State#state{ command_queue = NewQueue } };
+handle_info(starttls_complete, StateName, State) ->
+    %lager:info("STARTTLS completed successfully"),
+    { next_state, StateName, State };
+handle_info(Info, StateName, State) ->
+    lager:debug("handle_info called with unhandled info of ~p", [Info]),
+    { next_state, StateName, State }.
+
+terminate(_Reason, _Statename, State) -> close_socket(State), ok.
+
+code_change(_OldVsn, Statename, State, _Extra) -> { ok, Statename, State }.
+
+%% private API
+send_command_to_queue(EImap, From, ResponseToken, Module, Args) ->
+    send_command_to_queue(EImap, From, ResponseToken, Module, Args, undefined).
+send_command_to_queue(EImap, From, ResponseToken, Module, Args, Folder) ->
+    { Message, ResponseType } = Module:new_command(Args),
+    Command = #command{ mbox = Folder, message = Message, response_type = ResponseType,
+                        from = From, response_token = ResponseToken,
+                        parse_state = Module },
+    gen_fsm:send_all_state_event(EImap, { ready_command, Command }).
+
+send_hello_string(Capabilities, ServerId, Receiver, ResponseToken, Passthrough, PassthroughReceiver) ->
+    notify_of_response([{ capabilities, Capabilities }, { server_id, ServerId } ], Receiver, ResponseToken),
+    passthrough_capabilities(Capabilities, ServerId, Passthrough, PassthroughReceiver).
+
+passthrough_capabilities(Capabilities, ServerId, true, Receiver) ->
+    Message = <<"* OK [CAPABILITY ", Capabilities/binary, "] ", ServerId/binary, "\r\n">>,
+    Receiver ! { imap_server_response, Message };
+passthrough_capabilities(_Capabilities, _ServerId, _Passthrough, _Receiver) -> ok.
+
+notify_of_response(none, _Command) -> ok;
+notify_of_response(Response, #command { from = From, response_token = Token }) -> notify_of_response(Response, From, Token);
+notify_of_response(_, _) -> ok.
+
+notify_of_response(_Response, undefined, _Token) -> ok;
+notify_of_response(Response, From, undefined) -> From ! Response;
+notify_of_response(Response, From, Token) -> From ! { Token, Response }.
+
+%% the return is inverted for filtering
+notify_of_mbox_failure_during_filter(Command, true) -> notify_of_response({ error, mailboxnotfound }, Command), false;
+notify_of_mbox_failure_during_filter(_Command, false) -> true.
+
+next_command_after_response({ more, ParseState }, State) ->
+    { next_state, wait_response, State#state{ current_command = State#state.current_command#command{ parse_state = ParseState } } };
+next_command_after_response({ error, _ } = ErrorResponse, State) ->
+    notify_of_response(ErrorResponse, State#state.current_command),
+    gen_fsm:send_event(self(), process_command_queue),
+    { next_state, idle, State#state{ current_command = undefined } };
+next_command_after_response({ fini, Response }, State) ->
+    %lager:info("Notifying with ~p", [State#state.current_command]),
+    notify_of_response(Response, State#state.current_command),
+    gen_fsm:send_event(self(), process_command_queue),
+    { next_state, idle, State#state{ current_command = undefined } };
+next_command_after_response(starttls, State) ->
+    { TLSState, Socket } = upgrade_socket(State),
+    %lager:info("~p Upgraded the socket ...", [self()]),
+    gen_fsm:send_event(self(), process_command_queue),
+    { next_state, idle, State#state{ current_command = undefined, socket = Socket, tls_state = TLSState } };
+next_command_after_response(compression_active, State) ->
+    { Inflator, Deflator } = eimap_utils:new_imap_compressors(),
+    gen_fsm:send_event(self(), process_command_queue),
+    { next_state, idle, State#state{ current_command = undefined, inflator = Inflator, deflator = Deflator } };
+next_command_after_response({ close_socket, Response }, State) ->
+    notify_of_response(Response, State#state.current_command),
+    { stop, normal, State }.
+
+tag_field_width(Serial) when Serial < 10000 -> 4;
+tag_field_width(Serial) -> tag_field_width(Serial / 10000, 5).
+tag_field_width(Serial, Count) when Serial < 10 -> Count;
+tag_field_width(Serial, Count) -> tag_field_width(Serial / 10, Count + 1).
+
+create_socket(Host, Port, true, _Receiver, _ResponseToken, CommandQueue) ->
+    { ssl:connect(Host, Port, socket_options(), ?SSL_UPGRADE_TIMEOUT), true, self(), CommandQueue };
+create_socket(Host, Port, starttls, Receiver, ResponseToken, CommandQueue) ->
+    %lager:debug("Setting up the tls creation with ultimate end point of ~p ~p", [Receiver, ResponseToken]),
+    % we do an implicit TLS by adding a starttls command and then a capability command so we can
+    % pretend to the user that the socket just magically opened up like this.
+    %TODO: some duplicated code here; would be nice to clean this up a bit?
+    { TlsMessage, TlsResponseType } = eimap_command_starttls:new_command(ok),
+    TlsCommand = #command{ message = TlsMessage, response_type = TlsResponseType,
+                           from = self(), response_token = undefined,
+                           parse_state = eimap_command_starttls },
+    { CapMessage, CapResponseType } = eimap_command_capability:new_command(ok),
+    CapabilitiesCommand = #command{ message = CapMessage, response_type = CapResponseType,
+                                    from = self(), response_token = { posttls_capabilities, Receiver, ResponseToken },
+                                    parse_state = eimap_command_capability },
+    % note the use of queue:in_r to _prepend_ the commands so they get run first even if the user
+    % has pre-connection queued up commands
+    NewCommandQueue = queue:in_r(TlsCommand, queue:in_r(CapabilitiesCommand, CommandQueue)),
+    { gen_tcp:connect(Host, Port, socket_options(), ?TCP_CONNECT_TIMEOUT), false, self(), NewCommandQueue };
+create_socket(Host, Port, _, _Receiver, _ResponseToken, CommandQueue) ->
+    { gen_tcp:connect(Host, Port, socket_options(), ?TCP_CONNECT_TIMEOUT), false, self(), CommandQueue }.
+
+socket_options() -> [binary, { active, once }, { send_timeout, 5000 }].
+
+upgrade_socket(#state{ socket = Socket, tls_state = true, current_command = Command }) ->
+    notify_of_response(starttls_complete, Command),
+    ssl:setopts(Socket, [{ active, once }]),
+    { true, Socket };
+upgrade_socket(#state{ socket = Socket, current_command = Command }) ->
+    %lager:debug("~p upgrading the server socket due to starttls"[self()]),
+    case ssl:connect(Socket, socket_options(), ?SSL_UPGRADE_TIMEOUT) of
+        { ok, SSLSocket } ->
+            %lager:info("~p it worked", [self()]),
+            notify_of_response(starttls_complete, Command),
+            ssl:setopts(SSLSocket, [{ active, once }]),
+            { true, SSLSocket };
+        { error, Reason } ->
+            lager:warning("~p StartTLS failed due to: ~p", [self(), Reason]),
+            notify_of_response(starttls_failed, Command),
+            inet:setopts(Socket, [{ active, once }]),
+            { false, Socket }
+    end.
+
+close_socket(#state{ socket = undefined }) -> false;
+close_socket(#state{ socket = Socket, tls_state = true }) -> ssl:close(Socket);
+close_socket(#state{ socket = Socket }) -> gen_tcp:close(Socket).
+
+reset_state(State) -> State#state{ socket = undefined, command_serial = 1 }.
+
+%% sending command code paths:
+%%  0. not connected, TLS/SSL, unencrypted
+%%  1. no mbox needed, mbox is already selected, mbox needs selecting
+send_command(Command, #state{ socket = undefined } = State) ->
+    lager:warning("Not connected, dropping command on floor: ~s", [Command]),
+    State;
+send_command(Command, #state{ tls_state = true} = State) ->
+    send_command(fun ssl:send/2, Command, State);
+send_command(Command, State) ->
+    send_command(fun gen_tcp:send/2, Command, State).
+
+send_command(SocketFun, #command{ mbox = undefined } = Command, State) ->
+    %%lager:info("~p SELECT_DEBUG issuing command without mbox: ~p", [self(), Command#command.message]),
+    send_command_now(SocketFun, Command, State);
+send_command(SocketFun, #command{ mbox = MBox } = Command, #state{ current_mbox = CurrentMbox } = State) ->
+    %%lager:info("~p SELECT_DEBUG issuing command with mbox ~p (current: ~p, equal -> ~p): ~p", [self(), MBox, CurrentMbox, (MBox =:= CurrentMbox), Command#command.message]),
+    send_command_or_select_mbox(SocketFun, Command, State, MBox, MBox =:= CurrentMbox).
+
+send_command_or_select_mbox(SocketFun, Command, State, _MBox, true) ->
+    send_command_now(SocketFun, Command, State);
+send_command_or_select_mbox(SocketFun, DelayedCommand, State, MBox, false) ->
+    NextState = reenque_command(DelayedCommand, State),
+    %TODO: this really should be SELECT rather than EXAMINE
+    { SelectMessage, ResponseType } = eimap_command_switch_folder:new_command(MBox),
+    SelectCommand = #command{ message = SelectMessage, response_type = ResponseType,
+                              parse_state = eimap_command_switch_folder,
+                              from = self(), response_token = { selected, MBox } },
+    %%lager:info("~p SELECT_DEBUG: Doing a select first ~p", [self(), SelectMessage]),
+    send_command_now(SocketFun, SelectCommand, NextState).
+
+send_command_now(SocketFun, #command{ message = Message } = Command, #state{ command_serial = Serial, socket = Socket } = State) ->
+    Tag = list_to_binary(io_lib:format("EG~*..0B", [tag_field_width(Serial), Serial])),
+    Data = <<Tag/binary, " ", Message/binary, "\r\n">>,
+    %lager:info("Sending command via ~p: ~s", [Fun, Data]),
+    SocketFun(Socket, deflated(Data, State)),
+    State#state{ command_serial = Serial + 1, current_command = Command#command{ tag = Tag } }.
+
+enque_command(Command, State) ->
+    %%lager:info("Enqueuing command ~p", [Command]),
+    State#state { command_queue = queue:in(Command, State#state.command_queue) }.
+
+reenque_command(Command, State) ->
+    %%lager:info("Re-queueing command ~p", [Command]),
+    State#state { command_queue = queue:in_r(Command, State#state.command_queue) }.
+
+inflated(Data, #state{ inflator = undefined }) -> Data;
+inflated(Data, #state{ inflator = Inflator }) ->  joined(zlib:inflate(Inflator, Data), <<>>).
+
+deflated(Data, #state{ deflator = undefined }) -> Data;
+deflated(Data, #state{ deflator = Deflator }) ->  joined(zlib:deflate(Deflator, Data, sync), <<>>).
+
+joined([], Binary) -> Binary;
+joined([H|Rest], Binary) -> joined(Rest, <<Binary/binary, H/binary>>).
+
+

debian.tar.gz/src/eimap_command.erl Added

@@ -0,0 +1,78 @@
+-module(eimap_command).
+
+-export([
+         parse_response/4,
+         formulate_response/2,
+         process_status_line/2
+        ]).
+
+-type more_tuple() :: { more, ParseContinuation :: parse_continuation(), State :: term }.
+-type finished_tuple() :: { fini, Results :: term }.
+-type error_tuple() :: { error, Reason :: binary() }.
+-type parse_continuation() :: fun((Data :: binary(), Tag :: binary(), State :: term()) ->
+                                   more_tuple() | finished_tuple() | error_tuple()).
+
+-callback new_command(Args :: any()) -> { binary(), single_line_response | multiline_reponse | blob_response }.
+% TODO:bring back when we can depend on OTP 18 which introduced optional_callback
+% also define parse/2 (for blob_response), formulate_response/2
+%-callback process_line(Data :: binary(), Acc :: any()) ->
+%    more_tuple() | finished_tuple() | error_tuple() | starttls.
+
+parse_response(multiline_response, Data, Tag, ParseState) -> multiline_parse(false, Data, Tag, ParseState);
+parse_response(all_multiline_response, Data, Tag, ParseState) -> multiline_parse(parse_tagged, Data, Tag, ParseState);
+parse_response(single_line_response, Data, Tag, Module) -> Module:formulate_response(Data, Tag);
+parse_response(blob_response, Data, Tag, { Continuation, ParseState }) -> Continuation(Data, Tag, ParseState);
+parse_response(blob_response, Data, Tag, Module) ->
+    case Module:parse(Data, Tag) of
+        { more, Continuation, ParseState } -> { more, { Continuation, ParseState } };
+        Response -> Response
+    end.
+
+multiline_parse(ParseTaggedLine, Data, Tag, { LastPartialLine, Acc, Module }) ->
+    FullBuffer = <<LastPartialLine/binary, Data/binary>>,
+    { FullLinesBuffer, NewLastPartialLine } = eimap_utils:only_full_lines(FullBuffer),
+    Lines = binary:split(FullLinesBuffer, <<"\r\n">>, [global]),
+    process_lines(ParseTaggedLine, Tag, NewLastPartialLine, Lines, Acc, Module);
+multiline_parse(ParseTaggedLine, Data, Tag, Module) ->
+    multiline_parse(ParseTaggedLine, Data, Tag, { <<>>, [], Module }).
+
+process_lines(_ParseTaggedLine, _Tag, LastPartialLine, [], Acc, Module) -> { more, { LastPartialLine, Acc, Module } };
+process_lines(ParseTaggedLine, Tag, LastPartialLine, [Line|MoreLines], Acc, Module) ->
+    { FirstLine, ContinuationBytes } = eimap_utils:num_literal_continuation_bytes(Line),
+    process_line(ContinuationBytes, ParseTaggedLine, eimap_utils:is_tagged_response(FirstLine, Tag), Tag, LastPartialLine, FirstLine, MoreLines, Acc, Module).
+
+
+process_line(ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, [<<>>|MoreLines], Acc, Module) ->
+    %% skip empty lines
+    process_line(ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, MoreLines, Acc, Module);
+process_line(0, ParseTaggedLine, tagged, Tag, _LastPartialLine, Line, _MoreLines, Acc, Module) ->
+    Checked = eimap_utils:check_response_for_failure(Line, Tag),
+    Module:formulate_response(Checked, parse_tagged(Checked, ParseTaggedLine, Line, Acc, Module));
+process_line(0, ParseTaggedLine, untagged, Tag, LastPartialLine, Line, MoreLines, Acc, Module) ->
+    io:format("Calling it here with ~p~n~n...", [Line]),
+    process_lines(ParseTaggedLine, Tag, LastPartialLine, MoreLines, Module:process_line(Line, Acc), Module);
+process_line(ContinuationBytes, ParseTaggedLine, _IsTagged, Tag, LastPartialLine, Line, [], Acc, Module) ->
+    %% the line was continued, but there is no more lines ... so this line is now our last partial line. more must be on its way
+    io:format("Missing lines!~p~n~n", [Acc]),
+    BytesAsBinary = integer_to_binary(ContinuationBytes),
+    process_lines(ParseTaggedLine, Tag, <<Line/binary, ${, BytesAsBinary/binary, $}, LastPartialLine/binary>>, [], Acc, Module);
+process_line(_ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, [NextLine|MoreLines], Acc, Module) ->
+    { StrippedNextLine, NextContinuationBytes } = eimap_utils:num_literal_continuation_bytes(NextLine),
+    io:format("Connected up the next line: ~p ~i~n", [StrippedNextLine, NextContinuationBytes]),
+    FullLine = <<Line/binary, StrippedNextLine/binary>>,
+    process_line(NextContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, FullLine, MoreLines, Acc, Module).
+
+formulate_response(ok, Data) -> { fini, Data };
+formulate_response({ _, Reason }, _Data) -> { error, Reason }.
+
+parse_tagged(_, false, _Line, Acc, _Module) -> Acc; % we are not passing the tagged line forward (no content, e.g)
+parse_tagged(ok, _, Line, Acc, Module) -> Module:process_tagged_line(Line, Acc); % success, so pass it forward
+parse_tagged(_Checked, _ParsedTaggedLine, _Line, Acc, _Module) -> Acc. % error, don't bother passing it forward
+
+-spec process_status_line(Line :: binary(), Acc :: list()) -> NewAcc :: list().
+process_status_line(<<"* ", Rest/binary>>, Acc) -> process_matched_status_line(binary:split(Rest, <<" ">>, [global]), Acc);
+process_status_line(_, Acc) -> Acc.
+
+process_matched_status_line([Number, Key|_], Acc) -> [{ eimap_utils:binary_to_atom(Key), binary_to_integer(Number) }|Acc];
+process_matched_status_line(_, Acc) -> Acc.
+

debian.tar.gz/src/eimap_uidset.erl Added

@@ -0,0 +1,78 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_uidset).
+-export([uid_list_to_binary/1, parse/1, next_uid/1]).
+
+% for internal use only
+-export([add_uid_as_binary_to_list/2, stitch_bin_list/2]).
+
+%% tokens have the form: integer | { integer, integer }
+-record(uidset, { tokens = [], current = none }).
+
+uid_list_to_binary(UidList) when is_list(UidList) ->
+    ListOfBins = lists:foldl(fun ?MODULE:add_uid_as_binary_to_list/2, [], UidList),
+    lists:foldl(fun ?MODULE:stitch_bin_list/2, <<>>, ListOfBins);
+uid_list_to_binary(_UidList) -> <<>>.
+
+parse(UidSet) when is_list(UidSet) -> parse(list_to_binary(UidSet));
+parse(<<>>)  -> badarg;
+parse(UidSet) when is_binary(UidSet) ->
+    Components = binary:split(UidSet, <<",">>, [global]),
+    try lists:foldl(fun(Component, Acc) -> add_component(binary:split(Component, <<":">>), Acc) end, [], Components) of
+        Parsed -> #uidset{ tokens = lists:reverse(Parsed) }
+    catch
+        _:_ -> badarg
+    end.
+
+next_uid(#uidset{ tokens = Tokens, current = Current }) -> next_uid(Tokens, Current).
+next_uid([], _Current) -> { none, #uidset {} };
+next_uid([{ First, Second }|_] = FullList, Current) -> next_in_range(FullList, First, Second, Current);
+next_uid([Uid|UidSet], _Current) -> { Uid, #uidset{ tokens = UidSet } }.
+
+% PRIVATE API
+add_uid_as_binary_to_list(Uid, Acc) when is_integer(Uid), Uid >= 0 -> [integer_to_binary(Uid)|Acc];
+add_uid_as_binary_to_list({ StartUid, EndUid }, Acc) when is_integer(StartUid), is_integer(EndUid) ->
+    case add_uid_range_as_binary_to_list(StartUid, EndUid) of
+        error -> Acc;
+        { Start, End } -> [<<Start/binary, ":", End/binary>>|Acc]
+    end;
+add_uid_as_binary_to_list(_, Acc) -> Acc.
+
+add_uid_range_as_binary_to_list(Start, End) when Start < 0; End < 0 -> error;
+add_uid_range_as_binary_to_list(Start, End) when Start < End -> { integer_to_binary(Start), integer_to_binary(End) };
+add_uid_range_as_binary_to_list(Start, End) -> { integer_to_binary(End), integer_to_binary(Start) }.
+
+stitch_bin_list(Uid, <<>>) -> Uid;
+stitch_bin_list(Uid, Acc) -> <<Uid/binary, ",", Acc/binary>>.
+
+add_component(Uid, Acc) when is_integer(Uid), Uid >= 0 -> [Uid|Acc];
+add_component([First, Second], Acc) -> add_component(binary_to_integer(First), binary_to_integer(Second), Acc);
+add_component([<<"">>], Acc) -> Acc;
+add_component([Single], Acc) when is_binary(Single) -> add_component(binary_to_integer(Single), Acc);
+add_component(_, _Acc) -> throw(badarg).
+
+add_component(First, Second, Acc) when is_integer(First), First >= 0, is_integer(Second), Second >= 0 -> add_range(First, Second, Acc);
+add_component(_, _, _Acc) -> throw(badarg).
+
+add_range(First, Second, Acc) when First == Second -> [First|Acc];
+add_range(First, Second, Acc) -> [{ First, Second }|Acc].
+
+next_in_range(Tokens, First, _Second, none) -> { First, #uidset{ tokens = Tokens, current = First } };
+next_in_range(Tokens, First, Second, Current) when First < Second, Current < Second -> Next = Current + 1, { Next, #uidset{ tokens = Tokens, current = Next } };
+next_in_range(Tokens, First, Second, Current) when First > Second, Current > Second -> Next = Current - 1, { Next, #uidset{ tokens = Tokens, current = Next } };
+next_in_range([_|Tokens], _First, _Second, _Current) -> next_uid(#uidset{ tokens = Tokens }).

debian.tar.gz/src/eimap_utils.erl Added

@@ -0,0 +1,246 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_utils).
+-export([
+         extract_path_from_uri/3, extract_uidset_from_uri/1,
+         split_command_into_components/1, is_tagged_response/2, remove_tag_from_response/3,
+         header_name/1, parse_flags/1,
+         check_response_for_failure/2,
+         ensure_binary/1,
+         new_imap_compressors/0,
+         only_full_lines/1,
+         binary_to_atom/1,
+         num_literal_continuation_bytes/1
+        ]).
+
+%% Translate the folder name in to a fully qualified folder path such as it
+%% would be used by a cyrus administrator.
+-spec extract_path_from_uri(SharedPrefix :: binary(), HierarchyDelim :: binary, URI :: binary()) -> Path :: binary() | bad_uri.
+extract_path_from_uri(SharedPrefix, HierarchyDelim, URI) when is_binary(URI) ->
+    extract_path_from_uri(SharedPrefix, HierarchyDelim, binary_to_list(URI));
+extract_path_from_uri(SharedPrefix, HierarchyDelim, URI) when is_list(URI) ->
+    %%lager:info("Parsing ~p", [URI]),
+    SchemeDefaults = [{ imap, 143 }, { imaps, 993 }],
+    ParseOpts = [ { scheme_defaults, SchemeDefaults } ],
+    case imap_folder_path(SharedPrefix, HierarchyDelim, http_uri:parse(URI, ParseOpts)) of
+        Path when is_list(Path) -> list_to_binary(Path);
+        Error -> Error
+    end.
+
+-spec extract_uidset_from_uri(URI :: binary()) -> UIDSet:: binary().
+extract_uidset_from_uri(URI) when is_binary(URI) ->
+    { TagStart, TagEnd } = binary:match(URI, <<";UID=">>),
+    UIDStart = TagStart + TagEnd + 1,
+    UriLength = byte_size(URI),
+    case binary:match(URI, <<";">>, [{ scope, { UIDStart, UriLength - UIDStart } }]) of
+        nomatch -> binary:part(URI, UIDStart - 1, UriLength - UIDStart + 1);
+        { Semicolon, _ } -> binary:part(URI, UIDStart - 1, Semicolon - UIDStart + 1)
+    end.
+
+-spec header_name(mailbox_uid | groupware_uid | groupware_uid) -> binary(); (any()) -> unknown.
+header_name(mailbox_uid) -> <<"/vendor/cmu/cyrus-imapd/uniqueid">>;
+header_name(groupware_type) -> <<"X-Kolab-Type">>;
+header_name(groupware_uid) -> <<"Subject">>;
+header_name(_) -> unknown.
+
+-spec parse_flags(FlagString :: binary() | list()) -> Flags :: [binary()].
+parse_flags(String) when is_list(String) -> parse_flags(list_to_binary(String));
+parse_flags(<<"(", Parened/binary>>) ->
+    case binary:match(Parened, <<")">>) of
+        nomatch -> [];
+        { ClosingParens, _ } -> parse_flags(binary_part(Parened, 0, ClosingParens))
+    end;
+parse_flags(<<>>) -> [];
+parse_flags(FlagString) when is_binary(FlagString) ->
+    binary:split(FlagString, <<" ">>, [global]).
+
+-spec check_response_for_failure(Data :: binary(), Tag :: undefined | binary()) -> ok | { error, Reason :: binary() }.
+check_response_for_failure(Data, undefined) when is_binary(Data) ->
+    check_response_for_failure(Data, <<>>);
+check_response_for_failure(Data, Tag) when is_binary(Data), is_binary(Tag) ->
+    NoToken = <<Tag/binary, " NO ">>,
+    NoTokenLength = byte_size(NoToken),
+    case NoTokenLength > byte_size(Data) of
+        true -> ok;
+        false -> is_no_token_found(Data, Tag, binary:match(Data, NoToken, [ { scope, { 0, NoTokenLength } } ]))
+    end.
+
+-spec split_command_into_components(Buffer :: binary()) -> { Tag :: binary(), Command :: binary(), Data :: binary() }.
+split_command_into_components(Buffer) when is_binary(Buffer) ->
+    split_command(Buffer).
+
+-spec is_tagged_response(Buffer :: binary(), Tag :: binary()) -> tagged | untagged.
+is_tagged_response(Buffer, Tag) ->
+    TagSize = size(Tag) + 1, % The extra char is a space
+    BufferSize = size(Buffer),
+    case
+        case (TagSize =< BufferSize) of
+            true -> <<Tag/binary, " ">> =:= binary:part(Buffer, 0, TagSize);
+            _ -> false
+        end of
+
+        true -> tagged;
+        _ -> untagged
+    end.
+
+-spec num_literal_continuation_bytes(Buffer :: binary()) -> { BufferSansContinuation :: binary(), NumberBytes :: integer() }.
+num_literal_continuation_bytes(Buffer) when size(Buffer) < 4 ->
+    { Buffer, 0 };
+num_literal_continuation_bytes(Buffer) ->
+    case binary:last(Buffer) =:= $} of
+        true -> number_of_bytes_in_continuation(Buffer);
+        false -> { Buffer, 0 }
+    end.
+
+number_of_bytes_in_continuation(Buffer) ->
+    BufferSize = size(Buffer),
+    OpenBracePos = find_continuation_open_brace(Buffer, BufferSize - 3),
+    confirm_continuation(Buffer, OpenBracePos).
+
+find_continuation_open_brace(_Buffer, 0) -> -1;
+find_continuation_open_brace(Buffer, Pos) ->
+    case binary:at(Buffer, Pos) of
+        ${ -> Pos;
+        _ -> find_continuation_open_brace(Buffer, Pos - 1)
+    end.
+
+confirm_continuation(Buffer, -1) ->
+    { Buffer, 0 };
+confirm_continuation(Buffer, OpenBracePos) ->
+    BufferSize = size(Buffer),
+    try binary_to_integer(binary:part(Buffer, OpenBracePos + 1, BufferSize - OpenBracePos - 2)) of
+        Result -> { binary:part(Buffer, 0, OpenBracePos), Result }
+    catch
+        _:_ -> { Buffer, 0 }
+    end.
+
+-spec remove_tag_from_response(Buffer :: binary(), Tag :: undefine | binary(), Check :: check | trust) -> Command :: binary().
+remove_tag_from_response(Buffer, undefined, _) ->
+    Buffer;
+remove_tag_from_response(Buffer, <<>>, _) ->
+    Buffer;
+remove_tag_from_response(Buffer, Tag, check) ->
+    TagSize = size(Tag) + 1, % The extra char is a space
+    BufferSize = size(Buffer),
+    case TagSize =< BufferSize of
+        true ->
+            case <<Tag/binary, " ">> =:= binary:part(Buffer, 0, TagSize) of
+                true -> binary:part(Buffer, TagSize, BufferSize - TagSize);
+                false -> Buffer
+            end;
+        false -> Buffer
+    end;
+remove_tag_from_response(Buffer, Tag, trust) ->
+    TagSize = size(Tag) + 1, % The extra char is a space
+    BufferSize = size(Buffer),
+    case TagSize =< BufferSize of
+        true -> binary:part(Buffer, TagSize, BufferSize - TagSize);
+        false -> Buffer
+    end.
+
+%% Private
+split_command(<<>>) -> { <<>>, <<>>, <<>> };
+split_command(Buffer) ->
+    End = eol_found(Buffer, binary:match(Buffer, <<"\r\n">>)),
+    { Tag, CommandStart } = searched_in_buffer(Buffer, 0, End, binary:match(Buffer, <<" ">>, [ { scope, { 0, End } } ])),
+    { Command, DataStart } = searched_in_buffer(Buffer, CommandStart, End, binary:match(Buffer, <<" ">>, [ { scope, { CommandStart, End - CommandStart  } } ])),
+    Data = binary:part(Buffer, DataStart, End - (DataStart)),
+    { Tag, Command, Data }.
+
+eol_found(Buffer, nomatch) -> size(Buffer);
+eol_found(_Buffer, { MatchStart, _MatchLength }) -> MatchStart.
+
+searched_in_buffer(Buffer, Start, End, nomatch) -> { binary:part(Buffer, Start, End - Start), End };
+searched_in_buffer(Buffer, Start, _End, { MatchStart, MatchLength } ) -> { binary:part(Buffer, Start, MatchStart - Start), MatchStart + MatchLength }.
+
+is_no_token_found(Data, Tag, nomatch) ->
+    BadToken = <<Tag/binary, " BAD ">>,
+    BadTokenLength = byte_size(BadToken),
+    Match = binary:match(Data, BadToken, [ { scope, { 0, BadTokenLength } } ]),
+    is_bad_token_found(Data, Tag, Match);
+is_no_token_found(Data, _Tag, { Start, Length }) ->
+    ReasonStart = Start + Length,
+    Reason = binary:part(Data, ReasonStart, byte_size(Data) - ReasonStart),
+    { no, chop_newlines(Reason) }.
+
+is_bad_token_found(_Data, _Tag, nomatch) ->
+    ok;
+is_bad_token_found(Data, _Tag, { Start, Length }) ->
+    ReasonStart = Start + Length,
+    %% -2 is due to the traling \r\n
+    Reason = binary:part(Data, ReasonStart, byte_size(Data) - ReasonStart),
+    { bad, chop_newlines(Reason) }.
+
+chop_newlines(Data) ->
+    Size = size(Data),
+    chop_newline(Data, binary:at(Data, Size - 1), Size - 1).
+
+chop_newline(Data, $\r, Size) -> chop_newline(Data, binary:at(Data, Size - 1), Size - 1);
+chop_newline(Data, $\n, Size) -> chop_newline(Data, binary:at(Data, Size - 1), Size - 1);
+chop_newline(Data, _, Size) -> binary_part(Data, 0, Size + 1).
+
+imap_folder_path_from_parts(none, _HierarchyDelim, [], _Domain, Path) ->
+    Path;
+imap_folder_path_from_parts(SharedPrefix, _HierarchyDelim, [], _Domain, Path) ->
+    case string:str(Path, SharedPrefix) of
+        1 -> string:substr(Path, length(SharedPrefix) + 1);
+        _ -> Path
+    end;
+imap_folder_path_from_parts(_SharedPrefix, HierarchyDelim, User, Domain, "INBOX") ->
+    string:join(["user", string:join([User, Domain], "@")], HierarchyDelim);
+imap_folder_path_from_parts(_SharedPrefix, HierarchyDelim, User , Domain, Path) ->
+    string:join(["user", User, string:join([Path, Domain], "@")], HierarchyDelim).
+
+imap_folder_path(_SharedPrefix, _HierarchyDelim, { error, Reason }) ->
+    lager:info("ERROR! ~p", [Reason]),
+    bad_uri;
+imap_folder_path(SharedPrefix, HierarchyDelim, { ok, {_Scheme, User, Domain, _Port, FullPath, _Query} }) ->
+    { VDomain, _ImapHost } = split_imap_uri_domain(string:tokens(Domain, "@")),
+    [ [_|Path] | _ ] = string:tokens(FullPath, ";"),
+    %%lager:info("PARSED IMAP URI: ~p ~p ~p", [User, VDomain, Path]),
+    CanonicalPath = imap_folder_path_from_parts(SharedPrefix, HierarchyDelim, User, VDomain, http_uri:decode(Path)),
+    %%lager:info("PUT TOGETHER AS: ~p", [CanonicalPath]),
+    CanonicalPath.
+
+split_imap_uri_domain([ ImapHost ]) -> { ImapHost, ImapHost };
+split_imap_uri_domain([ VDomain, ImapHost ]) -> { VDomain, ImapHost }.
+
+ensure_binary(Arg) when is_list(Arg) -> list_to_binary(Arg);
+ensure_binary(Arg) when is_binary(Arg) -> Arg;
+ensure_binary(Arg) when is_atom(Arg) -> atom_to_binary(Arg, latin1);
+ensure_binary(_Arg) -> <<>>.
+
+new_imap_compressors() ->
+    Inflator = zlib:open(),
+    ok = zlib:inflateInit(Inflator, -15),
+    Deflator = zlib:open(),
+    ok = zlib:deflateInit(Deflator, 1, deflated, -15, 8, default),
+    { Inflator, Deflator }.
+
+-spec only_full_lines(Buffer :: binary()) -> { BufferOfFullLines :: binary(), TrailingFragmentaryLine :: binary() }.
+only_full_lines(Buffer) ->
+    BufferLength = size(Buffer),
+    only_full_lines(Buffer, BufferLength, binary:at(Buffer, BufferLength - 1), BufferLength).
+
+only_full_lines(Buffer, BufferLength, $\n, Pos) when Pos =:= BufferLength -> { Buffer, <<>> };
+only_full_lines(Buffer, BufferLength, $\n, Pos) -> { binary:part(Buffer, 0, Pos + 1), binary:part(Buffer, Pos + 1, BufferLength - Pos - 1) };
+only_full_lines(Buffer, _BufferLength, _, 0) -> { <<>>, Buffer };
+only_full_lines(Buffer, BufferLength, _, Pos) -> only_full_lines(Buffer, BufferLength, binary:at(Buffer, Pos - 1), Pos - 1).
+
+-spec binary_to_atom(Value :: binary()) -> ValueAsAtom :: atom().
+binary_to_atom(Value) -> list_to_atom(string:to_lower(binary_to_list(Value))).

debian.tar.gz/test Added

debian.tar.gz/test/eimap_command_annotation_tests.erl Added

@@ -0,0 +1,71 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_annotation_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+% c("test/eimap_command_annotation_tests.erl"). eunit:test(eimap_command_annotation).
+
+parse_test_() ->
+    Data =
+    [
+        %% { tag, server_response, expected_parsed_results }
+        {
+            <<"EG0002">>,
+            <<"* ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/color\" (\"value.shared\" \"32CD32\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/folder-type\" (\"value.shared\" \"event\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/x-toltec/test\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/horde/share-params\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/h-share-attr-desc\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/uniqueid\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/pxfb-readable-for\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/incidences-for\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/folder-test\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/displayname\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/activesync\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/uniqueid\" (\"value.shared\" \"b1a5bb95-2bd3-4628-a0d2-49e9bd10735e\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/squat\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/size\" (\"value.shared\" \"5726\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/sieve\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/sharedseen\" (\"value.shared\" \"false\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/pop3showafter\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/pop3newuidl\" (\"value.shared\" \"true\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/partition\" (\"value.shared\" \"default\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/news2mail\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/lastupdate\" (\"value.shared\" \"20-Mar-2015 05:17:51 +0100\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/lastpop\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/expire\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/duplicatedeliver\" (\"value.shared\" \"false\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/thread\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/specialuse\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/sort\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/comment\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/checkperiod\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/check\" (\"value.shared\" NIL)\r\nEG0002 OK Completed\r\n">>,
+            { fini, [
+                {<<"/vendor/cmu/cyrus-imapd/duplicatedeliver">>, false},
+                {<<"/vendor/cmu/cyrus-imapd/lastupdate">>, <<"20-Mar-2015 05:17:51 +0100">>},
+                {<<"/vendor/cmu/cyrus-imapd/partition">>,<<"default">>},
+                {<<"/vendor/cmu/cyrus-imapd/pop3newuidl">>,true},
+                {<<"/vendor/cmu/cyrus-imapd/sharedseen">>,false},
+                {<<"/vendor/cmu/cyrus-imapd/size">>,5726},
+                {<<"/vendor/cmu/cyrus-imapd/uniqueid">>, <<"b1a5bb95-2bd3-4628-a0d2-49e9bd10735e">>},
+                {<<"/vendor/kolab/folder-type">>,<<"event">>},
+                {<<"/vendor/kolab/color">>,<<"32CD32">>}
+               ]
+            }
+        },
+        {
+            <<"EG0002">>,
+            <<"* ANNOTATION user/john.doe/Sent@example.org \"/vendor/x-toltec/test\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/horde/share-params\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/h-share-attr-desc\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/uniqueid\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/pxfb-readable-for\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/incidences-for\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/folder-type\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/folder-test\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/displayname\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/color\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/activesync\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/uniqueid\" (\"value.shared\" \"237357ec-7610-422e-9e55-0bae83caf58a\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/squat\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/size\" (\"value.shared\" \"401\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/sieve\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/sharedseen\" (\"value.shared\" \"false\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/pop3showafter\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/pop3newuidl\" (\"value.shared\" \"true\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/partition\" (\"value.shared\" \"default\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/news2mail\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/lastupdate\" (\"value.shared\" \"23-Mar-2015 15:19:29 +0100\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/lastpop\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/expire\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/duplicatedeliver\" (\"value.shared\" \"false\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/thread\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/specialuse\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/sort\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/comment\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/checkperiod\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/check\" (\"value.shared\" NIL)\r\nEG0002 OK Completed\r\n">>,
+            { fini, [
+                {<<"/vendor/cmu/cyrus-imapd/duplicatedeliver">>,false},
+                {<<"/vendor/cmu/cyrus-imapd/lastupdate">>,<<"23-Mar-2015 15:19:29 +0100">>},
+                {<<"/vendor/cmu/cyrus-imapd/partition">>,<<"default">>},
+                {<<"/vendor/cmu/cyrus-imapd/pop3newuidl">>,true},
+                {<<"/vendor/cmu/cyrus-imapd/sharedseen">>,false},
+                {<<"/vendor/cmu/cyrus-imapd/size">>,401},
+                {<<"/vendor/cmu/cyrus-imapd/uniqueid">>,<<"237357ec-7610-422e-9e55-0bae83caf58a">>}
+                    ]
+            }
+        }
+    ],
+    { _Command, ResponseType } = eimap_command_annotation:new_command(<<"/my/folder">>),
+    lists:foldl(fun({ Tag, ServerData, Expected }, Acc) -> [?_assertEqual(Expected, eimap_command:parse_response(ResponseType, ServerData, Tag, eimap_command_annotation))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        %% mailbox, command
+        {
+          <<"user/john.doe/Calendar/Personal Calendar@example.org">>,
+          { <<"GETANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"*\" \"value.shared\"">>, multiline_response }
+        }
+    ],
+    lists:foldl(fun({ Mailbox, Command }, Acc) -> [?_assertEqual(Command, eimap_command_annotation:new_command(Mailbox))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_capability_tests.erl Added

@@ -0,0 +1,70 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_capability_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          parse_serverid,
+          <<"* OK [CAPABILITY IMAP4rev1 LITERAL+ ID ENABLE STARTTLS LOGINDISABLED] acme.com Cyrus IMAP 2.5.5.5-Kolab-2.5.5-5.1.el6.kolab_14 server ready\r\n">>,
+          <<>>,
+          { fini, { <<"IMAP4rev1 LITERAL+ ID ENABLE STARTTLS LOGINDISABLED">>, <<"acme.com Cyrus IMAP 2.5.5.5-Kolab-2.5.5-5.1.el6.kolab_14 server ready">> } }
+        },
+        {
+          ok,
+          <<"* CAPABILITY IMAP4rev1 LITERAL+ ID ENABLE STARTTLS AUTH=PLAIN AUTH=LOGIN SASL-IR\r\nabcd OK CAPABILITY COMPLETED\r\n">>,
+          <<"abcd">>,
+          { fini, [<<"IMAP4rev1 LITERAL+ ID ENABLE STARTTLS AUTH=PLAIN AUTH=LOGIN SASL-IR">>] }
+        },
+        {
+          ok,
+          <<"other stuff\r\n">>,
+          <<"abcd">>,
+          { more, { <<>>, [], eimap_command_capability } }
+        },
+        {
+          ok,
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          ok,
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    lists:foldl(fun({ InitArgs, Response, Tag, Parsed }, Acc) ->
+                        { _Command, ResponseType } = eimap_command_capability:new_command(InitArgs),
+                        [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, Response, Tag, eimap_command_capability))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { parse_serverid, { <<"CAPABILITY">>, single_line_response } },
+        { <<>>, { <<"CAPABILITY">>, multiline_response } },
+        { true, { <<"CAPABILITY">>, multiline_response } },
+        { [], { <<"CAPABILITY">>, multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_capability:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_compress_tests.erl Added

@@ -0,0 +1,55 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_compress_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"abcd OK DEFLATE active\r\n">>,
+          <<"abcd">>,
+          compression_active
+        },
+        {
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    InitArgs = ok,
+    { _Command, ResponseType } = eimap_command_compress:new_command(InitArgs),
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, Response, Tag, eimap_command_compress))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { ok, { <<"COMPRESS DEFLATE">>, single_line_response } },
+        { <<>>, { <<"COMPRESS DEFLATE">>, single_line_response } },
+        { true, { <<"COMPRESS DEFLATE">>, single_line_response } },
+        { [], { <<"COMPRESS DEFLATE">>, single_line_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_compress:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_getmetadata_tests.erl Added

@@ -0,0 +1,78 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_getmetadata_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"* METADATA Tasks (/shared/vendor/kolab/folder-type \"task\")\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { <<"Tasks">>, [ { <<"/shared/vendor/kolab/folder-type">>, <<"task">> } ] } ] }
+        },
+        {
+          <<"* METADATA \"Tasks Tasks\" (/shared/vendor/kolab/folder-type \"task\")\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { <<"Tasks Tasks">>, [ { <<"/shared/vendor/kolab/folder-type">>, <<"task">> } ] } ] }
+        },
+        {
+          <<"* METADATA Tasks (/shared/vendor/kolab/folder-type \"task \\\"sigh\\\"\")\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { <<"Tasks">>, [ { <<"/shared/vendor/kolab/folder-type">>, <<"task \"sigh\"">> } ] } ] }
+        },
+        {
+          <<"* METADATA Tasks (/shared/vendor/kolab/folder-type \"task \\\"sigh\\\"\")\r\n* METADATA Archive (/shared/vendor/kolab/folder-type NIL)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [
+                    { <<"Archive">>, [ {<<"/shared/vendor/kolab/folder-type">>, null } ] },
+                    { <<"Tasks">>, [ { <<"/shared/vendor/kolab/folder-type">>, <<"task \"sigh\"">> } ] }
+                  ]
+          }
+        },
+        {
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) ->
+                        [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_getmetadata))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { { <<>> }, { <<"GETMETADATA (DEPTH infinity) \"\"">>, multiline_response } },
+        { { <<>>, [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"\" (/shared/comment /private/comment)">>, multiline_response } },
+        { { <<"/my/folder">>, [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\" (/shared/comment /private/comment)">>, multiline_response } },
+        { { "/my/folder", [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\" (/shared/comment /private/comment)">>, multiline_response } },
+        { { <<"/my/folder">> }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\"">>, multiline_response } },
+        { { "/my/folder", [], 10, 100 }, { <<"GETMETADATA (DEPTH 10 MAXSIZE 100) \"/my/folder\"">>, multiline_response } },
+        { { <<"/my/folder">>, [], 10, 100 }, { <<"GETMETADATA (DEPTH 10 MAXSIZE 100) \"/my/folder\"">>, multiline_response } },
+        { { <<"/my/folder">>, [], 10, none}, { <<"GETMETADATA (DEPTH 10) \"/my/folder\"">>, multiline_response } },
+        { { <<"/my/folder">>, [], none, 100 }, { <<"GETMETADATA (MAXSIZE 100) \"/my/folder\"">>, multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_getmetadata:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_login_tests.erl Added

@@ -0,0 +1,51 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_login_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"abcd OK LOGIN completed\r\n">>,
+          <<"abcd">>,
+          { fini, authed }
+        },
+        {
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_login))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { { <<"aseigo">>, <<"oohyeah">> }, { <<"LOGIN aseigo oohyeah">>, multiline_response } },
+        { { "aseigo", "oohyeah" }, { <<"LOGIN aseigo oohyeah">>, multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_login:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_logout_tests.erl Added

@@ -0,0 +1,52 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_logout_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"abcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { close_socket, ok }
+        },
+        {
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { close_socket, { error, <<"Uh uh uh">> } }
+        },
+        {
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { close_socket, { error, <<"Uh uh uh">> } }
+        }
+    ],
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_logout))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { <<>>, { <<"LOGOUT">>, multiline_response } },
+        { true, { <<"LOGOUT">>, multiline_response } },
+        { [], { <<"LOGOUT">>, multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_logout:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_namespace_tests.erl Added

@@ -0,0 +1,72 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_namespace_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"* NAMESPACE ((\"\" \"/\")) NIL NIL\r\nabcd OK NAMESPACE command completed\r\n">>,
+          <<"abcd">>,
+          { fini, { none, none } }
+        },
+%        {
+%          <<"* NAMESPACE NIL NIL ((\"\" \".\"))\r\nabcd OK NAMESPACE command completed\r\n">>,
+%          <<"abcd">>,
+%          namespace
+%        },
+%        {
+%          <<"* NAMESPACE ((\"\" \"/\")) NIL ((\"Public Folders/\" \"/\"))\r\nabcd OK NAMESPACE command completed\r\n">>,
+%          <<"abcd">>,
+%          namespace
+%        },
+%        {
+%          <<"* NAMESPACE ((\"\" \"/\")) ((\"~\" \"/\")) ((\"#shared/\" \"/\")\r\n(\"#public/\" \"/\")(\"#ftp/\" \"/\")(\"#news.\" \".\"))\r\nabcd OK NAMESPACE command completed\r\n">>,
+%          <<"abcd">>,
+%          namespace
+%        },
+%        {
+%          <<"* NAMESPACE ((\"INBOX.\" \".\")) NIL  NIL\r\nabcd OK NAMESPACE command completed\r\n">>,
+%          <<"abcd">>,
+%          namespace
+%        },
+        {
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_namespace))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { <<>>, { <<"NAMESPACE">>, multiline_response } },
+        { true, { <<"NAMESPACE">>, multiline_response } },
+        { [], { <<"NAMESPACE">>, multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_namespace:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_noop_tests.erl Added

@@ -0,0 +1,69 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_noop_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          ok,
+          <<"* 100 EXISTS\r\n* 22 EXPUNGE\r\n* 14 FETCH (FLAGS (\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen))\r\n* 3 Recent\r\nabcd OK Completed\r\n">>,
+          <<"abcd">>,
+          { fini,
+            [
+             { recent, 3 },
+             { fetch, 14 },
+             { expunge, 22 },
+             { exists, 100 }
+            ]
+          }
+        },
+        {
+          ok,
+          <<"abcd OK Completed\r\n">>,
+          <<"abcd">>,
+          { fini, [] }
+        },
+        {
+          ok,
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          ok,
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    lists:foldl(fun({ InitArgs, ServerResponse, Tag, Parsed }, Acc) ->
+                        { _Command, ResponseType } = eimap_command_noop:new_command(InitArgs),
+                        [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, ServerResponse, Tag, eimap_command_noop))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { ok, { <<"NOOP">>, multiline_response } },
+        { <<>>, { <<"NOOP">>, multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_noop:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_starttls_tests.erl Added

@@ -0,0 +1,52 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_starttls_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"abcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          starttls
+        },
+        {
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(single_line_response, Response, Tag, eimap_command_starttls))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { <<>>, { <<"STARTTLS">>, single_line_response } },
+        { true, { <<"STARTTLS">>, single_line_response } },
+        { [], { <<"STARTTLS">>, single_line_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_starttls:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_status_tests.erl Added

@@ -0,0 +1,65 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_status_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"* STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [{ uidnext, 44292 }, { messages, 231 }] }
+        },
+        {
+          <<"* STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292 RECENT 0 UIDVALIDITY 10110 UNSEEN 10)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [{ unseen, 10 }, { uidvalidity, 10110 }, { recent, 0 }, { uidnext, 44292 }, { messages, 231 }] }
+        },
+        {
+          <<"* STATUS blurdybloop (RECENT 1 UIDVALIDITY 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [{ uidvalidity, 44292 }, { recent, 1 }] }
+        }
+    ],
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_status))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { { "INBOX", [] },
+          { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+        { { <<"INBOX">>, [] },
+          { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+        { { <<>>, [messages] },
+          { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+        { { <<"">>, [messages] },
+          { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+        { { <<"/my/folder">>, [messages, recent, uidnext, uidvalidity, unseen] },
+          { <<"STATUS /my/folder (MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)">>, multiline_response } },
+        { { <<"/my/folder">>, [uidnext, recent, uidvalidity, unseen] },
+          { <<"STATUS /my/folder (UIDNEXT RECENT UIDVALIDITY UNSEEN)">>, multiline_response } },
+        { { <<"/my/folder">>, [garbage, unseen] },
+          { <<"STATUS /my/folder (UNSEEN)">>, multiline_response } },
+        { { <<"/my/folder">>, [garbage] },
+          { <<"STATUS /my/folder (MESSAGES)">>, multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_status:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_switch_folder_tests.erl Added

@@ -0,0 +1,72 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_switch_folder_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"Trash">>,
+          <<"* 0 EXISTS\r\n* 0 RECENT\r\n* FLAGS (\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)\r\n* OK [PERMANENTFLAGS ()] Ok\r\n* OK [UIDVALIDITY 1447439786] Ok\r\n* OK [UIDNEXT 1] Ok\r\n* OK [HIGHESTMODSEQ 1] Ok\r\n* OK [URLMECH INTERNAL] Ok>\r\n* OK [ANNOTATIONS 65536] Ok\r\nabcd OK [READ-WRITE] SELECT completed\r\n">>,
+          <<"abcd">>,
+          { fini,
+            [
+             { writeable, true },
+             { annotations, 65536 },
+             { url_mech, internal },
+             { highest_mod_seq, 1 },
+             { uid_next, 1 },
+             { uid_validity, 1447439786 },
+             { permanent_flags, [] },
+             { flags, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">>] },
+             { recent, 0 },
+             { exists, 0 }
+            ]
+          }
+        },
+        {
+          <<"Nope">>,
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          <<"ALsoWrong">>,
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    lists:foldl(fun({ InitArgs, ServerResponse, Tag, Parsed }, Acc) ->
+                        { _Command, ResponseType } = eimap_command_switch_folder:new_command(InitArgs),
+                        [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, ServerResponse, Tag, eimap_command_switch_folder))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { "Trash", { <<"SELECT \"Trash\"">>, all_multiline_response } },
+        { <<"Trash">>, { <<"SELECT \"Trash\"">>, all_multiline_response } },
+        { { <<"Trash">>, select }, { <<"SELECT \"Trash\"">>, all_multiline_response } },
+        { { <<"Trash">>, examine }, { <<"EXAMINE \"Trash\"">>, all_multiline_response } },
+        { { "Trash", examine }, { <<"EXAMINE \"Trash\"">>, all_multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_switch_folder:new_command(Params))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_command_tests.erl Added

@@ -0,0 +1,65 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_tests).
+-include_lib("eunit/include/eunit.hrl").
+-export([process_line/2, formulate_response/2]).
+
+% c("test/eimap_command_tests.erl"). eunit:test(eimap_command).
+
+process_line(Data, Acc) -> [{ marked, Data } | Acc].
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, lists:reverse(Data)).
+
+
+literal_continuations_test_() ->
+    Data =
+    [
+        % input, output
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"* STATUS 1 (MESSAGES 231 {14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { marked, <<"* STATUS 1 (MESSAGES 231 UIDNEXT 44292)">> } ] }
+        },
+        {
+          <<"* STATUS 1a (MESSAGES 231 {14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation">>,
+          <<"abcd">>,
+          { more, { <<"abcd OK Begin TLS negotiation">>, [ { marked, <<"* STATUS 1a (MESSAGES 231 UIDNEXT 44292)">> } ], ?MODULE } }
+        },
+        {
+          <<"* STATUS 2 (MESSAGES 231 {14}\r\n">>,
+          <<"abcd">>,
+          { more, { <<"* STATUS 2 (MESSAGES 231 {14}">>, [], ?MODULE } }
+        },
+        {
+          <<"* STATUS 3 (MESSAGES 231 {h14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { marked, <<"* STATUS 3 (MESSAGES 231 {h14}">> }, { marked, <<"UIDNEXT 44292)">> } ] }
+        },
+        {
+          <<"* STATUS 4 (MESSAGES 231 \r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { marked, <<"* STATUS 4 (MESSAGES 231 ">> }, { marked, <<"UIDNEXT 44292)">> } ] }
+        },
+        {
+          <<"* STATUS 5 (MESSAGES 231 UIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { marked, <<"* STATUS 5 (MESSAGES 231 UIDNEXT 44292)">> } ] }
+        }
+    ],
+    lists:foldl(fun({ Binary, Tag, Result }, Acc) -> [?_assertEqual(Result, eimap_command:parse_response(multiline_response, Binary, Tag, ?MODULE))|Acc] end, [], Data).
+

debian.tar.gz/test/eimap_uidset_tests.erl Added

@@ -0,0 +1,103 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_uidset_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+% c("test/eimap_uidset_tests.erl"). eunit:test(eimap_uidset).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { [4], <<"4">> },
+        { [1, 2, 3, 4], <<"1,2,3,4">> },
+        { [-1, 1, 2, 3, 4], <<"1,2,3,4">> },
+        { [1, {100, 10}, 2, 3, 4], <<"1,10:100,2,3,4">> },
+        { [1, {10, 100}, 2, 3, 4], <<"1,10:100,2,3,4">> },
+        { [1, {-10, 100}, 2, 3, 4], <<"1,2,3,4">> },
+        { [1, {-100, 10}, 2, 3, 4], <<"1,2,3,4">> },
+        { [1, {-10, 100}, 2, 3, 4], <<"1,2,3,4">> },
+        { [1, {"alpha", 100}, <<"random_binary">>, some_atom, 2, 3, 4], <<"1,2,3,4">> },
+        { <<"1,2,3,4">>, <<>> },
+        { other, <<>> },
+        { [], <<>> }
+    ],
+    lists:foldl(fun({ List, Binary }, Acc) -> [?_assertEqual(Binary, eimap_uidset:uid_list_to_binary(List))|Acc] end, [], Data).
+
+single_value_test_() ->
+    [
+        ?_assertEqual([1], iterate_uidset(eimap_uidset:parse(<<"1,">>))),
+        ?_assertEqual([1], iterate_uidset(eimap_uidset:parse(<<"1">>))),
+        ?_assertEqual([20], iterate_uidset(eimap_uidset:parse(<<"20">>))),
+        ?_assertEqual([147], iterate_uidset(eimap_uidset:parse(<<"147">>)))
+    ].
+
+multiple_single_value_test_() ->
+    [
+        ?_assertEqual([1, 2], iterate_uidset(eimap_uidset:parse(<<"1,2">>)))
+    ].
+
+range_test_() ->
+    [
+        ?_assertEqual([1, 2, 3], iterate_uidset(eimap_uidset:parse(<<"1:3">>))),
+        ?_assertEqual([3, 2, 1], iterate_uidset(eimap_uidset:parse(<<"3:1">>))),
+        ?_assertEqual([1], iterate_uidset(eimap_uidset:parse(<<"1:1">>)))
+    ].
+
+multiple_range_test_() ->
+    [ ?_assertEqual([1, 2, 3, 10, 11, 12, 13, 14, 15], iterate_uidset(eimap_uidset:parse(<<"1:3,10:15">>))) ].
+
+mix_single_and_range_test_() ->
+    [
+        ?_assertEqual([1, 3, 4, 5], iterate_uidset(eimap_uidset:parse(<<"1,3:5">>))),
+        ?_assertEqual([1, 3, 4, 5, 10], iterate_uidset(eimap_uidset:parse(<<"1,3:5,10">>))),
+        ?_assertEqual([1, 3, 4, 5, 10, 20, 21, 22, 23, 30], iterate_uidset(eimap_uidset:parse(<<"1,3:5,10,20:23,30">>)))
+    ].
+
+mix_single_and_range_with_whitespace_test_() ->
+    [
+        ?_assertEqual(badarg, eimap_uidset:parse(<<"1, 3:5">>)),
+        ?_assertEqual(badarg, eimap_uidset:parse(<<"1,3:5 ,10">>)),
+        ?_assertEqual(badarg, eimap_uidset:parse(<<"1,3 :5,10,20:  23,30">>))
+    ].
+
+bad_uidsets_test_() ->
+    [
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<>>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"-1,3:5">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"alpha">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1,a,3:5">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1,3:5,a">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1;2">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1, 2">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"1:3:5">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"-11,3:5">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"11,-3:5">>))),
+        ?_assertEqual(badarg, iterate_uidset(eimap_uidset:parse(<<"11,3:-5">>)))
+    ].
+
+
+iterate_uidset(badarg) ->
+    badarg;
+iterate_uidset(UidSet) ->
+    %%io:fwrite("we are going to iterate over ~p~n", [UidSet]),
+    lists:reverse(iterate_uidset(eimap_uidset:next_uid(UidSet), [])).
+iterate_uidset({ none, _UidSet }, Acc) -> Acc;
+iterate_uidset({ Uid, UidSet }, Acc) -> iterate_uidset(eimap_uidset:next_uid(UidSet), [Uid|Acc]).
+

debian.tar.gz/test/eimap_utils_tests.erl Added

@@ -0,0 +1,198 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_utils_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+% c("test/eimap_utils_tests.erl"). eunit:test(eimap_utils).
+
+extract_path_from_uri_test_() ->
+    Data =
+    [
+        {
+          <<"user/john.doe/Calendar@example.org">>,
+          none, "/",
+          <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=1">>
+        },
+        {
+          <<"user/john.doe/Personal Calendar@example.org">>,
+          none, "/",
+          <<"imap://john.doe@example.org@kolab.example.org/Personal%20Calendar;UIDVALIDITY=1424683684/;UID=1">>
+        },
+        {
+          <<"Personal Calendar">>,
+          none, "/",
+          <<"imap://kolab.example.org/Personal%20Calendar;UIDVALIDITY=1424683684/;UID=1">>
+        },
+        {
+          <<"Personal Calendar">>,
+          "Shared/", "/",
+          <<"imap://kolab.example.org/Shared/Personal%20Calendar;UIDVALIDITY=1424683684/;UID=1">>
+        },
+        {
+          <<"Personal Calendar">>,
+          "Shared/", "/",
+          <<"imap://kolab.example.org/Personal%20Calendar;UIDVALIDITY=1424683684/;UID=1">>
+        },
+        {
+          <<"user/john.doe@example.org">>,
+          "Shared/", "/",
+          <<"imap://john.doe@example.org@kolab.example.org/INBOX;UIDVALIDITY=1424683684/;UID=1">>
+        },
+        {
+          bad_uri,
+          none, "/",
+          <<"merf">>
+        }
+    ],
+    lists:foldl(fun({ Val, SharePrefix, Sep, Input }, Acc) -> [?_assertEqual(Val, eimap_utils:extract_path_from_uri(SharePrefix, Sep, Input))|Acc] end,
+                [], Data).
+
+extract_uid_from_uri_test_() ->
+    Data =
+    [
+        { <<"1">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=1">> },
+        { <<"12">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=12">> },
+        { <<"123">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=123">> },
+        { <<"1">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=1;foo">> },
+        { <<"12">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=12;foo=bar">> },
+        { <<"123">>, <<"imap://john.doe@example.org@kolab.example.org/Calendar;UIDVALIDITY=1424683684/;UID=123;foo=bar">> }
+    ],
+    lists:foldl(fun({ Val, Input }, Acc) -> [?_assertEqual(Val, eimap_utils:extract_uidset_from_uri(Input))|Acc] end,
+                [], Data).
+
+split_command_into_components_test_() ->
+    Data =
+    [
+        { { <<>>, <<>>, <<>> }, <<>> },
+        { { <<".">>, <<"LIST">>, <<"\"\" \"*\"">> }, <<". LIST \"\" \"*\"">> },
+        { { <<"1">>, <<"STARTTLS">>, <<>> }, <<"1 STARTTLS">> },
+        { { <<"1">>, <<"STARTTLS">>, <<>> }, <<"1 STARTTLS\r\n">> },
+        { { <<"3">>, <<"ID">>, <<"(\"name\" \"Thunderbird\" \"version\" \"38.3.0\")">> }, <<"3 ID (\"name\" \"Thunderbird\" \"version\" \"38.3.0\")">> }
+    ],
+    lists:foldl(fun({ Val, Input }, Acc) -> [?_assertEqual(Val, eimap_utils:split_command_into_components(Input)) | Acc] end,
+                 [], Data).
+
+check_response_for_failure_test_() ->
+    Tag = <<"abcdef">>,
+    Data =
+    [
+       { Tag, <<Tag/binary, " NO reasons\r\n">>, { no, <<"reasons">> } },
+       { Tag, <<Tag/binary, " NO reasons">>, { no, <<"reasons">> } },
+       { Tag, <<Tag/binary, " BAD reasons\r\n">>, { bad, <<"reasons">> } },
+       { Tag, <<Tag/binary, " BAD reasons">>, { bad, <<"reasons">> } },
+       { Tag, <<Tag/binary, " OK reasons">>, ok },
+       { Tag, <<"short">>, ok },
+       { undefined, <<"* OK reasons">>, ok }
+    ],
+    lists:foldl(fun({ Tag2, Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:check_response_for_failure(Input, Tag2)) | Acc] end, [], Data).
+
+is_tagged_response_test_() ->
+    Tag = <<"abcd">>,
+    Data =
+    [
+       { <<Tag/binary, " Indeed\r\n">>, tagged },
+       { <<Tag/binary, " Indeed">>, tagged },
+       { <<"one">>, untagged },
+       { <<"* Yeah baby">>, untagged }
+    ],
+    lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:is_tagged_response(Input, Tag)) | Acc] end, [], Data).
+
+remove_tag_from_response_test_() ->
+    Tag = <<"abcd">>,
+    Data =
+    [
+       { Tag, <<Tag/binary, " Indeed\r\n">>, check, <<"Indeed\r\n">> },
+       { Tag, <<Tag/binary, " Indeed\r\n">>, trust, <<"Indeed\r\n">> },
+       { Tag, <<Tag/binary, " Indeed">>, check, <<"Indeed">>},
+       { Tag, <<Tag/binary, " Indeed">>, trust, <<"Indeed">>},
+       { undefined, <<"abcd4 Indeed">>, check, <<"abcd4 Indeed">>},
+       { undefined, <<"abcd4 Indeed">>, trust, <<"abcd4 Indeed">>},
+       { <<>>, <<"abcd4 Indeed">>, check, <<"abcd4 Indeed">>},
+       { <<>>, <<"abcd4 Indeed">>, trust, <<"abcd4 Indeed">>},
+       { Tag, <<"abcd4 Indeed">>, check, <<"abcd4 Indeed">>},
+       { Tag, <<"abcd4 Indeed">>, trust, <<" Indeed">>},
+       { Tag, <<"* Yeah baby">>, check, <<"* Yeah baby">> },
+       { Tag, <<"">>, check, <<"">> },
+       { Tag, <<"">>, trust, <<"">> },
+       { Tag, <<>>, check, <<>> },
+       { Tag, <<>>, trust, <<>> }
+    ],
+    lists:foldl(fun({ Tag2, Input, Check, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:remove_tag_from_response(Input, Tag2, Check)) | Acc] end, [], Data).
+
+header_name_test_() ->
+    Data =
+    [
+        { mailbox_uid ,  <<"/vendor/cmu/cyrus-imapd/uniqueid">> },
+        { groupware_type ,  <<"X-Kolab-Type">> },
+        { groupware_uid ,  <<"Subject">> },
+        { dunno,  unknown },
+        { "dunno",  unknown },
+        { <<"dunno">>,  unknown },
+        { 134,  unknown }
+    ],
+    lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:header_name(Input)) | Acc] end, [], Data).
+
+ensure_binary_test_() ->
+    Data = 
+    [
+        { "yep", <<"yep">> },
+        { <<"yep">>, <<"yep">> },
+        { [1, 2, 3], <<1, 2, 3>> },
+        { yep, <<"yep">> },
+        { 123, <<>> }
+    ],
+    lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:ensure_binary(Input)) | Acc] end, [], Data).
+
+only_full_lines_test_() ->
+    Data = 
+    [
+        { <<"yep">>, { <<>>, <<"yep">> } },
+        { <<"yep\r\nhohoho">>, { <<"yep\r\n">>, <<"hohoho">> } },
+        { <<"nope\r\nyep\r\nhohoho">>, { <<"nope\r\nyep\r\n">>, <<"hohoho">> } },
+        { <<"nope\r\nyep\r\nhohoho\r\n">>, { <<"nope\r\nyep\r\nhohoho\r\n">>, <<>> } }
+    ],
+    lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:only_full_lines(Input)) | Acc] end, [], Data).
+
+parse_flags_test_() ->
+    Data =
+    [
+        { <<"()">>, [] },
+        { <<>>, [] },
+        { <<"\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen">>, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] },
+        { <<"(\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)">>, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] },
+        { "(\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)", [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] }
+    ],
+    lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:parse_flags(Input)) | Acc] end, [], Data).
+
+num_literal_continuation_bytes_test_() ->
+    Data =
+    [
+        { <<"abcd">>, { <<"abcd">>, 0 } },
+        { <<"abcd{5}">>, { <<"abcd">>, 5 } },
+        { <<"abcd{100}">>, { <<"abcd">>, 100 } },
+        { <<"123abcd{100}">>, { <<"123abcd">>, 100  } },
+        { <<"ab{123abcd{100}">>, { <<"ab{123abcd">>, 100  } },
+        { <<"ab{123abcd{1{00}">>, { <<"ab{123abcd{1">>, 0 } },
+        { <<"abcd{aa0}">>, { <<"abcd{aa0}">>, 0 } },
+        { <<"abcd{10aa0}">>, { <<"abcd{10aa0}">>, 0 } },
+        { <<"abcd100}">>, { <<"abcd100}">>, 0 } },
+        { <<"abcd100}">>, { <<"abcd100}">>, 0 } }
+    ],
+    lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:num_literal_continuation_bytes(Input)) | Acc] end, [], Data).
+
+

erlang-eimap-0.2.tar.gz/README.md -> erlang-eimap-0.2.2.tar.gz/README.md Changed

@@ -18,7 +18,7 @@
 To use eimap from your imap application add the following line to your rebar
 config:
 
-    { eimap, "*", {git, "git://git.kolab.org/diffusion/EI/eimap.git" }
+    { eimap, "*", {git, "git://git.kolab.org/diffusion/EI/eimap.git" } }
 
 There is no need to start the eimap application as it does not have any process
 or startup routines related to its usage. eimap does rely on lager being avilable,
@@ -28,7 +28,7 @@
 ============
 The eimap erlang module is the home of the primary API for the eimap library. It
 is a gen_fsm and should be started as a process in the normal Erlang/OTP manner for
-use. 
+use.
 
 An eimap instance represents a single IMAP connection to a single IMAP server
 and is stateful: commands that are started may change the selected folder, for
@@ -38,14 +38,14 @@
 Once started, an eimap process may be directed to connect to an imap server
 and then start with functions such as fetching path tokens:
 
-    ImapServerArgs = #eimap_server_config{ host = "acme.com" },
+    ImapServerArgs = [ { host, "imap.acme.com" }, { port, 143 }, { tls, starttls } ]
     { ok, Imap } = eimap:start_link(ImapServerArgs),
     eimap_imap:starttls(),
     eimap_imap:login(Imap, self(), undefined, "username", "password"),
     eimap_imap:connect(Imap),
     eimap_imap:get_path_tokens(Imap, self(), get_path_tokens)
 
-The eimap_server_config record is defined in eimap.hrl and allows one to set
+The Imap server args is a simple proplist which allows one to set
 host, port and TLS settings. For TLS, the following values are supported:
 
     * true: start a TLS session when opening the socket ("implicit TLS")
@@ -110,15 +110,53 @@
 The API for commands is defined in src/eimap_command.erl as a behavior. Commands
 are expected to provide at least two functions:
 
-    new(Args): create a command bitstring to be passed to the imap server
-               Args is specific to the command, and some commands ignore this
-               parameter
-    parse(Data, Tag): parses a response from the imap server; the Tag is the
-               IMAP command tag sent with the command and Data is the full
-               Data buffer being process (possibly including tagged lines).
-
-Data to be parsed may contain multiple lines, and in the case of commands with
-large responses may only contain part of the response.
+    new_command(Args) -> { Command, ResponseType }
+        create a command bitstring to be passed to the imap server and defines
+        the type of response for this command. Response types include
+        single_line_response, multiline_response, all_multiline_response
+        and blob_response.
+
+        Args is specific to the command, and some commands
+        ignore this parameter
+
+Single line response
+--------------------
+Commands which the IMAP server will respond to with a single line in return
+should use single_line_response and must implement formulate_response/2 which
+is passed the Data and the command Tag. This usually returns one of
+{ fini, Result } or { error, Reason }, though some special commands may return
+atoms which the eimap module responds to such as starttls.
+
+Multiline Response
+------------------
+This is the most common response type and is used when the IMAP server may
+respond with zero or more untagged responses and a final tagged response.
+
+Such commands must implement:
+
+    process_line/2 which is passed one line at a time (minus newlines)
+        and a list accumulator to add responses to
+
+    formulate_response/2 which is passed ok on success or an error tuple of 
+     { [no|bad], Reason }. This should return either { fini, Response } or
+     { error, Reason } in most cases; and for that there is
+     eimap_command:formulate_response. Which means that for most commands
+     formulate_response/2 is implemented as:
+
+        formulate_response(Result, Response) -> eimap_command:formulate(Result, Response).
+
+Commands which are all_multiline_responses also must implement process_tagged_line/2
+which behaves exactly like process_line but which accepts the tagged response line
+from the IMAP server. This is useful for commands where useful information is also
+passed in the tagged response line. An example of this is the select/exmine
+commands.
+
+Unstructured (blob) responses
+-----------------------------
+Responses that do not follow the usual untagged/tagged line response pattern
+may use the blog_response type and implement parse/2 which will be passed
+the data as it arrives. The command is responsible for all buffer stitching
+across network packets, etc.
 
 In the case of partial responses, parse/2 may return { more, fun/3, State }.
 The State object allows preserving the parsing state and will be passed back to
@@ -140,9 +178,7 @@
 =======
 Tests can be run with `make tests` or `rebar eunit`.
 
-All new commands must be accompanied by tests in the test/ directory. Currently
-testing is not remotely complete in coverage (a historical accident), and this
-needs to be rectified over time. New tests welcome.
+All new commands must be accompanied by tests in the test/ directory.
 
 Contributing
 ============
@@ -150,5 +186,15 @@
 Mailing list: devel@lists.kolab.com
 Project page: https://git.kolab.org/tag/eimap/
 
+This project uses the git flow workflow as described here:
+
+    http://nvie.com/posts/a-successful-git-branching-model/
+
+You can installed git flow from here:
+
+    https://github.com/nvie/gitflow
+
+Then initialize your local clone with `git flow init -d`.
+
 You can find the list of open tasks on the project page's workboard. Anything
 in the backlog is open to be worked on.

erlang-eimap-0.2.tar.gz/rebar.config -> erlang-eimap-0.2.2.tar.gz/rebar.config Changed

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_annotation.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_annotation.erl Changed

@@ -17,37 +17,23 @@
 
 -module(eimap_command_annotation).
 -behavior(eimap_command).
--export([new/1, parse/2]).
+-export([new_command/1, process_line/2, formulate_response/2]).
 
 %% Public API
-new(Folder) when is_binary(Folder) ->
-    <<"GETANNOTATION \"", Folder/binary, "\" \"*\" \"value.shared\"">>.
+new_command(Folder) when is_list(Folder) -> new_command(list_to_binary(Folder));
+new_command(Folder) -> { <<"GETANNOTATION \"", Folder/binary, "\" \"*\" \"value.shared\"">>, multiline_response }.
 
-parse(Data, Tag) when is_binary(Data) ->
-    case eimap_utils:check_response_for_failure(Data, Tag) of
-        ok ->
-            Lines = binary:split(Data, <<"\r\n">>, [global]),
-            Rv = lists:foldl(fun(Line, Acc) -> parseLine(Line, Acc, Tag) end, [], Lines),
-            { fini, Rv };
-        { _, Reason } ->
-            { error, Reason }
-    end.
-
-
-%% Private API
-parseLine(<<" ", Data/binary>>, Acc, Tag) ->
-    parseLine(Data, Acc, Tag);
-parseLine(<<"* ANNOTATION ", Data/binary>>, Acc, _Tag) ->
+process_line(<<" ", Data/binary>>, Acc) ->
+    process_line(Data, Acc);
+process_line(<<"* ANNOTATION ", Data/binary>>, Acc) ->
     Pieces = binary:split(Data, <<"\"">>, [global]),
     process_pieces(Pieces, Acc);
-parseLine(<<>>, Acc, _Tag) ->
-    Acc;
-parseLine(Data, Acc, Tag) ->
-    case binary:match(Data, Tag) of
-        { 0, End } -> handle_possible_end(binary:part(Data, End + 1, byte_size(Data) - End - 1), Acc);
-        _ -> lager:warning("Unexpected response from imap server: ~p", [Data]), Acc
-    end.
+process_line(<<>>, Acc) ->
+    Acc.
+
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
 
+%% Private API
 process_pieces([MBox, Key, _, _, _, Value, _], Acc) when MBox =/= <<>> -> [ { Key, translate(Value) } | Acc ];
 process_pieces([_, _MBox, _, Key, _, _, _, Value, _], Acc) -> [ { Key, translate(Value) } | Acc ];
 process_pieces(_, Acc) -> Acc.
@@ -61,16 +47,3 @@
         _:_ -> Value
     end.
 
-handle_possible_end(<<"OK", _/binary>>, Acc) ->
-    Acc;
-handle_possible_end(<<"NO ", Reason/binary>>, Acc) ->
-    lager:warning("Annotation error from imap server: ~p", [Reason]),
-    Acc;
-handle_possible_end(<<"BAD ", Reason/binary>>, Acc) ->
-    lager:warning("Annotation error from imap server: ~p", [Reason]),
-    Acc;
-handle_possible_end([_Tag, Message], Acc) ->
-    handle_possible_end(Message, Acc);
-handle_possible_end(Message, Acc) ->
-    lager:warning("Unexpected response from imap server: ~p", [Message]),
-    Acc.

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_capability.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_capability.erl Changed

@@ -17,31 +17,34 @@
 
 -module(eimap_command_capability).
 -behavior(eimap_command).
--export([new/1, parse/2]).
+-export([new_command/1, process_line/2, formulate_response/2]).
 
 %% http://tools.ietf.org/html/rfc2342
 
 %% Public API
-new(_Args) -> <<"CAPABILITY">>.
+new_command(parse_serverid) -> { <<"CAPABILITY">>, single_line_response };
+new_command(_Args) -> { <<"CAPABILITY">>, multiline_response }.
 
-parse(Data, Tag) -> formulate_reponse(eimap_utils:check_response_for_failure(Data, Tag),
-                                      eimap_utils:remove_tag_from_response(Data, Tag, check)).
+process_line(<<"* CAPABILITY ", Data/binary>>, Acc) ->
+    [Data|Acc];
+process_line(_Data, Acc) -> Acc.
 
+formulate_response(ok, Response) -> { fini, Response };
+formulate_response({ _, Reason }, _Data) -> { error, Reason };
+formulate_response(Data, Tag) -> parse_oneliner(eimap_utils:check_response_for_failure(Data, Tag),
+                                                eimap_utils:remove_tag_from_response(Data, Tag, check)).
 
 %% Private API
 % TODO: probably way too cyrus imap specific on the responses (capitalization, etc)
 % make generic with a nicer parser
-formulate_reponse(ok, <<"* OK [CAPABILITY ", Data/binary>>) ->
+parse_oneliner(ok, <<"* OK [CAPABILITY ", Data/binary>>) ->
     % this is a server response on connect
     { End, _ } = binary:match(Data, <<"]">>),
     { TextEnd, _ } = binary:match(Data, <<"\r\n">>),
     Capabilities = binary:part(Data, { 0, End }),
     ServerID = binary:part(Data, { End + 2, TextEnd - End  - 2}),
     { fini, { Capabilities, ServerID } };
-formulate_reponse(ok, <<"* CAPABILITY ", Data/binary>>) ->
-    { End, _ } = binary:match(Data, <<"\r\n">>),
-    Capabilities = binary:part(Data, { 0, End }),
-    { fini, Capabilities };
-formulate_reponse(ok, Data) -> Data;
-formulate_reponse({ _, Reason }, _Data) -> { error, Reason }.
+parse_oneliner({ _, Reason }, _Data) -> { error, Reason };
+parse_oneliner(_, Data) -> { fini, Data }.
+

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_compress.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_compress.erl Changed

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_getmetadata.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_getmetadata.erl Changed

@@ -17,44 +17,44 @@
 
 -module(eimap_command_getmetadata).
 -behavior(eimap_command).
--export([new/1, parse/2, continue_parse/3]).
+-export([new_command/1, process_line/2, formulate_response/2]).
 
 %% http://tools.ietf.org/html/rfc2342
 
 %% Public API
-new({ Folder }) -> new({ Folder, [] });
-new({ Folder, Attributes }) when is_list(Folder) -> new({ list_to_binary(Folder), Attributes });
-new({ Folder, Attributes }) ->
-    AttributesList = format_attributes(Attributes, <<>>),
-    Command = <<"GETMETADATA (DEPTH infinity) \"", Folder/binary, "\"", AttributesList/binary>>,
-    Command.
-
-parse(Data, Tag) -> continue_parse(Data, Tag, { <<>>, [] }).
-
-continue_parse(Data, Tag, { LastPartialLine, Acc }) ->
-    FullBuffer = <<LastPartialLine/binary, Data/binary>>,
-    { FullLinesBuffer, NewLastPartialLine } = eimap_utils:only_full_lines(FullBuffer),
-    Lines = binary:split(FullLinesBuffer, <<"\r\n">>, [global]),
-    process_line(Tag, NewLastPartialLine, Lines, Acc).
+new_command({ Folder }) -> new_command({ Folder, [] });
+new_command({ Folder, Attributes }) -> new_command({ Folder, Attributes, infinity, nomax });
+
+%% Depth and MaxSize are both optional arguments, so we have a 4-tuple version of new_command to accomodate this
+%% "Depth, Maxsize" could be replaced with a proplist of the form [ { depth, Depth }, { maxsize, MaxSize } ] but
+%% as this is an internal (to eimap) API there is little benefit for the performance cost
+new_command({ Folder, Attributes, Depth, MaxSize }) when is_list(Folder) -> new_command({ list_to_binary(Folder), Attributes, Depth, MaxSize });
+new_command({ Folder, Attributes, Depth, MaxSize }) ->
+    AttributesString = format_attributes(Attributes, <<>>),
+    DepthString = depth_param(Depth),
+    MaxSizeString = maxsize_param(MaxSize),
+    Command = metadata_command(DepthString, MaxSizeString, Folder, AttributesString),
+    { Command, multiline_response }.
+
+process_line(<<"* METADATA ", Details/binary>>, Acc) ->
+    Results = parse_folder(Details),
+    [Results|Acc];
+process_line(_Line, Acc) -> Acc.
 
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
 
 %% Private API
-process_line(_Tag, LastPartialLine, [], Acc) -> { more, fun ?MODULE:continue_parse/3, { LastPartialLine, Acc } };
-process_line(Tag, LastPartialLine, [Line|MoreLines], Acc) ->
-    case eimap_utils:is_tagged_response(Line, Tag) of
-        true ->
-            formulate_response(eimap_utils:check_response_for_failure(Line, Tag), Acc);
-        false ->
-            process_line(Tag, LastPartialLine, MoreLines, process_metadata_response(Line, Acc))
-    end.
+depth_param(infinity) -> <<"DEPTH infinity">>;
+depth_param(Depth) when is_integer(Depth) -> Bin = integer_to_binary(Depth), <<"DEPTH ", Bin/binary>>;
+depth_param(_) -> <<>>.
 
-formulate_response(ok, Data) -> { fini, Data };
-formulate_response({ _, Reason }, _Data) -> { error, Reason }.
+maxsize_param(Size) when is_integer(Size) -> Bin = integer_to_binary(Size), <<"MAXSIZE ", Bin/binary>>;
+maxsize_param(_) -> <<>>.
 
-process_metadata_response(<<"* METADATA ", Details/binary>>, Acc) ->
-    Results = parse_folder(Details),
-    [Results|Acc];
-process_metadata_response(_Line, Acc) -> Acc.
+metadata_command(<<>>, <<>>, Folder, Attributes) -> <<"GETMETADATA \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(Depth, <<>>, Folder, Attributes) -> <<"GETMETADATA (", Depth/binary, ") \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(<<>>, MaxSize, Folder, Attributes) -> <<"GETMETADATA (", MaxSize/binary, ") \"", Folder/binary, "\"", Attributes/binary>>;
+metadata_command(Depth, MaxSize, Folder, Attributes) -> <<"GETMETADATA (", Depth/binary, " ", MaxSize/binary, ") \"", Folder/binary, "\"", Attributes/binary>>.
 
 format_attributes([], <<>>) -> <<>>;
 format_attributes([], String) -> <<" (", String/binary, ")">>;

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_login.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_login.erl Changed

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_logout.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_logout.erl Changed

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_namespace.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_namespace.erl Changed

@@ -17,44 +17,27 @@
 
 -module(eimap_command_namespace).
 -behavior(eimap_command).
--export([new/1, parse/2, continue_parse/3]).
+-export([new_command/1, process_line/2, formulate_response/2]).
 
 %% http://tools.ietf.org/html/rfc2342
 
 %% Public API
-new(_Args) -> <<"NAMESPACE">>.
+new_command(_Args) -> { <<"NAMESPACE">>, multiline_response }.
 
-%TODO support multi-packet continuing parse
-parse(Data, Tag) -> continue_parse(Data, Tag, []).
+process_line(<<"* NAMESPACE ", Data/binary>>, Acc) -> [process_shared_prefix_parts(Data, 1)|Acc];
+process_line(_Line, Acc) -> Acc.
 
-continue_parse(Data, Tag, Acc) ->
-    Lines = binary:split(Data, <<"\r\n">>, [global]), %%TODO partial lines
-    process_line(Tag, Lines, Acc).
 
-
-%% Private API
-process_line(_Tag, [], Acc) -> { more, fun ?MODULE:continue_parse/3, Acc };
-process_line(Tag, [Line|MoreLines], Acc) ->
-    case eimap_utils:is_tagged_response(Line, Tag) of
-        true ->
-            formulate_response(eimap_utils:check_response_for_failure(Line, Tag), Acc);
-        false ->
-            process_line(Tag, MoreLines, [process_shared_prefix_parts(Line)|Acc])
-    end.
-
-%TODO: multiline!
 formulate_response(ok, [Acc]) -> { fini, relevant_shared_prefix_parts(Acc) };
 formulate_response({ _, Reason }, _Acc) -> { error, Reason }.
 
+% Private API
 relevant_shared_prefix_parts([]) -> { none, none};
 relevant_shared_prefix_parts([[], [], _]) -> { none, none };
 relevant_shared_prefix_parts([[], Delim]) -> { none, Delim };
 relevant_shared_prefix_parts([SharedPrefix, [], _]) -> { SharedPrefix, "/" };
 relevant_shared_prefix_parts([SharedPrefix, Delim]) -> { SharedPrefix, Delim }.
 
-process_shared_prefix_parts(<<"* NAMESPACE ", Data/binary>>) -> process_shared_prefix_parts(Data, 1);
-process_shared_prefix_parts(_) -> [].
-
 process_shared_prefix_parts(<<"NIL ", Data/binary>>, PartNumber) ->
     process_shared_prefix_parts(Data, PartNumber + 1);
 process_shared_prefix_parts(<<"NIL", Data/binary>>, PartNumber) ->

erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_noop.erl Added

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_peek_message.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_peek_message.erl Changed

@@ -17,15 +17,15 @@
 
 -module(eimap_command_peek_message).
 -behavior(eimap_command).
--export([new/1, parse/2, continue_parse/3]).
+-export([new_command/1, parse/2, continue_parse/3]).
 -record(parse_state, { body_size, parts, data }).
 -record(parts, { headers = <<"">>, body = <<"">>, flags = <<"">> }).
 
 %% https://tools.ietf.org/html/rfc3501#section-6.4.5
 
 %% Public API
-new(MessageID) when is_integer(MessageID) -> new(integer_to_binary(MessageID));
-new(MessageID) when is_binary(MessageID) -> <<"UID FETCH ",  MessageID/binary, " (FLAGS BODY.PEEK[HEADER] BODY.PEEK[TEXT])">>.
+new_command(MessageID) when is_integer(MessageID) -> new_command(integer_to_binary(MessageID));
+new_command(MessageID) when is_binary(MessageID) -> { <<"UID FETCH ",  MessageID/binary, " (FLAGS BODY.PEEK[HEADER] BODY.PEEK[TEXT])">>, blob_response }.
 
 continue_parse(Data, _Tag, #parse_state{ body_size = Size, parts = Parts, data = PrevData }) ->
     try_body_parse(<<PrevData/binary, Data/binary>>, Size, Parts).

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_starttls.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_starttls.erl Changed

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_status.erl -> erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_status.erl Changed

@@ -17,25 +17,26 @@
 
 -module(eimap_command_status).
 -behavior(eimap_command).
--export([new/1, parse/2, continue_parse/3]).
+-export([new_command/1, process_line/2, formulate_response/2]).
 
 % https://tools.ietf.org/html/rfc5464
 
 % supported attributes: messages, recent, uidnext, uidvalidity, unseen, annotate
 % Public API
-new({ Folder, Attributes }) when is_list(Folder) -> new({ list_to_binary(Folder), Attributes });
-new({ <<>>, Attributes}) -> new({ <<"INBOX">>, Attributes });
-new({ Folder, []}) -> new({ Folder, [messages] });
-new({ Folder, Attributes }) when is_list(Attributes) ->
-          AttributesString = attribute_string(Attributes, <<>>),
-          <<"STATUS ", Folder/binary, " (", AttributesString/binary, ")">>.
+new_command({ Folder, Attributes }) when is_list(Folder) -> new_command({ list_to_binary(Folder), Attributes });
+new_command({ <<>>, Attributes}) -> new_command({ <<"INBOX">>, Attributes });
+new_command({ Folder, []}) -> new_command({ Folder, [messages] });
+new_command({ Folder, Attributes }) when is_list(Attributes) ->
+            AttributesString = attribute_string(Attributes, <<>>),
+            { <<"STATUS ", Folder/binary, " (", AttributesString/binary, ")">>, multiline_response }.
 
-parse(Data, Tag) -> continue_parse(Data, Tag, []).
-
-continue_parse(Data, Tag, Acc) ->
-    Lines = binary:split(Data, <<"\r\n">>, [global]),
-    process_line(Tag, Lines, Acc).
+process_line(<<"* STATUS ", Data/binary>>, Acc) ->
+    process_status_items(binary:match(Data, <<"(">>),
+                         binary:match(Data, <<")">>),
+                         Data, Acc);
+process_line(_, Acc) -> Acc.
 
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, Data).
 
 %% Private API
 attribute_string([], <<>>) -> attribute_string(messages);
@@ -49,25 +50,7 @@
         Attr -> attribute_string(Attributes, <<String/binary, " ", Attr/binary>>)
     end.
 
-process_line(_Tag, [], Acc) -> { more, fun ?MODULE:continue_parse/3, Acc };
-process_line(Tag, [Line|MoreLines], Acc) ->
-    case eimap_utils:is_tagged_response(Line, Tag) of
-        true ->
-            formulate_response(eimap_utils:check_response_for_failure(Line, Tag), Acc);
-        false ->
-            process_line(Tag, MoreLines, process_status_items(Line, Acc))
-    end.
-
-%TODO: multiline, partial lines
-formulate_response(ok, Acc) -> { fini, Acc };
-formulate_response({ _, Reason }, _Acc) -> { error, Reason }.
-
-process_status_items(<<"* STATUS ", Data/binary>>, Acc) ->
-    process_status_items(binary:match(Data, <<"(">>),
-                         binary:match(Data, <<")">>),
-                         Data, Acc);
-process_status_items(_, Acc) -> Acc.
-
+% Private API
 process_status_items(nomatch, _, _Data, Acc) -> Acc;
 process_status_items(_, nomatch, _Data, Acc) -> Acc;
 process_status_items({ Start, _ }, { End, _ }, Data, Acc) ->

erlang-eimap-0.2.2.tar.gz/src/commands/eimap_command_switch_folder.erl Added

erlang-eimap-0.2.tar.gz/src/eimap.app.src -> erlang-eimap-0.2.2.tar.gz/src/eimap.app.src Changed

erlang-eimap-0.2.tar.gz/src/eimap.erl -> erlang-eimap-0.2.2.tar.gz/src/eimap.erl Changed

@@ -17,7 +17,6 @@
 
 -module(eimap).
 -behaviour(gen_fsm).
--include("eimap.hrl").
 
 %% API
 -export([start_link/1,
@@ -33,12 +32,13 @@
          capabilities/3,
          login/5, logout/3,
          compress/1,
-         get_server_metadata/4,
+         get_server_metadata/4, get_server_metadata/6,
          get_folder_status/5,
-         get_folder_metadata/5,
+         get_folder_metadata/5, get_folder_metadata/7,
          get_folder_annotations/4,
-         get_message_headers_and_body/5,
-         get_path_tokens/3]).
+         peek_message_headers_and_body/5,
+         get_path_tokens/3,
+         noop/3]).
 
 %% gen_fsm callbacks
 -export([disconnected/2, idle/2, passthrough/2, wait_response/2, startingtls/2]).
@@ -47,26 +47,16 @@
 %% state record definition
 -record(state, { host, port, tls, tls_state = false, socket, server_id = <<>>,
                  command_serial = 1, command_queue = queue:new(),
-                 current_command, current_mbox, parse_state,
+                 current_command, current_mbox,
                  passthrough = false, passthrough_recv, passthrough_send_buffer = <<>>,
                  inflator, deflator}).
--record(command, { tag, mbox, message, from, response_token, parse_fun }).
+-record(command, { tag, mbox, message, from, response_type, response_token, parse_state }).
 
 -define(SSL_UPGRADE_TIMEOUT, 5000).
 -define(TCP_CONNECT_TIMEOUT, 5000).
 
--export([test/0]).
-test() ->
-    ServerConfig = #eimap_server_config{ host = "192.168.56.101", port = 143, tls = false },
-    { ok, Conn } = start_link(ServerConfig),
-    login(Conn, self(), undefined, "doe", "doe"),
-    get_folder_metadata(Conn, self(), undefined, "*", ["/shared/vendor/kolab/folder-type"]),
-    logout(Conn, self(), undefined),
-    connect(Conn).
-
-
 %% public API
-start_link(ServerConfig) when is_record(ServerConfig, eimap_server_config) -> gen_fsm:start_link(?MODULE, ServerConfig, []).
+start_link(Options) when is_list(Options) -> gen_fsm:start_link(?MODULE, Options, []).
 
 start_passthrough(PID, Receiver) when is_pid(Receiver)  -> gen_fsm:send_all_state_event(PID, { start_passthrough, Receiver } ).
 stop_passthrough(PID) -> gen_fsm:send_all_state_event(PID, stop_passthrough).
@@ -75,93 +65,80 @@
 connect(PID, From, ResponseToken) -> gen_fsm:send_all_state_event(PID, { connect, From, ResponseToken }).
 disconnect(PID) -> gen_fsm:send_all_state_event(PID, disconnect).
 
-compress(PID) when is_pid(PID) ->
-    Command = #command{ message = eimap_command_compress:new(ok),
-                        from = PID, response_token = compress,
-                        parse_fun = fun eimap_command_compress:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec compress(EImap :: pid()) -> ok.
+compress(EImap) when is_pid(EImap) ->
+    send_command_to_queue(EImap, EImap, compress, eimap_command_compress, ok).
 
-starttls(PID, From, ResponseToken) when is_pid(PID) ->
-    Command = #command{ message = eimap_command_starttls:new(ok),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_starttls:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec starttls(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+starttls(EImap, From, ResponseToken) when is_pid(EImap) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_starttls, ok).
 
-capabilities(PID, From, ResponseToken) when is_pid(PID) ->
-    Command = #command{ message = eimap_command_capability:new(noparams),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_capability:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec capabilities(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+capabilities(EImap, From, ResponseToken) when is_pid(EImap) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_capability, ok).
 
--spec login(PID :: pid(), From :: pid(), ResponseToken :: any(), User :: list() | binary(), Pass :: list() | binary()) -> ok.
-login(PID, From, ResponseToken, User, Pass) ->
-    Command = #command{ message = eimap_command_login:new({ User, Pass }),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_login:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec login(EImap :: pid(), From :: pid(), ResponseToken :: any(), User :: list() | binary(), Pass :: list() | binary()) -> ok.
+login(EImap, From, ResponseToken, User, Pass) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_login, { User, Pass }).
 
--spec logout(PID :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
-logout(PID, From, ResponseToken) ->
-    Command = #command{ message = eimap_command_logout:new(ok),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_logout:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec logout(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+logout(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_logout, ok).
 
 -type status_property() :: messages | recent | uidnext | uidvalidity | unseen.
 -type status_properties() :: [status_property()].
--spec get_folder_status(PID :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: status_properties()) -> ok.
-get_folder_status(PID, From, ResponseToken, Folder, Properties) ->
-    Command = #command{ message = eimap_command_status:new({ Folder, Properties }),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_status:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_folder_status(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: status_properties()) -> ok.
+get_folder_status(EImap, From, ResponseToken, Folder, Properties) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_status, { Folder, Properties }).
 
--spec get_folder_metadata(PID :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()]) -> ok.
-get_folder_metadata(PID, From, ResponseToken, Folder, Properties) ->
-    Command = #command{ message = eimap_command_getmetadata:new({ Folder, Properties}),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_getmetadata:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()]) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties) ->
+    get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, infinity, nomax).
 
--spec get_server_metadata(PID :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()]) -> ok.
-get_server_metadata(PID, From, ResponseToken, Properties) ->
-    Command = #command{ message = eimap_command_getmetadata:new({ <<>>, Properties}),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_getmetadata:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, Depth, MaxSize) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { Folder, Properties, Depth, MaxSize }).
 
-get_folder_annotations(PID, From, ResponseToken, Folder) when is_list(Folder) ->
-    get_folder_annotations(PID, From, ResponseToken, list_to_binary(Folder));
-get_folder_annotations(PID, From, ResponseToken, Folder) when is_binary(Folder) ->
-    Command = #command{ message = eimap_command_annotation:new(Folder),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_annotation:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()]) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, infinity, nomax }).
 
-get_message_headers_and_body(PID, From, ResponseToken, Folder, MessageID) ->
-    %%lager:info("SELECT_DEBUG: peeking message ~p ~p", [Folder, MessageID]),
-    Command = #command{ mbox = Folder, message = eimap_command_peek_message:new(MessageID),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_peek_message:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties, Depth, MaxSize) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, Depth, MaxSize }).
+
+-spec get_folder_annotations(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()]) -> ok.
+get_folder_annotations(EImap, From, ResponseToken, Folder) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_annotation, Folder).
+
+-spec peek_message_headers_and_body(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()], MessageID :: [integer() | binary()]) -> ok.
+peek_message_headers_and_body(EImap, From, ResponseToken, Folder, MessageID) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_peek_message, MessageID, Folder).
+
+-spec get_path_tokens(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+get_path_tokens(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_namespace, ok).
+
+-spec noop(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+noop(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_noop, ok).
 
-get_path_tokens(PID, From, ResponseToken) ->
-    Command = #command{ message = eimap_command_namespace:new([]),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_namespace:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
 
 %% gen_server API
-init(#eimap_server_config{ host = Host, port = Port, tls = TLS }) ->
+init(Options) ->
+    Host = proplists:get_value(host, Options, "127.0.0.1"),
+    Port = proplists:get_value(port, Options, 143),
+    TLS = proplists:get_value(tls, Options, false),
     State = #state { host = Host, port = Port, tls  = TLS },
     { ok, disconnected, State }.
 
 disconnected({ connect, Receiver, ResponseToken }, #state{ command_queue = CommandQueue, host = Host, port = Port, tls = TLS, socket = undefined } = State) ->
     %lager:debug("CONNECTING! ~p ~p", [Receiver, ResponseToken]),
     { {ok, Socket}, TlsState, SendCapabilitiesTo, NewCommandQueue } = create_socket(Host, Port, TLS, Receiver, ResponseToken, CommandQueue),
-    Command = #command{ message = eimap_command_capability:new([]),
+    { Message, ResponseType } = eimap_command_capability:new_command(parse_serverid),
+    Command = #command{ message = Message, response_type = ResponseType,
                         from = SendCapabilitiesTo, response_token = { connected, Receiver, ResponseToken },
-                        parse_fun = fun eimap_command_capability:parse/2 },
+                        parse_state = eimap_command_capability },
     { next_state, wait_response, State#state { socket = Socket, tls_state = TlsState, current_command = Command, command_queue = NewCommandQueue } };
 disconnected(Command, State) when is_record(Command, command) ->
     { next_state, disconnected, enque_command(Command, State) }.
@@ -216,15 +193,11 @@
 %%TODO a variant that checks "#command{ from = undefined }" to avoid parsing responses which will go undelivered?
 wait_response(Command, State) when is_record(Command, command) ->
     { next_state, wait_response, enque_command(Command, State) };
-wait_response({ data, _Data }, #state{ current_command = #command{ parse_fun = undefined } } = State) ->
+wait_response({ data, _Data }, #state{ current_command = #command{ parse_state = undefined } } = State) ->
     gen_fsm:send_event(self(), process_command_queue),
     { next_state, idle, State };
-wait_response({ data, Data }, #state{ current_command = #command{ parse_fun = Fun, tag = Tag } } = State) when is_function(Fun, 2) ->
-    Response = Fun(Data, Tag),
-    %%lager:info("Response from parser was ~p ~p, size of queue ~p", [More, Response, queue:len(State#state.command_queue)]),
-    next_command_after_response(Response, State);
-wait_response({ data, Data }, #state{ parse_state = ParseState, current_command = #command{ parse_fun = Fun, tag = Tag } } = State) when is_function(Fun, 3) ->
-    Response = Fun(Data, Tag, ParseState),
+wait_response({ data, Data }, #state{ current_command = #command{ response_type = ResponseType, parse_state = CommandState , tag = Tag } } = State) ->
+    Response = eimap_command:parse_response(ResponseType, Data, Tag, CommandState),
     %%lager:info("Response from parser was ~p ~p, size of queue ~p", [More, Response, queue:len(State#state.command_queue)]),
     next_command_after_response(Response, State);
 wait_response(process_command_queue, State) ->
@@ -235,8 +208,8 @@
     { next_state, startingtls, State#state{ passthrough_send_buffer = <<Buffer/binary, Data>> } };
 startingtls(Command, State) when is_record(Command, command) ->
     { next_state, startingtls, enque_command(Command, State) };
-startingtls({ data, Data }, #state{ current_command = #command{ parse_fun = Fun, tag = Tag } } = State) when is_function(Fun, 2) ->
-    Response = Fun(Data, Tag),
+startingtls({ data, Data }, #state{ current_command = #command{ response_type = ResponseType, parse_state = CommandState, tag = Tag } } = State) ->
+    Response = eimap_command:parse_response(ResponseType, Data, Tag, CommandState),
     %%lager:info("Response from parser was ~p ~p, size of queue ~p", [More, Response, queue:len(State#state.command_queue)]),
     next_command_after_response(Response, State).
 
@@ -249,6 +222,8 @@
 handle_event(disconnect, _StateName, State) ->
     close_socket(State),
     { next_state, disconnected, reset_state(State) };
+handle_event({ ready_command, Command }, StateName, State) when is_record(Command, command) ->
+    ?MODULE:StateName(Command, State);
 handle_event({ start_passthrough, Receiver }, StateName, State) ->
     { next_state, StateName, State#state{ passthrough = true, passthrough_recv = Receiver } };
 handle_event(stop_passthrough, StateName, State) ->
@@ -259,8 +234,6 @@
                     State -> State
                 end,
     { next_state, NextState, State#state{ passthrough = false } };
-handle_event({ ready_command, Command }, StateName, State) when is_record(Command, command) ->
-    ?MODULE:StateName(Command, State);
 handle_event({ passthrough, Data }, passthrough, #state{ passthrough = true } = State) ->
     ?MODULE:passthrough({ passthrough, Data }, State);
 handle_event({ passthrough, Data }, StateName, #state{ passthrough = true, passthrough_send_buffer = Buffer } = State) ->
@@ -287,13 +260,13 @@
     %lager:info("Received from server plaintext: ~s", [Data]),
     ?MODULE:StateName({ data, Data }, State);
 handle_info({ ssl_closed, Socket }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
-    lager:info("~p Disconnected from ~p:~p .\n", [self(), Host, Port]),
+    lager:debug("~p Disconnected from ~p:~p .\n", [self(), Host, Port]),
     { stop, normal, State };
 handle_info({ ssl_error, Socket, _Reason }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
     lager:info("~p Disconnected due to socket error from ~p:~p .\n", [self(), Host, Port]),
     { stop, normal, State };
 handle_info({ tcp_closed, Socket }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
-    lager:info("~p Disconnected from ~p:~p .\n", [self(), Host, Port]),
+    lager:debug("~p Disconnected from ~p:~p .\n", [self(), Host, Port]),
     { stop, normal, State };
 handle_info({ tcp_error, Socket, _Reason }, _StateName, #state{ socket = Socket, host = Host, port = Port } = State) ->
     lager:info("~p Disconnected due to socket error from ~p:~p .\n", [self(), Host, Port]),
@@ -313,10 +286,15 @@
             %lager:debug("Connected, capabilities are: ~s; ServerID is ~s", [Capabilities, ServerID]),
             send_hello_string(Capabilities, ServerID, Receiver, ResponseToken, Passthrough, PassthroughReceiver)
     end,
-    { next_state, idle, State#state{ parse_state = none, server_id = ServerID } };
+    { next_state, idle, State#state{ current_command = undefined, server_id = ServerID } };
 handle_info({ { posttls_capabilities, Receiver, ResponseToken }, Capabilities }, _StateName, #state{ server_id = ServerID, passthrough = Passthrough, passthrough_recv = PassthroughReceiver } = State) ->
-    send_hello_string(Capabilities, ServerID, Receiver, ResponseToken, Passthrough, PassthroughReceiver),
-    { next_state, idle, State#state{ parse_state = none } };
+    OurCapabilities =
+        case binary:match(Capabilities, <<"STARTTLS">>) of
+            nomatch -> <<Capabilities/binary, " STARTTLS">>;
+            _ -> Capabilities
+        end,
+    send_hello_string(OurCapabilities, ServerID, Receiver, ResponseToken, Passthrough, PassthroughReceiver),
+    { next_state, idle, State#state{ current_command = none } };
 handle_info({ { selected, MBox }, ok }, StateName, State) ->
     %%lager:info("~p Selected mbox ~p", [self(), MBox]),
     { next_state, StateName, State#state{ current_mbox = MBox } };
@@ -336,13 +314,23 @@
 code_change(_OldVsn, Statename, State, _Extra) -> { ok, Statename, State }.
 
 %% private API
+send_command_to_queue(EImap, From, ResponseToken, Module, Args) ->
+    send_command_to_queue(EImap, From, ResponseToken, Module, Args, undefined).
+send_command_to_queue(EImap, From, ResponseToken, Module, Args, Folder) ->
+    { Message, ResponseType } = Module:new_command(Args),
+    Command = #command{ mbox = Folder, message = Message, response_type = ResponseType,
+                        from = From, response_token = ResponseToken,
+                        parse_state = Module },
+    gen_fsm:send_all_state_event(EImap, { ready_command, Command }).
+
 send_hello_string(Capabilities, ServerId, Receiver, ResponseToken, Passthrough, PassthroughReceiver) ->
-    Message = <<"* OK [CAPABILITY ", Capabilities/binary, "] ", ServerId/binary, "\r\n">>,
-    notify_of_response(Message, Receiver, ResponseToken),
-    passthrough_capabilities(Message, Passthrough, PassthroughReceiver).
+    notify_of_response([{ capabilities, Capabilities }, { server_id, ServerId } ], Receiver, ResponseToken),
+    passthrough_capabilities(Capabilities, ServerId, Passthrough, PassthroughReceiver).
 
-passthrough_capabilities(Response, true, Receiver) -> Receiver ! { imap_server_response, Response };
-passthrough_capabilities(_Response, _Passthrough, _Receiver) -> ok.
+passthrough_capabilities(Capabilities, ServerId, true, Receiver) ->
+    Message = <<"* OK [CAPABILITY ", Capabilities/binary, "] ", ServerId/binary, "\r\n">>,
+    Receiver ! { imap_server_response, Message };
+passthrough_capabilities(_Capabilities, _ServerId, _Passthrough, _Receiver) -> ok.
 
 notify_of_response(none, _Command) -> ok;
 notify_of_response(Response, #command { from = From, response_token = Token }) -> notify_of_response(Response, From, Token);
@@ -356,28 +344,26 @@
 notify_of_mbox_failure_during_filter(Command, true) -> notify_of_response({ error, mailboxnotfound }, Command), false;
 notify_of_mbox_failure_during_filter(_Command, false) -> true.
 
-next_command_after_response({ more, Fun, ParseState }, State) when is_function(Fun, 3) ->
-    { next_state, wait_response, State#state{ parse_state = ParseState, current_command = State#state.current_command#command{ parse_fun = Fun } } };
 next_command_after_response({ more, ParseState }, State) ->
-    { next_state, wait_response, State#state{ parse_state = ParseState } };
+    { next_state, wait_response, State#state{ current_command = State#state.current_command#command{ parse_state = ParseState } } };
 next_command_after_response({ error, _ } = ErrorResponse, State) ->
     notify_of_response(ErrorResponse, State#state.current_command),
     gen_fsm:send_event(self(), process_command_queue),
-    { next_state, idle, State#state{ parse_state = none } };
+    { next_state, idle, State#state{ current_command = undefined } };
 next_command_after_response({ fini, Response }, State) ->
     %lager:info("Notifying with ~p", [State#state.current_command]),
     notify_of_response(Response, State#state.current_command),
     gen_fsm:send_event(self(), process_command_queue),
-    { next_state, idle, State#state{ parse_state = none } };
+    { next_state, idle, State#state{ current_command = undefined } };
 next_command_after_response(starttls, State) ->
     { TLSState, Socket } = upgrade_socket(State),
     %lager:info("~p Upgraded the socket ...", [self()]),
     gen_fsm:send_event(self(), process_command_queue),
-    { next_state, idle, State#state{ parse_state = none, socket = Socket, tls_state = TLSState } };
+    { next_state, idle, State#state{ current_command = undefined, socket = Socket, tls_state = TLSState } };
 next_command_after_response(compression_active, State) ->
     { Inflator, Deflator } = eimap_utils:new_imap_compressors(),
     gen_fsm:send_event(self(), process_command_queue),
-    { next_state, idle, State#state{ inflator = Inflator, deflator = Deflator } };
+    { next_state, idle, State#state{ current_command = undefined, inflator = Inflator, deflator = Deflator } };
 next_command_after_response({ close_socket, Response }, State) ->
     notify_of_response(Response, State#state.current_command),
     { stop, normal, State }.
@@ -393,12 +379,15 @@
     %lager:debug("Setting up the tls creation with ultimate end point of ~p ~p", [Receiver, ResponseToken]),
     % we do an implicit TLS by adding a starttls command and then a capability command so we can
     % pretend to the user that the socket just magically opened up like this.
-    TlsCommand = #command{ message = eimap_command_starttls:new(noparams),
+    %TODO: some duplicated code here; would be nice to clean this up a bit?
+    { TlsMessage, TlsResponseType } = eimap_command_starttls:new_command(ok),
+    TlsCommand = #command{ message = TlsMessage, response_type = TlsResponseType,
                            from = self(), response_token = undefined,
-                           parse_fun = fun eimap_command_starttls:parse/2 },
-    CapabilitiesCommand = #command{ message = eimap_command_capability:new(noparams),
+                           parse_state = eimap_command_starttls },
+    { CapMessage, CapResponseType } = eimap_command_capability:new_command(ok),
+    CapabilitiesCommand = #command{ message = CapMessage, response_type = CapResponseType,
                                     from = self(), response_token = { posttls_capabilities, Receiver, ResponseToken },
-                                    parse_fun = fun eimap_command_capability:parse/2 },
+                                    parse_state = eimap_command_capability },
     % note the use of queue:in_r to _prepend_ the commands so they get run first even if the user
     % has pre-connection queued up commands
     NewCommandQueue = queue:in_r(TlsCommand, queue:in_r(CapabilitiesCommand, CommandQueue)),
@@ -444,28 +433,30 @@
 send_command(Command, State) ->
     send_command(fun gen_tcp:send/2, Command, State).
 
-send_command(Fun, #command{ mbox = undefined } = Command, State) ->
+send_command(SocketFun, #command{ mbox = undefined } = Command, State) ->
     %%lager:info("~p SELECT_DEBUG issuing command without mbox: ~p", [self(), Command#command.message]),
-    send_command_now(Fun, Command, State);
-send_command(Fun, #command{ mbox = MBox } = Command, #state{ current_mbox = CurrentMbox } = State) ->
+    send_command_now(SocketFun, Command, State);
+send_command(SocketFun, #command{ mbox = MBox } = Command, #state{ current_mbox = CurrentMbox } = State) ->
     %%lager:info("~p SELECT_DEBUG issuing command with mbox ~p (current: ~p, equal -> ~p): ~p", [self(), MBox, CurrentMbox, (MBox =:= CurrentMbox), Command#command.message]),
-    send_command_or_select_mbox(Fun, Command, State, MBox, MBox =:= CurrentMbox).
+    send_command_or_select_mbox(SocketFun, Command, State, MBox, MBox =:= CurrentMbox).
 
-send_command_or_select_mbox(Fun, Command, State, _MBox, true) ->
-    send_command_now(Fun, Command, State);
-send_command_or_select_mbox(Fun, DelayedCommand, State, MBox, false) ->
+send_command_or_select_mbox(SocketFun, Command, State, _MBox, true) ->
+    send_command_now(SocketFun, Command, State);
+send_command_or_select_mbox(SocketFun, DelayedCommand, State, MBox, false) ->
     NextState = reenque_command(DelayedCommand, State),
-    SelectMessage = eimap_command_examine:new(MBox),
-    SelectCommand = #command{ message = SelectMessage, parse_fun = fun eimap_command_examine:parse/2,
+    %TODO: this really should be SELECT rather than EXAMINE
+    { SelectMessage, ResponseType } = eimap_command_switch_folder:new_command(MBox),
+    SelectCommand = #command{ message = SelectMessage, response_type = ResponseType,
+                              parse_state = eimap_command_switch_folder,
                               from = self(), response_token = { selected, MBox } },
     %%lager:info("~p SELECT_DEBUG: Doing a select first ~p", [self(), SelectMessage]),
-    send_command_now(Fun, SelectCommand, NextState).
+    send_command_now(SocketFun, SelectCommand, NextState).
 
-send_command_now(Fun, #command{ message = Message } = Command, #state{ command_serial = Serial, socket = Socket } = State) ->
+send_command_now(SocketFun, #command{ message = Message } = Command, #state{ command_serial = Serial, socket = Socket } = State) ->
     Tag = list_to_binary(io_lib:format("EG~*..0B", [tag_field_width(Serial), Serial])),
     Data = <<Tag/binary, " ", Message/binary, "\r\n">>,
     %lager:info("Sending command via ~p: ~s", [Fun, Data]),
-    Fun(Socket, deflated(Data, State)),
+    SocketFun(Socket, deflated(Data, State)),
     State#state{ command_serial = Serial + 1, current_command = Command#command{ tag = Tag } }.
 
 enque_command(Command, State) ->

erlang-eimap-0.2.tar.gz/src/eimap_command.erl -> erlang-eimap-0.2.2.tar.gz/src/eimap_command.erl Changed

@@ -1,13 +1,78 @@
 -module(eimap_command).
 
+-export([
+         parse_response/4,
+         formulate_response/2,
+         process_status_line/2
+        ]).
+
 -type more_tuple() :: { more, ParseContinuation :: parse_continuation(), State :: term }.
 -type finished_tuple() :: { fini, Results :: term }.
 -type error_tuple() :: { error, Reason :: binary() }.
 -type parse_continuation() :: fun((Data :: binary(), Tag :: binary(), State :: term()) ->
                                    more_tuple() | finished_tuple() | error_tuple()).
 
--callback new(Args :: any()) -> binary().
--callback parse(Data :: binary(), Tag :: binary()) ->
-    more_tuple() | finished_tuple() | error_tuple() | starttls.
+-callback new_command(Args :: any()) -> { binary(), single_line_response | multiline_reponse | blob_response }.
+% TODO:bring back when we can depend on OTP 18 which introduced optional_callback
+% also define parse/2 (for blob_response), formulate_response/2
+%-callback process_line(Data :: binary(), Acc :: any()) ->
+%    more_tuple() | finished_tuple() | error_tuple() | starttls.
+
+parse_response(multiline_response, Data, Tag, ParseState) -> multiline_parse(false, Data, Tag, ParseState);
+parse_response(all_multiline_response, Data, Tag, ParseState) -> multiline_parse(parse_tagged, Data, Tag, ParseState);
+parse_response(single_line_response, Data, Tag, Module) -> Module:formulate_response(Data, Tag);
+parse_response(blob_response, Data, Tag, { Continuation, ParseState }) -> Continuation(Data, Tag, ParseState);
+parse_response(blob_response, Data, Tag, Module) ->
+    case Module:parse(Data, Tag) of
+        { more, Continuation, ParseState } -> { more, { Continuation, ParseState } };
+        Response -> Response
+    end.
+
+multiline_parse(ParseTaggedLine, Data, Tag, { LastPartialLine, Acc, Module }) ->
+    FullBuffer = <<LastPartialLine/binary, Data/binary>>,
+    { FullLinesBuffer, NewLastPartialLine } = eimap_utils:only_full_lines(FullBuffer),
+    Lines = binary:split(FullLinesBuffer, <<"\r\n">>, [global]),
+    process_lines(ParseTaggedLine, Tag, NewLastPartialLine, Lines, Acc, Module);
+multiline_parse(ParseTaggedLine, Data, Tag, Module) ->
+    multiline_parse(ParseTaggedLine, Data, Tag, { <<>>, [], Module }).
+
+process_lines(_ParseTaggedLine, _Tag, LastPartialLine, [], Acc, Module) -> { more, { LastPartialLine, Acc, Module } };
+process_lines(ParseTaggedLine, Tag, LastPartialLine, [Line|MoreLines], Acc, Module) ->
+    { FirstLine, ContinuationBytes } = eimap_utils:num_literal_continuation_bytes(Line),
+    process_line(ContinuationBytes, ParseTaggedLine, eimap_utils:is_tagged_response(FirstLine, Tag), Tag, LastPartialLine, FirstLine, MoreLines, Acc, Module).
+
+
+process_line(ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, [<<>>|MoreLines], Acc, Module) ->
+    %% skip empty lines
+    process_line(ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, MoreLines, Acc, Module);
+process_line(0, ParseTaggedLine, tagged, Tag, _LastPartialLine, Line, _MoreLines, Acc, Module) ->
+    Checked = eimap_utils:check_response_for_failure(Line, Tag),
+    Module:formulate_response(Checked, parse_tagged(Checked, ParseTaggedLine, Line, Acc, Module));
+process_line(0, ParseTaggedLine, untagged, Tag, LastPartialLine, Line, MoreLines, Acc, Module) ->
+    io:format("Calling it here with ~p~n~n...", [Line]),
+    process_lines(ParseTaggedLine, Tag, LastPartialLine, MoreLines, Module:process_line(Line, Acc), Module);
+process_line(ContinuationBytes, ParseTaggedLine, _IsTagged, Tag, LastPartialLine, Line, [], Acc, Module) ->
+    %% the line was continued, but there is no more lines ... so this line is now our last partial line. more must be on its way
+    io:format("Missing lines!~p~n~n", [Acc]),
+    BytesAsBinary = integer_to_binary(ContinuationBytes),
+    process_lines(ParseTaggedLine, Tag, <<Line/binary, ${, BytesAsBinary/binary, $}, LastPartialLine/binary>>, [], Acc, Module);
+process_line(_ContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, Line, [NextLine|MoreLines], Acc, Module) ->
+    { StrippedNextLine, NextContinuationBytes } = eimap_utils:num_literal_continuation_bytes(NextLine),
+    io:format("Connected up the next line: ~p ~i~n", [StrippedNextLine, NextContinuationBytes]),
+    FullLine = <<Line/binary, StrippedNextLine/binary>>,
+    process_line(NextContinuationBytes, ParseTaggedLine, IsTagged, Tag, LastPartialLine, FullLine, MoreLines, Acc, Module).
+
+formulate_response(ok, Data) -> { fini, Data };
+formulate_response({ _, Reason }, _Data) -> { error, Reason }.
+
+parse_tagged(_, false, _Line, Acc, _Module) -> Acc; % we are not passing the tagged line forward (no content, e.g)
+parse_tagged(ok, _, Line, Acc, Module) -> Module:process_tagged_line(Line, Acc); % success, so pass it forward
+parse_tagged(_Checked, _ParsedTaggedLine, _Line, Acc, _Module) -> Acc. % error, don't bother passing it forward
+
+-spec process_status_line(Line :: binary(), Acc :: list()) -> NewAcc :: list().
+process_status_line(<<"* ", Rest/binary>>, Acc) -> process_matched_status_line(binary:split(Rest, <<" ">>, [global]), Acc);
+process_status_line(_, Acc) -> Acc.
 
+process_matched_status_line([Number, Key|_], Acc) -> [{ eimap_utils:binary_to_atom(Key), binary_to_integer(Number) }|Acc];
+process_matched_status_line(_, Acc) -> Acc.

erlang-eimap-0.2.tar.gz/src/eimap_uidset.erl -> erlang-eimap-0.2.2.tar.gz/src/eimap_uidset.erl Changed

@@ -16,12 +16,20 @@
 %% along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 -module(eimap_uidset).
--export([parse/1, next_uid/1]).
+-export([uid_list_to_binary/1, parse/1, next_uid/1]).
+
+% for internal use only
+-export([add_uid_as_binary_to_list/2, stitch_bin_list/2]).
 
 %% tokens have the form: integer | { integer, integer }
 -record(uidset, { tokens = [], current = none }).
 
-%% currently do not support parsing regular (list) strings, but could be added
+uid_list_to_binary(UidList) when is_list(UidList) ->
+    ListOfBins = lists:foldl(fun ?MODULE:add_uid_as_binary_to_list/2, [], UidList),
+    lists:foldl(fun ?MODULE:stitch_bin_list/2, <<>>, ListOfBins);
+uid_list_to_binary(_UidList) -> <<>>.
+
+parse(UidSet) when is_list(UidSet) -> parse(list_to_binary(UidSet));
 parse(<<>>)  -> badarg;
 parse(UidSet) when is_binary(UidSet) ->
     Components = binary:split(UidSet, <<",">>, [global]),
@@ -31,6 +39,27 @@
         _:_ -> badarg
     end.
 
+next_uid(#uidset{ tokens = Tokens, current = Current }) -> next_uid(Tokens, Current).
+next_uid([], _Current) -> { none, #uidset {} };
+next_uid([{ First, Second }|_] = FullList, Current) -> next_in_range(FullList, First, Second, Current);
+next_uid([Uid|UidSet], _Current) -> { Uid, #uidset{ tokens = UidSet } }.
+
+% PRIVATE API
+add_uid_as_binary_to_list(Uid, Acc) when is_integer(Uid), Uid >= 0 -> [integer_to_binary(Uid)|Acc];
+add_uid_as_binary_to_list({ StartUid, EndUid }, Acc) when is_integer(StartUid), is_integer(EndUid) ->
+    case add_uid_range_as_binary_to_list(StartUid, EndUid) of
+        error -> Acc;
+        { Start, End } -> [<<Start/binary, ":", End/binary>>|Acc]
+    end;
+add_uid_as_binary_to_list(_, Acc) -> Acc.
+
+add_uid_range_as_binary_to_list(Start, End) when Start < 0; End < 0 -> error;
+add_uid_range_as_binary_to_list(Start, End) when Start < End -> { integer_to_binary(Start), integer_to_binary(End) };
+add_uid_range_as_binary_to_list(Start, End) -> { integer_to_binary(End), integer_to_binary(Start) }.
+
+stitch_bin_list(Uid, <<>>) -> Uid;
+stitch_bin_list(Uid, Acc) -> <<Uid/binary, ",", Acc/binary>>.
+
 add_component(Uid, Acc) when is_integer(Uid), Uid >= 0 -> [Uid|Acc];
 add_component([First, Second], Acc) -> add_component(binary_to_integer(First), binary_to_integer(Second), Acc);
 add_component([<<"">>], Acc) -> Acc;
@@ -43,11 +72,6 @@
 add_range(First, Second, Acc) when First == Second -> [First|Acc];
 add_range(First, Second, Acc) -> [{ First, Second }|Acc].
 
-next_uid(#uidset{ tokens = Tokens, current = Current }) -> next_uid(Tokens, Current).
-next_uid([], _Current) -> { none, #uidset {} };
-next_uid([{ First, Second }|_] = FullList, Current) -> next_in_range(FullList, First, Second, Current);
-next_uid([Uid|UidSet], _Current) -> { Uid, #uidset{ tokens = UidSet } }.
-
 next_in_range(Tokens, First, _Second, none) -> { First, #uidset{ tokens = Tokens, current = First } };
 next_in_range(Tokens, First, Second, Current) when First < Second, Current < Second -> Next = Current + 1, { Next, #uidset{ tokens = Tokens, current = Next } };
 next_in_range(Tokens, First, Second, Current) when First > Second, Current > Second -> Next = Current - 1, { Next, #uidset{ tokens = Tokens, current = Next } };

erlang-eimap-0.2.tar.gz/src/eimap_utils.erl -> erlang-eimap-0.2.2.tar.gz/src/eimap_utils.erl Changed

@@ -19,15 +19,18 @@
 -export([
          extract_path_from_uri/3, extract_uidset_from_uri/1,
          split_command_into_components/1, is_tagged_response/2, remove_tag_from_response/3,
-         header_name/1,
+         header_name/1, parse_flags/1,
          check_response_for_failure/2,
          ensure_binary/1,
          new_imap_compressors/0,
-         only_full_lines/1
+         only_full_lines/1,
+         binary_to_atom/1,
+         num_literal_continuation_bytes/1
         ]).
 
 %% Translate the folder name in to a fully qualified folder path such as it
 %% would be used by a cyrus administrator.
+-spec extract_path_from_uri(SharedPrefix :: binary(), HierarchyDelim :: binary, URI :: binary()) -> Path :: binary() | bad_uri.
 extract_path_from_uri(SharedPrefix, HierarchyDelim, URI) when is_binary(URI) ->
     extract_path_from_uri(SharedPrefix, HierarchyDelim, binary_to_list(URI));
 extract_path_from_uri(SharedPrefix, HierarchyDelim, URI) when is_list(URI) ->
@@ -39,6 +42,7 @@
         Error -> Error
     end.
 
+-spec extract_uidset_from_uri(URI :: binary()) -> UIDSet:: binary().
 extract_uidset_from_uri(URI) when is_binary(URI) ->
     { TagStart, TagEnd } = binary:match(URI, <<";UID=">>),
     UIDStart = TagStart + TagEnd + 1,
@@ -48,11 +52,23 @@
         { Semicolon, _ } -> binary:part(URI, UIDStart - 1, Semicolon - UIDStart + 1)
     end.
 
+-spec header_name(mailbox_uid | groupware_uid | groupware_uid) -> binary(); (any()) -> unknown.
 header_name(mailbox_uid) -> <<"/vendor/cmu/cyrus-imapd/uniqueid">>;
 header_name(groupware_type) -> <<"X-Kolab-Type">>;
 header_name(groupware_uid) -> <<"Subject">>;
 header_name(_) -> unknown.
 
+-spec parse_flags(FlagString :: binary() | list()) -> Flags :: [binary()].
+parse_flags(String) when is_list(String) -> parse_flags(list_to_binary(String));
+parse_flags(<<"(", Parened/binary>>) ->
+    case binary:match(Parened, <<")">>) of
+        nomatch -> [];
+        { ClosingParens, _ } -> parse_flags(binary_part(Parened, 0, ClosingParens))
+    end;
+parse_flags(<<>>) -> [];
+parse_flags(FlagString) when is_binary(FlagString) ->
+    binary:split(FlagString, <<" ">>, [global]).
+
 -spec check_response_for_failure(Data :: binary(), Tag :: undefined | binary()) -> ok | { error, Reason :: binary() }.
 check_response_for_failure(Data, undefined) when is_binary(Data) ->
     check_response_for_failure(Data, <<>>);
@@ -68,13 +84,49 @@
 split_command_into_components(Buffer) when is_binary(Buffer) ->
     split_command(Buffer).
 
--spec is_tagged_response(Buffer :: binary(), Tag :: binary()) -> true | false.
+-spec is_tagged_response(Buffer :: binary(), Tag :: binary()) -> tagged | untagged.
 is_tagged_response(Buffer, Tag) ->
     TagSize = size(Tag) + 1, % The extra char is a space
     BufferSize = size(Buffer),
-    case (TagSize =< BufferSize) of
-        true -> <<Tag/binary, " ">> =:= binary:part(Buffer, 0, TagSize);
-        false -> false
+    case
+        case (TagSize =< BufferSize) of
+            true -> <<Tag/binary, " ">> =:= binary:part(Buffer, 0, TagSize);
+            _ -> false
+        end of
+
+        true -> tagged;
+        _ -> untagged
+    end.
+
+-spec num_literal_continuation_bytes(Buffer :: binary()) -> { BufferSansContinuation :: binary(), NumberBytes :: integer() }.
+num_literal_continuation_bytes(Buffer) when size(Buffer) < 4 ->
+    { Buffer, 0 };
+num_literal_continuation_bytes(Buffer) ->
+    case binary:last(Buffer) =:= $} of
+        true -> number_of_bytes_in_continuation(Buffer);
+        false -> { Buffer, 0 }
+    end.
+
+number_of_bytes_in_continuation(Buffer) ->
+    BufferSize = size(Buffer),
+    OpenBracePos = find_continuation_open_brace(Buffer, BufferSize - 3),
+    confirm_continuation(Buffer, OpenBracePos).
+
+find_continuation_open_brace(_Buffer, 0) -> -1;
+find_continuation_open_brace(Buffer, Pos) ->
+    case binary:at(Buffer, Pos) of
+        ${ -> Pos;
+        _ -> find_continuation_open_brace(Buffer, Pos - 1)
+    end.
+
+confirm_continuation(Buffer, -1) ->
+    { Buffer, 0 };
+confirm_continuation(Buffer, OpenBracePos) ->
+    BufferSize = size(Buffer),
+    try binary_to_integer(binary:part(Buffer, OpenBracePos + 1, BufferSize - OpenBracePos - 2)) of
+        Result -> { binary:part(Buffer, 0, OpenBracePos), Result }
+    catch
+        _:_ -> { Buffer, 0 }
     end.
 
 -spec remove_tag_from_response(Buffer :: binary(), Tag :: undefine | binary(), Check :: check | trust) -> Command :: binary().
@@ -187,6 +239,8 @@
 
 only_full_lines(Buffer, BufferLength, $\n, Pos) when Pos =:= BufferLength -> { Buffer, <<>> };
 only_full_lines(Buffer, BufferLength, $\n, Pos) -> { binary:part(Buffer, 0, Pos + 1), binary:part(Buffer, Pos + 1, BufferLength - Pos - 1) };
-only_full_lines(Buffer, BufferLength, _, 0) -> { <<>>, Buffer };
+only_full_lines(Buffer, _BufferLength, _, 0) -> { <<>>, Buffer };
 only_full_lines(Buffer, BufferLength, _, Pos) -> only_full_lines(Buffer, BufferLength, binary:at(Buffer, Pos - 1), Pos - 1).
 
+-spec binary_to_atom(Value :: binary()) -> ValueAsAtom :: atom().
+binary_to_atom(Value) -> list_to_atom(string:to_lower(binary_to_list(Value))).

erlang-eimap-0.2.tar.gz/test/eimap_command_annotation_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_annotation_tests.erl Changed

@@ -26,7 +26,7 @@
         %% { tag, server_response, expected_parsed_results }
         {
             <<"EG0002">>,
-            <<"* ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/color\" (\"value.shared\" \"32CD32\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/folder-type\" (\"value.shared\" \"event\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/x-toltec/test\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/horde/share-params\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/h-share-attr-desc\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/uniqueid\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/pxfb-readable-for\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/incidences-for\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/folder-test\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/displayname\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/activesync\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/uniqueid\" (\"value.shared\" \"b1a5bb95-2bd3-4628-a0d2-49e9bd10735e\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/squat\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/size\" (\"value.shared\" \"5726\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/sieve\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/sharedseen\" (\"value.shared\" \"false\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/pop3showafter\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/pop3newuidl\" (\"value.shared\" \"true\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/partition\" (\"value.shared\" \"default\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/news2mail\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/lastupdate\" (\"value.shared\" \"20-Mar-2015 05:17:51 +0100\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/lastpop\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/expire\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/duplicatedeliver\" (\"value.shared\" \"false\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/thread\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/specialuse\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/sort\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/comment\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/checkperiod\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/check\" (\"value.shared\" NIL)\r\n    EG0002 OK Completed">>,
+            <<"* ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/color\" (\"value.shared\" \"32CD32\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/folder-type\" (\"value.shared\" \"event\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/x-toltec/test\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/horde/share-params\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/h-share-attr-desc\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/uniqueid\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/pxfb-readable-for\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/incidences-for\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/folder-test\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/displayname\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/kolab/activesync\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/uniqueid\" (\"value.shared\" \"b1a5bb95-2bd3-4628-a0d2-49e9bd10735e\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/squat\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/size\" (\"value.shared\" \"5726\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/sieve\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/sharedseen\" (\"value.shared\" \"false\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/pop3showafter\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/pop3newuidl\" (\"value.shared\" \"true\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/partition\" (\"value.shared\" \"default\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/news2mail\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/lastupdate\" (\"value.shared\" \"20-Mar-2015 05:17:51 +0100\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/lastpop\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/expire\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/vendor/cmu/cyrus-imapd/duplicatedeliver\" (\"value.shared\" \"false\")\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/thread\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/specialuse\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/sort\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/comment\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/checkperiod\" (\"value.shared\" NIL)\r\n    * ANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"/check\" (\"value.shared\" NIL)\r\nEG0002 OK Completed\r\n">>,
             { fini, [
                 {<<"/vendor/cmu/cyrus-imapd/duplicatedeliver">>, false},
                 {<<"/vendor/cmu/cyrus-imapd/lastupdate">>, <<"20-Mar-2015 05:17:51 +0100">>},
@@ -42,7 +42,7 @@
         },
         {
             <<"EG0002">>,
-            <<"* ANNOTATION user/john.doe/Sent@example.org \"/vendor/x-toltec/test\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/horde/share-params\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/h-share-attr-desc\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/uniqueid\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/pxfb-readable-for\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/incidences-for\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/folder-type\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/folder-test\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/displayname\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/color\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/activesync\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/uniqueid\" (\"value.shared\" \"237357ec-7610-422e-9e55-0bae83caf58a\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/squat\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/size\" (\"value.shared\" \"401\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/sieve\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/sharedseen\" (\"value.shared\" \"false\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/pop3showafter\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/pop3newuidl\" (\"value.shared\" \"true\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/partition\" (\"value.shared\" \"default\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/news2mail\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/lastupdate\" (\"value.shared\" \"23-Mar-2015 15:19:29 +0100\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/lastpop\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/expire\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/duplicatedeliver\" (\"value.shared\" \"false\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/thread\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/specialuse\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/sort\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/comment\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/checkperiod\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/check\" (\"value.shared\" NIL)\r\n         EG0002 OK Completed">>,
+            <<"* ANNOTATION user/john.doe/Sent@example.org \"/vendor/x-toltec/test\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/horde/share-params\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/h-share-attr-desc\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/uniqueid\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/pxfb-readable-for\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/incidences-for\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/folder-type\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/folder-test\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/displayname\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/color\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/kolab/activesync\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/uniqueid\" (\"value.shared\" \"237357ec-7610-422e-9e55-0bae83caf58a\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/squat\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/size\" (\"value.shared\" \"401\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/sieve\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/sharedseen\" (\"value.shared\" \"false\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/pop3showafter\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/pop3newuidl\" (\"value.shared\" \"true\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/partition\" (\"value.shared\" \"default\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/news2mail\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/lastupdate\" (\"value.shared\" \"23-Mar-2015 15:19:29 +0100\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/lastpop\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/expire\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/vendor/cmu/cyrus-imapd/duplicatedeliver\" (\"value.shared\" \"false\")\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/thread\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/specialuse\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/sort\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/comment\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/checkperiod\" (\"value.shared\" NIL)\r\n         * ANNOTATION user/john.doe/Sent@example.org \"/check\" (\"value.shared\" NIL)\r\nEG0002 OK Completed\r\n">>,
             { fini, [
                 {<<"/vendor/cmu/cyrus-imapd/duplicatedeliver">>,false},
                 {<<"/vendor/cmu/cyrus-imapd/lastupdate">>,<<"23-Mar-2015 15:19:29 +0100">>},
@@ -55,13 +55,17 @@
             }
         }
     ],
-    lists:foldl(fun({ Tag, ServerData, Expected }, Acc) -> [?_assertEqual(Expected, eimap_command_annotation:parse(ServerData, Tag))|Acc] end, [], Data).
+    { _Command, ResponseType } = eimap_command_annotation:new_command(<<"/my/folder">>),
+    lists:foldl(fun({ Tag, ServerData, Expected }, Acc) -> [?_assertEqual(Expected, eimap_command:parse_response(ResponseType, ServerData, Tag, eimap_command_annotation))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         %% mailbox, command
-        { <<"user/john.doe/Calendar/Personal Calendar@example.org">>, <<"GETANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"*\" \"value.shared\"">> }
+        {
+          <<"user/john.doe/Calendar/Personal Calendar@example.org">>,
+          { <<"GETANNOTATION \"user/john.doe/Calendar/Personal Calendar@example.org\" \"*\" \"value.shared\"">>, multiline_response }
+        }
     ],
-    lists:foldl(fun({ Mailbox, Command }, Acc) -> [?_assertEqual(Command, eimap_command_annotation:new(Mailbox))|Acc] end, [], Data).
+    lists:foldl(fun({ Mailbox, Command }, Acc) -> [?_assertEqual(Command, eimap_command_annotation:new_command(Mailbox))|Acc] end, [], Data).

erlang-eimap-0.2.tar.gz/test/eimap_command_capability_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_capability_tests.erl Changed

@@ -23,40 +23,48 @@
     [
         % { Binary Response, Binary Tag, Parsed Results }
         {
+          parse_serverid,
           <<"* OK [CAPABILITY IMAP4rev1 LITERAL+ ID ENABLE STARTTLS LOGINDISABLED] acme.com Cyrus IMAP 2.5.5.5-Kolab-2.5.5-5.1.el6.kolab_14 server ready\r\n">>,
           <<>>,
           { fini, { <<"IMAP4rev1 LITERAL+ ID ENABLE STARTTLS LOGINDISABLED">>, <<"acme.com Cyrus IMAP 2.5.5.5-Kolab-2.5.5-5.1.el6.kolab_14 server ready">> } }
         },
         {
+          ok,
           <<"* CAPABILITY IMAP4rev1 LITERAL+ ID ENABLE STARTTLS AUTH=PLAIN AUTH=LOGIN SASL-IR\r\nabcd OK CAPABILITY COMPLETED\r\n">>,
           <<"abcd">>,
-          { fini, <<"IMAP4rev1 LITERAL+ ID ENABLE STARTTLS AUTH=PLAIN AUTH=LOGIN SASL-IR">> }
+          { fini, [<<"IMAP4rev1 LITERAL+ ID ENABLE STARTTLS AUTH=PLAIN AUTH=LOGIN SASL-IR">>] }
         },
         {
+          ok,
           <<"other stuff\r\n">>,
           <<"abcd">>,
-          <<"other stuff\r\n">>
+          { more, { <<>>, [], eimap_command_capability } }
         },
         {
+          ok,
           <<"abcd BAD Uh uh uh\r\n">>,
           <<"abcd">>,
           { error, <<"Uh uh uh">> }
         },
         {
+          ok,
           <<"abcd NO Uh uh uh\r\n">>,
           <<"abcd">>,
           { error, <<"Uh uh uh">> }
         }
     ],
-    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command_capability:parse(Response, Tag))|Acc] end, [], Data).
+    lists:foldl(fun({ InitArgs, Response, Tag, Parsed }, Acc) ->
+                        { _Command, ResponseType } = eimap_command_capability:new_command(InitArgs),
+                        [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, Response, Tag, eimap_command_capability))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         % input, output
-        { <<>>, <<"CAPABILITY">> },
-        { true, <<"CAPABILITY">> },
-        { [], <<"CAPABILITY">> }
+        { parse_serverid, { <<"CAPABILITY">>, single_line_response } },
+        { <<>>, { <<"CAPABILITY">>, multiline_response } },
+        { true, { <<"CAPABILITY">>, multiline_response } },
+        { [], { <<"CAPABILITY">>, multiline_response } }
     ],
-    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_capability:new(Params))|Acc] end, [], Data).
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_capability:new_command(Params))|Acc] end, [], Data).

erlang-eimap-0.2.tar.gz/test/eimap_command_compress_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_compress_tests.erl Changed

@@ -38,15 +38,18 @@
           { error, <<"Uh uh uh">> }
         }
     ],
-    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command_compress:parse(Response, Tag))|Acc] end, [], Data).
+    InitArgs = ok,
+    { _Command, ResponseType } = eimap_command_compress:new_command(InitArgs),
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, Response, Tag, eimap_command_compress))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         % input, output
-        { <<>>, <<"COMPRESS DEFLATE">> },
-        { true, <<"COMPRESS DEFLATE">> },
-        { [], <<"COMPRESS DEFLATE">> }
+        { ok, { <<"COMPRESS DEFLATE">>, single_line_response } },
+        { <<>>, { <<"COMPRESS DEFLATE">>, single_line_response } },
+        { true, { <<"COMPRESS DEFLATE">>, single_line_response } },
+        { [], { <<"COMPRESS DEFLATE">>, single_line_response } }
     ],
-    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_compress:new(Params))|Acc] end, [], Data).
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_compress:new_command(Params))|Acc] end, [], Data).

erlang-eimap-0.2.tar.gz/test/eimap_command_getmetadata_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_getmetadata_tests.erl Changed

@@ -57,17 +57,22 @@
           { error, <<"Uh uh uh">> }
         }
     ],
-    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command_getmetadata:parse(Response, Tag))|Acc] end, [], Data).
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) ->
+                        [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_getmetadata))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         % input, output
-        { { <<>> }, <<"GETMETADATA (DEPTH infinity) \"\"">> },
-        { { <<>>, [<<"/shared/comment">>, "/private/comment"] }, <<"GETMETADATA (DEPTH infinity) \"\" (/shared/comment /private/comment)">> },
-        { { <<"/my/folder">>, [<<"/shared/comment">>, "/private/comment"] }, <<"GETMETADATA (DEPTH infinity) \"/my/folder\" (/shared/comment /private/comment)">> },
-        { { "/my/folder", [<<"/shared/comment">>, "/private/comment"] }, <<"GETMETADATA (DEPTH infinity) \"/my/folder\" (/shared/comment /private/comment)">> },
-        { { <<"/my/folder">> }, <<"GETMETADATA (DEPTH infinity) \"/my/folder\"">> }
+        { { <<>> }, { <<"GETMETADATA (DEPTH infinity) \"\"">>, multiline_response } },
+        { { <<>>, [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"\" (/shared/comment /private/comment)">>, multiline_response } },
+        { { <<"/my/folder">>, [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\" (/shared/comment /private/comment)">>, multiline_response } },
+        { { "/my/folder", [<<"/shared/comment">>, "/private/comment"] }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\" (/shared/comment /private/comment)">>, multiline_response } },
+        { { <<"/my/folder">> }, { <<"GETMETADATA (DEPTH infinity) \"/my/folder\"">>, multiline_response } },
+        { { "/my/folder", [], 10, 100 }, { <<"GETMETADATA (DEPTH 10 MAXSIZE 100) \"/my/folder\"">>, multiline_response } },
+        { { <<"/my/folder">>, [], 10, 100 }, { <<"GETMETADATA (DEPTH 10 MAXSIZE 100) \"/my/folder\"">>, multiline_response } },
+        { { <<"/my/folder">>, [], 10, none}, { <<"GETMETADATA (DEPTH 10) \"/my/folder\"">>, multiline_response } },
+        { { <<"/my/folder">>, [], none, 100 }, { <<"GETMETADATA (MAXSIZE 100) \"/my/folder\"">>, multiline_response } }
     ],
-    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_getmetadata:new(Params))|Acc] end, [], Data).
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_getmetadata:new_command(Params))|Acc] end, [], Data).

erlang-eimap-0.2.tar.gz/test/eimap_command_login_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_login_tests.erl Changed

@@ -38,14 +38,14 @@
           { error, <<"Uh uh uh">> }
         }
     ],
-    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command_login:parse(Response, Tag))|Acc] end, [], Data).
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_login))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         % input, output
-        { { <<"aseigo">>, <<"oohyeah">> }, <<"LOGIN aseigo oohyeah">> },
-        { { "aseigo", "oohyeah" }, <<"LOGIN aseigo oohyeah">> }
+        { { <<"aseigo">>, <<"oohyeah">> }, { <<"LOGIN aseigo oohyeah">>, multiline_response } },
+        { { "aseigo", "oohyeah" }, { <<"LOGIN aseigo oohyeah">>, multiline_response } }
     ],
-    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_login:new(Params))|Acc] end, [], Data).
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_login:new_command(Params))|Acc] end, [], Data).

erlang-eimap-0.2.tar.gz/test/eimap_command_logout_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_logout_tests.erl Changed

@@ -38,15 +38,15 @@
           { close_socket, { error, <<"Uh uh uh">> } }
         }
     ],
-    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command_logout:parse(Response, Tag))|Acc] end, [], Data).
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_logout))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         % input, output
-        { <<>>, <<"LOGOUT">> },
-        { true, <<"LOGOUT">> },
-        { [], <<"LOGOUT">> }
+        { <<>>, { <<"LOGOUT">>, multiline_response } },
+        { true, { <<"LOGOUT">>, multiline_response } },
+        { [], { <<"LOGOUT">>, multiline_response } }
     ],
-    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_logout:new(Params))|Acc] end, [], Data).
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_logout:new_command(Params))|Acc] end, [], Data).

erlang-eimap-0.2.tar.gz/test/eimap_command_namespace_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_namespace_tests.erl Changed

@@ -58,15 +58,15 @@
           { error, <<"Uh uh uh">> }
         }
     ],
-    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command_namespace:parse(Response, Tag))|Acc] end, [], Data).
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_namespace))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         % input, output
-        { <<>>, <<"NAMESPACE">> },
-        { true, <<"NAMESPACE">> },
-        { [], <<"NAMESPACE">> }
+        { <<>>, { <<"NAMESPACE">>, multiline_response } },
+        { true, { <<"NAMESPACE">>, multiline_response } },
+        { [], { <<"NAMESPACE">>, multiline_response } }
     ],
-    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_namespace:new(Params))|Acc] end, [], Data).
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_namespace:new_command(Params))|Acc] end, [], Data).

erlang-eimap-0.2.2.tar.gz/test/eimap_command_noop_tests.erl Added

erlang-eimap-0.2.tar.gz/test/eimap_command_starttls_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_starttls_tests.erl Changed

@@ -38,15 +38,15 @@
           { error, <<"Uh uh uh">> }
         }
     ],
-    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command_starttls:parse(Response, Tag))|Acc] end, [], Data).
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(single_line_response, Response, Tag, eimap_command_starttls))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         % input, output
-        { <<>>, <<"STARTTLS">> },
-        { true, <<"STARTTLS">> },
-        { [], <<"STARTTLS">> }
+        { <<>>, { <<"STARTTLS">>, single_line_response } },
+        { true, { <<"STARTTLS">>, single_line_response } },
+        { [], { <<"STARTTLS">>, single_line_response } }
     ],
-    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_starttls:new(Params))|Acc] end, [], Data).
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_starttls:new_command(Params))|Acc] end, [], Data).

erlang-eimap-0.2.tar.gz/test/eimap_command_status_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_command_status_tests.erl Changed

@@ -38,23 +38,28 @@
           { fini, [{ uidvalidity, 44292 }, { recent, 1 }] }
         }
     ],
-    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command_status:parse(Response, Tag))|Acc] end, [], Data).
+    lists:foldl(fun({ Response, Tag, Parsed }, Acc) -> [?_assertEqual(Parsed, eimap_command:parse_response(multiline_response, Response, Tag, eimap_command_status))|Acc] end, [], Data).
 
 new_test_() ->
     Data =
     [
         % input, output
-        { { "INBOX", [] }, <<"STATUS INBOX (MESSAGES)">> },
-        { { <<"INBOX">>, [] }, <<"STATUS INBOX (MESSAGES)">> },
-        { { <<>>, [messages] }, <<"STATUS INBOX (MESSAGES)">> },
-        { { <<"">>, [messages] }, <<"STATUS INBOX (MESSAGES)">> },
+        { { "INBOX", [] },
+          { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+        { { <<"INBOX">>, [] },
+          { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+        { { <<>>, [messages] },
+          { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
+        { { <<"">>, [messages] },
+          { <<"STATUS INBOX (MESSAGES)">>, multiline_response } },
         { { <<"/my/folder">>, [messages, recent, uidnext, uidvalidity, unseen] },
-           <<"STATUS /my/folder (MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)">> },
+          { <<"STATUS /my/folder (MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)">>, multiline_response } },
         { { <<"/my/folder">>, [uidnext, recent, uidvalidity, unseen] },
-           <<"STATUS /my/folder (UIDNEXT RECENT UIDVALIDITY UNSEEN)">> },
+          { <<"STATUS /my/folder (UIDNEXT RECENT UIDVALIDITY UNSEEN)">>, multiline_response } },
         { { <<"/my/folder">>, [garbage, unseen] },
-           <<"STATUS /my/folder (UNSEEN)">> },
-        { { <<"/my/folder">>, [garbage] }, <<"STATUS /my/folder (MESSAGES)">> }
+          { <<"STATUS /my/folder (UNSEEN)">>, multiline_response } },
+        { { <<"/my/folder">>, [garbage] },
+          { <<"STATUS /my/folder (MESSAGES)">>, multiline_response } }
     ],
-    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_status:new(Params))|Acc] end, [], Data).
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_status:new_command(Params))|Acc] end, [], Data).

erlang-eimap-0.2.2.tar.gz/test/eimap_command_switch_folder_tests.erl Added

@@ -0,0 +1,72 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_switch_folder_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+parse_test_() ->
+    Data =
+    [
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"Trash">>,
+          <<"* 0 EXISTS\r\n* 0 RECENT\r\n* FLAGS (\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)\r\n* OK [PERMANENTFLAGS ()] Ok\r\n* OK [UIDVALIDITY 1447439786] Ok\r\n* OK [UIDNEXT 1] Ok\r\n* OK [HIGHESTMODSEQ 1] Ok\r\n* OK [URLMECH INTERNAL] Ok>\r\n* OK [ANNOTATIONS 65536] Ok\r\nabcd OK [READ-WRITE] SELECT completed\r\n">>,
+          <<"abcd">>,
+          { fini,
+            [
+             { writeable, true },
+             { annotations, 65536 },
+             { url_mech, internal },
+             { highest_mod_seq, 1 },
+             { uid_next, 1 },
+             { uid_validity, 1447439786 },
+             { permanent_flags, [] },
+             { flags, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">>] },
+             { recent, 0 },
+             { exists, 0 }
+            ]
+          }
+        },
+        {
+          <<"Nope">>,
+          <<"abcd BAD Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        },
+        {
+          <<"ALsoWrong">>,
+          <<"abcd NO Uh uh uh\r\n">>,
+          <<"abcd">>,
+          { error, <<"Uh uh uh">> }
+        }
+    ],
+    lists:foldl(fun({ InitArgs, ServerResponse, Tag, Parsed }, Acc) ->
+                        { _Command, ResponseType } = eimap_command_switch_folder:new_command(InitArgs),
+                        [?_assertEqual(Parsed, eimap_command:parse_response(ResponseType, ServerResponse, Tag, eimap_command_switch_folder))|Acc] end, [], Data).
+
+new_test_() ->
+    Data =
+    [
+        % input, output
+        { "Trash", { <<"SELECT \"Trash\"">>, all_multiline_response } },
+        { <<"Trash">>, { <<"SELECT \"Trash\"">>, all_multiline_response } },
+        { { <<"Trash">>, select }, { <<"SELECT \"Trash\"">>, all_multiline_response } },
+        { { <<"Trash">>, examine }, { <<"EXAMINE \"Trash\"">>, all_multiline_response } },
+        { { "Trash", examine }, { <<"EXAMINE \"Trash\"">>, all_multiline_response } }
+    ],
+    lists:foldl(fun({ Params, Command }, Acc) -> [?_assertEqual(Command, eimap_command_switch_folder:new_command(Params))|Acc] end, [], Data).
+

erlang-eimap-0.2.2.tar.gz/test/eimap_command_tests.erl Added

@@ -0,0 +1,65 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap_command_tests).
+-include_lib("eunit/include/eunit.hrl").
+-export([process_line/2, formulate_response/2]).
+
+% c("test/eimap_command_tests.erl"). eunit:test(eimap_command).
+
+process_line(Data, Acc) -> [{ marked, Data } | Acc].
+formulate_response(Result, Data) -> eimap_command:formulate_response(Result, lists:reverse(Data)).
+
+
+literal_continuations_test_() ->
+    Data =
+    [
+        % input, output
+        % { Binary Response, Binary Tag, Parsed Results }
+        {
+          <<"* STATUS 1 (MESSAGES 231 {14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { marked, <<"* STATUS 1 (MESSAGES 231 UIDNEXT 44292)">> } ] }
+        },
+        {
+          <<"* STATUS 1a (MESSAGES 231 {14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation">>,
+          <<"abcd">>,
+          { more, { <<"abcd OK Begin TLS negotiation">>, [ { marked, <<"* STATUS 1a (MESSAGES 231 UIDNEXT 44292)">> } ], ?MODULE } }
+        },
+        {
+          <<"* STATUS 2 (MESSAGES 231 {14}\r\n">>,
+          <<"abcd">>,
+          { more, { <<"* STATUS 2 (MESSAGES 231 {14}">>, [], ?MODULE } }
+        },
+        {
+          <<"* STATUS 3 (MESSAGES 231 {h14}\r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { marked, <<"* STATUS 3 (MESSAGES 231 {h14}">> }, { marked, <<"UIDNEXT 44292)">> } ] }
+        },
+        {
+          <<"* STATUS 4 (MESSAGES 231 \r\nUIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { marked, <<"* STATUS 4 (MESSAGES 231 ">> }, { marked, <<"UIDNEXT 44292)">> } ] }
+        },
+        {
+          <<"* STATUS 5 (MESSAGES 231 UIDNEXT 44292)\r\nabcd OK Begin TLS negotiation now\r\n">>,
+          <<"abcd">>,
+          { fini, [ { marked, <<"* STATUS 5 (MESSAGES 231 UIDNEXT 44292)">> } ] }
+        }
+    ],
+    lists:foldl(fun({ Binary, Tag, Result }, Acc) -> [?_assertEqual(Result, eimap_command:parse_response(multiline_response, Binary, Tag, ?MODULE))|Acc] end, [], Data).
+

erlang-eimap-0.2.tar.gz/test/eimap_uidset_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_uidset_tests.erl Changed

erlang-eimap-0.2.tar.gz/test/eimap_utils_tests.erl -> erlang-eimap-0.2.2.tar.gz/test/eimap_utils_tests.erl Changed

@@ -79,6 +79,7 @@
     Data =
     [
         { { <<>>, <<>>, <<>> }, <<>> },
+        { { <<".">>, <<"LIST">>, <<"\"\" \"*\"">> }, <<". LIST \"\" \"*\"">> },
         { { <<"1">>, <<"STARTTLS">>, <<>> }, <<"1 STARTTLS">> },
         { { <<"1">>, <<"STARTTLS">>, <<>> }, <<"1 STARTTLS\r\n">> },
         { { <<"3">>, <<"ID">>, <<"(\"name\" \"Thunderbird\" \"version\" \"38.3.0\")">> }, <<"3 ID (\"name\" \"Thunderbird\" \"version\" \"38.3.0\")">> }
@@ -104,10 +105,10 @@
     Tag = <<"abcd">>,
     Data =
     [
-       { <<Tag/binary, " Indeed\r\n">>, true },
-       { <<Tag/binary, " Indeed">>, true },
-       { <<"one">>, false },
-       { <<"* Yeah baby">>, false }
+       { <<Tag/binary, " Indeed\r\n">>, tagged },
+       { <<Tag/binary, " Indeed">>, tagged },
+       { <<"one">>, untagged },
+       { <<"* Yeah baby">>, untagged }
     ],
     lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:is_tagged_response(Input, Tag)) | Acc] end, [], Data).
 
@@ -167,3 +168,31 @@
     ],
     lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:only_full_lines(Input)) | Acc] end, [], Data).
 
+parse_flags_test_() ->
+    Data =
+    [
+        { <<"()">>, [] },
+        { <<>>, [] },
+        { <<"\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen">>, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] },
+        { <<"(\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)">>, [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] },
+        { "(\\\\Answered \\\\Flagged \\\\Draft \\\\Deleted \\\\Seen)", [<<"\\\\Answered">>, <<"\\\\Flagged">>, <<"\\\\Draft">>, <<"\\\\Deleted">>, <<"\\\\Seen">> ] }
+    ],
+    lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:parse_flags(Input)) | Acc] end, [], Data).
+
+num_literal_continuation_bytes_test_() ->
+    Data =
+    [
+        { <<"abcd">>, { <<"abcd">>, 0 } },
+        { <<"abcd{5}">>, { <<"abcd">>, 5 } },
+        { <<"abcd{100}">>, { <<"abcd">>, 100 } },
+        { <<"123abcd{100}">>, { <<"123abcd">>, 100  } },
+        { <<"ab{123abcd{100}">>, { <<"ab{123abcd">>, 100  } },
+        { <<"ab{123abcd{1{00}">>, { <<"ab{123abcd{1">>, 0 } },
+        { <<"abcd{aa0}">>, { <<"abcd{aa0}">>, 0 } },
+        { <<"abcd{10aa0}">>, { <<"abcd{10aa0}">>, 0 } },
+        { <<"abcd100}">>, { <<"abcd100}">>, 0 } },
+        { <<"abcd100}">>, { <<"abcd100}">>, 0 } }
+    ],
+    lists:foldl(fun({ Input, Output}, Acc) -> [?_assertEqual(Output, eimap_utils:num_literal_continuation_bytes(Input)) | Acc] end, [], Data).
+
+

erlang-eimap-0.2.tar.gz/src/commands/eimap_command_examine.erl Deleted

@@ -1,33 +0,0 @@
-%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
-%%
-%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
-%%
-%% This program is free software: you can redistribute it and/or modify
-%% it under the terms of the GNU General Public License as published by
-%% the Free Software Foundation, either version 3 of the License, or
-%% (at your option) any later version.
-%%
-%% This program is distributed in the hope that it will be useful,
-%% but WITHOUT ANY WARRANTY; without even the implied warranty of
-%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-%% GNU General Public License for more details.
-%%
-%% You should have received a copy of the GNU General Public License
-%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
--module(eimap_command_examine).
--behavior(eimap_command).
--export([new/1, parse/2]).
-
-%% https://tools.ietf.org/html/rfc3501#section-6.3.2
-
-%% Public API
-new(MBox) when is_binary(MBox) -> <<"EXAMINE \"", MBox/binary, "\"">>.
-
-parse(Data, Tag) ->
-    case eimap_utils:check_response_for_failure(Data, Tag) of
-        ok -> { fini, ok };
-        { _, Reason } -> { error, Reason }
-    end.
-
-%% Private API

erlang-eimap-0.2.tar.gz/src/eimap.hrl Deleted

erlang-eimap.dsc Changed