Request 1698 (accepted)

Overview

Request 1698 (accepted)

Submit erlang-eimap

Created by vanmeeuwen over 8 years ago
In state accepted

Submit erlang-eimap

Submit package Kolab:Winterfell / erlang-eimap to package Kolab:16 / erlang-eimap

erlang-eimap.spec Changed

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

0001-there-is-only-ever-one-response.-be-strict-about-tha.patch Added

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

0002-the-explicit-capabilities-command-is-multiline-so-it.patch Added

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

0003-don-t-munge-the-incoming-response.-leave-that-to-the.patch Added

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

debian.changelog Added

debian.control Added

debian.rules Added

debian.tar.gz Added

erlang-eimap-0.1.5.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.1.5.tar.gz/src/eimap.hrl Deleted

erlang-eimap-0.1.5.tar.gz/README.md -> erlang-eimap-0.2.4.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.1.5.tar.gz/rebar.config -> erlang-eimap-0.2.4.tar.gz/rebar.config Changed

erlang-eimap-0.1.5.tar.gz/src/commands/eimap_command_annotation.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/src/commands/eimap_command_capability.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/src/commands/eimap_command_compress.erl -> erlang-eimap-0.2.4.tar.gz/src/commands/eimap_command_compress.erl Changed

erlang-eimap-0.1.5.tar.gz/src/commands/eimap_command_getmetadata.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/src/commands/eimap_command_login.erl -> erlang-eimap-0.2.4.tar.gz/src/commands/eimap_command_login.erl Changed

erlang-eimap-0.1.5.tar.gz/src/commands/eimap_command_logout.erl -> erlang-eimap-0.2.4.tar.gz/src/commands/eimap_command_logout.erl Changed

erlang-eimap-0.1.5.tar.gz/src/commands/eimap_command_namespace.erl -> erlang-eimap-0.2.4.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.4.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).
+

erlang-eimap-0.1.5.tar.gz/src/commands/eimap_command_peek_message.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/src/commands/eimap_command_starttls.erl -> erlang-eimap-0.2.4.tar.gz/src/commands/eimap_command_starttls.erl Changed

erlang-eimap-0.1.5.tar.gz/src/commands/eimap_command_status.erl -> erlang-eimap-0.2.4.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.4.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.
+

erlang-eimap-0.1.5.tar.gz/src/eimap.app.src -> erlang-eimap-0.2.4.tar.gz/src/eimap.app.src Changed

erlang-eimap-0.1.5.tar.gz/src/eimap.erl -> erlang-eimap-0.2.4.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 }).
+                 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 @@
     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) }.
+    NewState = ensure_process_command_queue(State),
+    { next_state, idle, enque_command(Command, NewState) }.
 
 idle(process_command_queue, #state{ command_queue = Queue } = State) ->
+    UnguardedState = State#state{ process_command_queue_guard = false },
     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 }),
+            NewState = send_command(Command, UnguardedState#state{ command_queue = ModifiedQueue }),
             { next_state, wait_response, NewState };
-       { empty, ModifiedQueue } ->
+       { 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 } }
+            { next_state, NextState, UnguardedState }
     end;
 idle({ data, _Data }, State) ->
     %%lager:info("Idling, server sent: ~p", [_Data]),
@@ -204,7 +181,8 @@
     NewState = send_command(Command, State),
     { next_state, wait_response, NewState };
 idle(_Event, State) ->
-    { next_state, idle, State }.
+    { next_state, idle, ensure_process_command_queue(State) }.
+
 
 next_state_after_emptied_queue(#state{ passthrough = true }) ->
     gen_fsm:send_event(self(), flush_passthrough_buffer),
@@ -212,19 +190,22 @@
 next_state_after_emptied_queue(_State) ->
     idle.
 
+ensure_process_command_queue(State) ->
+    case State#state.process_command_queue_guard of
+        true ->
+            State;
+        _ ->
+            gen_fsm:send_event(self(), process_command_queue),
+            State#state{ process_command_queue_guard = true }
+    end.
 
 %%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) ->
-    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{ parse_state = undefined } } = State) ->
+    { next_state, idle, ensure_process_command_queue(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) ->
@@ -235,8 +216,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,27 +230,26 @@
 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
+    { NextStateName, NewState } = case StateName of
+                    passthrough -> { idle, ensure_process_command_queue(State) };
+                    StateName -> { StateName, 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);
+    { next_state, NextStateName, NewState#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>>,
+    NewState =
     case StateName of
-        idle -> gen_fsm:send_event(self(), process_command_queue);
-        _ -> ok
+        idle -> ensure_process_command_queue(State);
+        _ -> State
     end,
-    { next_state, StateName, State#state{ passthrough_send_buffer = NewBuffer } };
+    { next_state, StateName, NewState#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}.
@@ -287,13 +267,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 +293,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 +321,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 +351,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 } };
+    NewState = ensure_process_command_queue(State),
+    { next_state, idle, NewState#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 } };
+    NewState = ensure_process_command_queue(State),
+    { next_state, idle, NewState#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 } };
+    NewState = ensure_process_command_queue(State),
+    { next_state, idle, NewState#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 } };
+    NewState = ensure_process_command_queue(State),
+    { next_state, idle, NewState#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 +386,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 +440,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.1.5.tar.gz/src/eimap_command.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/src/eimap_uidset.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/src/eimap_utils.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/test/eimap_command_annotation_tests.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/test/eimap_command_capability_tests.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/test/eimap_command_compress_tests.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/test/eimap_command_getmetadata_tests.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/test/eimap_command_login_tests.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/test/eimap_command_logout_tests.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/test/eimap_command_namespace_tests.erl -> erlang-eimap-0.2.4.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.4.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).
+

erlang-eimap-0.1.5.tar.gz/test/eimap_command_starttls_tests.erl -> erlang-eimap-0.2.4.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.1.5.tar.gz/test/eimap_command_status_tests.erl -> erlang-eimap-0.2.4.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.4.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.4.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.1.5.tar.gz/test/eimap_uidset_tests.erl -> erlang-eimap-0.2.4.tar.gz/test/eimap_uidset_tests.erl Changed

erlang-eimap-0.1.5.tar.gz/test/eimap_utils_tests.erl -> erlang-eimap-0.2.4.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.dsc Added

repack.sh Deleted

Build Results
RPM Lint

Refresh

Comments for request 1698 0

Request History

vanmeeuwen created request over 8 years ago

Submit erlang-eimap

vanmeeuwen accepted review over 8 years ago

vanmeeuwen approved review over 8 years ago

vanmeeuwen accepted request over 8 years ago