@@ -5,30 +5,38 @@

 %global realname eimap

 %global debug_package %{nil}

-Name:      erlang-%{realname}

-Version:   0.1.5

-Release:   1%{?dist}

-Summary:   Erlang IMAP client

-Group:     Development/Libraries

-License:   BSD

-URL:       http://git.kolab.org/diffusion/EI/%{realname}.git

+Name:           erlang-%{realname}

+Version:        0.2.4

+Release:        0.20160111.git%{?dist}

+Summary:        Erlang IMAP client

+Group:          Development/Libraries

+License:        GPLv3+

+URL:            http://git.kolab.org/diffusion/EI/%{realname}.git

 %if 0%{?el7}%{?fedora}

-VCS:       scm:git:https://git.kolab.org/diffusion/EI/%{realname}.git

+VCS:            scm:git:https://git.kolab.org/diffusion/EI/%{realname}.git

 %endif

-Source0:   erlang-eimap-%{version}.tar.gz

+Source0:        erlang-eimap-0.2.4.tar.gz

-BuildRequires:  erlang-goldrush >= 0.1.6

-BuildRequires: erlang-lager >= 2.1.0

+Patch0001:      0001-there-is-only-ever-one-response.-be-strict-about-tha.patch

+Patch0002:      0002-the-explicit-capabilities-command-is-multiline-so-it.patch

+Patch0003:      0003-don-t-munge-the-incoming-response.-leave-that-to-the.patch

+

+BuildRequires: erlang-goldrush >= 0.1.7

+BuildRequires: erlang-lager >= 2.2.0

 BuildRequires: erlang-rebar >= 2.5.1

-Requires:  erlang-erts%{?_isa} >= R13B

-Requires:  erlang-stdlib%{?_isa} >= R13B

+Requires:       erlang-erts%{?_isa} >= R13B

+Requires:       erlang-stdlib%{?_isa} >= R13B

 %description

 IMAP client library for Erlang

 %prep

-%setup -q

+%setup -q -n eimap-%{version}

+

+%patch0001 -p1

+%patch0002 -p1

+%patch0003 -p1

 %build

 rebar compile -v

@@ -44,7 +52,6 @@

 install -D -m 644 ebin/%{realname}.app %{buildroot}%{_libdir}/erlang/lib/%{realname}-%{version}/ebin/%{realname}.app

 install -D -m 644 ebin/*.beam %{buildroot}%{_libdir}/erlang/lib/%{realname}-%{version}/ebin/.

-install -D -m 644 src/*.hrl %{buildroot}%{_libdir}/erlang/lib/%{realname}-%{version}/src/

 %files

 %doc README.md

@@ -53,11 +60,11 @@

 %dir %{_libdir}/erlang/lib/%{realname}-%{version}/src/

 %{_libdir}/erlang/lib/%{realname}-%{version}/ebin/%{realname}.app

 %{_libdir}/erlang/lib/%{realname}-%{version}/ebin/*.beam

-%{_libdir}/erlang/lib/%{realname}-%{version}/src/*.hrl

 %changelog

-* Mon Jan  4 2016 Jeroen van Meeuwen <vanmeeuwen@kolabsys.com> - 0.1.5-1

-- Release 0.1.5

-

+* Wed Jun 08 2016 Aaron Seigo <seigo@kolabsystems.com> - 0.2.4-1

+- Packaging of 0.2.4

+* Tue Jun 07 2016 Aaron Seigo <seigo@kolabsystems.com> - 0.2.2-1

+- Packaging of 0.2.2

 * Mon Dec 21 2015 Jeroen van Meeuwen <vanmeeuwen@kolabsys.com> - 0.1.2-1

 - First package

​

@@ -0,0 +1,27 @@

+From 297c7097833f10c70b4b3f928dbc6166282b947b Mon Sep 17 00:00:00 2001

+From: Aaron Seigo <aseigo@kde.org>

+Date: Mon, 20 Jun 2016 16:49:55 +0200

+Subject: [PATCH 1/3] there is only ever one response. be strict about that.

+

+---

+ src/commands/eimap_command_capability.erl | 4 ++--

+ 1 file changed, 2 insertions(+), 2 deletions(-)

+

+diff --git a/src/commands/eimap_command_capability.erl b/src/commands/eimap_command_capability.erl

+index 8f9d12e..a1b50c9 100644

+--- a/src/commands/eimap_command_capability.erl

++++ b/src/commands/eimap_command_capability.erl

+@@ -25,8 +25,8 @@

+ new_command(parse_serverid) -> { <<"CAPABILITY">>, single_line_response };

+ new_command(_Args) -> { <<"CAPABILITY">>, multiline_response }.

+ 

+-process_line(<<"* CAPABILITY ", Data/binary>>, Acc) ->

+-    [Data|Acc];

++process_line(<<"* CAPABILITY ", Data/binary>>, _Acc) ->

++    [Data];

+ process_line(_Data, Acc) -> Acc.

+ 

+ formulate_response(ok, Response) -> { fini, Response };

+-- 

+2.5.5

+

​

@@ -0,0 +1,26 @@

+From ee6185b256058ee5884d01ac16faf30585480fbb Mon Sep 17 00:00:00 2001

+From: Aaron Seigo <aseigo@kde.org>

+Date: Mon, 20 Jun 2016 16:55:01 +0200

+Subject: [PATCH 2/3] the explicit capabilities command is multiline, so it

+ produces a list response

+

+---

+ src/eimap.erl | 2 +-

+ 1 file changed, 1 insertion(+), 1 deletion(-)

+

+diff --git a/src/eimap.erl b/src/eimap.erl

+index 76f02f2..ebf3a02 100644

+--- a/src/eimap.erl

++++ b/src/eimap.erl

+@@ -294,7 +294,7 @@ handle_info({ { connected, Receiver, ResponseToken }, { 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) ->

++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">>;

+-- 

+2.5.5

+

​

@@ -0,0 +1,31 @@

+From bc9d05a44c7ebbfb7bbbcb1006b23d2bb76d8101 Mon Sep 17 00:00:00 2001

+From: Aaron Seigo <aseigo@kde.org>

+Date: Mon, 20 Jun 2016 16:55:28 +0200

+Subject: [PATCH 3/3] don't munge the incoming response. leave that to the

+ application.

+

+---

+ src/eimap.erl | 7 +------

+ 1 file changed, 1 insertion(+), 6 deletions(-)

+

+diff --git a/src/eimap.erl b/src/eimap.erl

+index ebf3a02..b331d1d 100644

+--- a/src/eimap.erl

++++ b/src/eimap.erl

+@@ -295,12 +295,7 @@ handle_info({ { connected, Receiver, ResponseToken }, { Capabilities, ServerID }

+     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),

++    send_hello_string(Capabilities, 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]),

+-- 

+2.5.5

+

​

@@ -0,0 +1,23 @@

+erlang-eimap (0.2.4) unstable; urgency=medium

+

+  * Package the 0.2.4 release

+

+ -- Aaron Seigo <seigo@kolabsystems.com>  Wed, 08 Jun 2016 10:30:50 +0100

+

+erlang-eimap (0.2.2) unstable; urgency=medium

+

+  * Package the 0.2.2 release

+

+ -- Aaron Seigo <seigo@kolabsystems.com>  Tue, 07 Jun 2016 10:30:50 +0100

+

+erlang-eimap (0.2-1+git20160111~kolab1) unstable; urgency=medium

+

+  * Bump to new git version.

+

+ -- Christoph Erhardt <kolab@sicherha.de>  Thu, 11 Feb 2016 21:09:49 +0100

+

+erlang-eimap (0.1.5-1~kolab1) unstable; urgency=medium

+

+  * Initial release.

+

+ -- Christoph Erhardt <kolab@sicherha.de>  Sun, 07 Feb 2016 12:37:53 +0100

​

@@ -0,0 +1,20 @@

+Source: erlang-eimap

+Maintainer: Christoph Erhardt <kolab@sicherha.de>

+Section: devel

+Priority: extra

+Standards-Version: 3.9.6

+Homepage: https://git.kolab.org/diffusion/EI/eimap.git

+Build-Depends: debhelper (>= 9), erlang-goldrush (>= 0.1.7), erlang-lager (>= 2.2.0), rebar (>= 2.5.1)

+

+Package: erlang-eimap

+Architecture: any

+Section: devel

+Priority: extra

+Depends: ${misc:Depends},

+   erlang-base | ${erlang-abi:Depends},

+   erlang-goldrush,

+    erlang-lager,

+   ${erlang:Depends}

+Enhances: erlang

+Description: Erlang IMAP client

+ IMAP client library for Erlang

​

@@ -0,0 +1,19 @@

+#!/usr/bin/make -f

+

+include /usr/share/dpkg/pkg-info.mk

+

+DESTDIR = $(CURDIR)/debian/erlang-eimap

+

+%:

+   dh $@

+

+override_dh_auto_build:

+   rebar compile -v

+

+override_dh_auto_install:

+   mkdir -p $(DESTDIR)/usr/lib/erlang/lib/eimap-$(DEB_VERSION_UPSTREAM)/ebin \

+         $(DESTDIR)/usr/lib/erlang/lib/eimap-$(DEB_VERSION_UPSTREAM)/src

+   install -D -m 644 ebin/eimap.app \

+           $(DESTDIR)/usr/lib/erlang/lib/eimap-$(DEB_VERSION_UPSTREAM)/ebin/eimap.app

+   install -D -m 644 ebin/*.beam \

+           $(DESTDIR)/usr/lib/erlang/lib/eimap-$(DEB_VERSION_UPSTREAM)/ebin/

​

@@ -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

​

@@ -1,2 +0,0 @@

--record(eimap_server_config, { host :: string(), port = 143 :: integer(), tls = false :: boolean() }).

-

​

@@ -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.

​

@@ -1,22 +1,17 @@

 %% -*- tab-width: 4;erlang-indent-level: 4;indent-tabs-mode: nil -*-

 %% ex: ft=erlang ts=4 sw=4 et

-{deps_dir, "deps"}.

 {deps, [

-    { lager, ".*", { git, "https://github.com/basho/lager.git", { tag, "2.1.0" } } }

+    { lager, ".*", { git, "git://github.com/basho/lager.git" } }

    ]}.

-{erl_opts, [ %%no_debug_info,

-            {parse_transform, lager_transform},

-            {platform_define, "(linux|solaris|freebsd|darwin)", 'HAVE_SENDFILE'}

-            ]}.

+{erl_opts, [warnings_as_errors, {parse_transform, lager_transform}]}.

 { erl_first_files, ["src/eimap_command.erl"] }.

 {sub_dirs, [

     "src",

     "rel",

     "tests"

  ]}.

-{erl_opts, [debug_info, fail_on_warning]}.

 {cover_enabled, true}.

 %%{require_otp_vsn, "17"}.

​

@@ -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.

​

@@ -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 }.

+

​

@@ -17,17 +17,16 @@

 -module(eimap_command_compress).

 -behavior(eimap_command).

--export([new/1, parse/2]).

+-export([new_command/1, formulate_response/2]).

 %% http://tools.ietf.org/html/rfc2342

 %% Public API

-new(_Args) -> <<"COMPRESS DEFLATE">>.

+new_command(_Args) -> { <<"COMPRESS DEFLATE">>, single_line_response }.

-parse(Data, Tag) -> formulate_reponse(eimap_utils:check_response_for_failure(Data, Tag)).

-

-

-%% Private API

-formulate_reponse(ok) -> compression_active;

-formulate_reponse({ _, Reason }) -> { error, Reason }.

+formulate_response(Data, Tag) ->

+    case eimap_utils:check_response_for_failure(Data, Tag) of

+        ok -> compression_active;

+        { _, Reason } -> { error, Reason }

+    end.

​

@@ -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, ")">>;

​

@@ -17,19 +17,19 @@

 -module(eimap_command_login).

 -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({ User, Password }) ->

+new_command({ User, Password }) ->

     UserBin = eimap_utils:ensure_binary(User),

     PasswordBin = eimap_utils:ensure_binary(Password),

-    <<"LOGIN ", UserBin/binary, " ", PasswordBin/binary>>.

+    { <<"LOGIN ", UserBin/binary, " ", PasswordBin/binary>>, multiline_response }.

-parse(Data, Tag) -> formulate_reponse(eimap_utils:check_response_for_failure(Data, Tag)).

+process_line(_Data, Acc) -> Acc.

 %% Private API

-formulate_reponse(ok) -> { fini, authed };

-formulate_reponse({ _, Reason }) -> { error, Reason }.

+formulate_response(ok, _Acc) -> { fini, authed };

+formulate_response({ _, Reason }, _Acc) -> { error, Reason }.

​

@@ -17,17 +17,13 @@

 -module(eimap_command_logout).

 -behavior(eimap_command).

--export([new/1, parse/2]).

-

-%% http://tools.ietf.org/html/rfc2342

+-export([new_command/1, process_line/2, formulate_response/2]).

 %% Public API

-new(_Args) -> <<"LOGOUT">>.

-

-parse(Data, Tag) -> formulate_reponse(eimap_utils:check_response_for_failure(Data, Tag)).

+new_command(_Args) -> { <<"LOGOUT">>, multiline_response }.

+process_line(_Data, Acc) -> Acc.

-%% Private API

-formulate_reponse(ok) -> { close_socket, ok };

-formulate_reponse({ _, Reason }) -> { close_socket, { error, Reason } }.

+formulate_response(ok, _Data) -> { close_socket, ok };

+formulate_response({ _, Reason }, _Data) -> { close_socket, { error, Reason } }.

​

@@ -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) ->

​

@@ -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).

+

​

@@ -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).

​

@@ -17,17 +17,16 @@

 -module(eimap_command_starttls).

 -behavior(eimap_command).

--export([new/1, parse/2]).

+-export([new_command/1, formulate_response/2]).

 %% http://tools.ietf.org/html/rfc2342

 %% Public API

-new(_Args) -> <<"STARTTLS">>.

+new_command(_Args) -> { <<"STARTTLS">>, single_line_response }.

-parse(Data, Tag) -> formulate_reponse(eimap_utils:check_response_for_failure(Data, Tag)).

-

-

-%% Private API

-formulate_reponse(ok) -> starttls;

-formulate_reponse({ _, Reason }) -> { error, Reason }.

+formulate_response(Data, Tag) ->

+    case eimap_utils:check_response_for_failure(Data, Tag) of

+        ok -> starttls;

+        { _, Reason } -> { error, Reason }

+    end.

​

@@ -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) ->

​

@@ -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.

+

​

@@ -2,7 +2,7 @@

 {application, eimap,

  [

   { description, "IMAP client implementation" },

-  { vsn, "0.1.5" },

+  { vsn, "0.2.4" },

   { registered, [] },

   { applications, [

                    kernel,

​

@@ -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 }).

+                 inflator, deflator, process_command_queue_guard = false }).

+-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) }.

@@ -182,19 +159,19 @@