Kolab Groupware OBS

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 6

debian.tar.gz/.erlang Added

debian.tar.gz/.gitignore Added

debian.tar.gz/Makefile Added

debian.tar.gz/README.md Added

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

debian.tar.gz/compat Deleted

debian.tar.gz/copyright Deleted

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

debian.tar.gz/rebar Added

debian.tar.gz/rebar.config Added

debian.tar.gz/source Deleted

debian.tar.gz/source/format Deleted

debian.tar.gz/src Added

debian.tar.gz/src/commands Added

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,479 @@
+%% Copyright 2014 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Aaron Seigo (Kolab Systems) <seigo a kolabsys.com>
+%%
+%% This program is free software: you can redistribute it and/or modify
+%% it under the terms of the GNU General Public License as published by
+%% the Free Software Foundation, either version 3 of the License, or
+%% (at your option) any later version.
+%%
+%% This program is distributed in the hope that it will be useful,
+%% but WITHOUT ANY WARRANTY; without even the implied warranty of
+%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%% GNU General Public License for more details.
+%%
+%% You should have received a copy of the GNU General Public License
+%% along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(eimap).
+-behaviour(gen_fsm).
+
+%% API
+-export([start_link/1,
+         %% passthrough mode, where data is just sent to the server blindly and
+         %% responses passed back equally blindly. in this mode the user is on
+         %% their own and better know what they are doing. can only be activated
+         %% when disconnected or idle
+         start_passthrough/2, stop_passthrough/1, passthrough_data/2,
+         %% connection management
+         connect/1, connect/3, disconnect/1,
+         %% commands
+         starttls/3,
+         capabilities/3,
+         login/5, logout/3,
+         compress/1,
+         get_server_metadata/4, get_server_metadata/6,
+         get_folder_status/5,
+         get_folder_metadata/5, get_folder_metadata/7,
+         get_folder_annotations/4,
+         peek_message_headers_and_body/5,
+         get_path_tokens/3,
+         noop/3]).
+
+%% gen_fsm callbacks
+-export([disconnected/2, idle/2, passthrough/2, wait_response/2, startingtls/2]).
+-export([init/1, handle_event/3, handle_sync_event/4, handle_info/3, terminate/3, code_change/4]).
+
+%% state record definition
+-record(state, { host, port, tls, tls_state = false, socket, server_id = <<>>,
+                 command_serial = 1, command_queue = queue:new(),
+                 current_command, current_mbox,
+                 passthrough = false, passthrough_recv, passthrough_send_buffer = <<>>,
+                 inflator, deflator}).
+-record(command, { tag, mbox, message, from, response_type, response_token, parse_state }).
+
+-define(SSL_UPGRADE_TIMEOUT, 5000).
+-define(TCP_CONNECT_TIMEOUT, 5000).
+
+%% public API
+start_link(Options) when is_list(Options) -> gen_fsm:start_link(?MODULE, Options, []).
+
+start_passthrough(PID, Receiver) when is_pid(Receiver)  -> gen_fsm:send_all_state_event(PID, { start_passthrough, Receiver } ).
+stop_passthrough(PID) -> gen_fsm:send_all_state_event(PID, stop_passthrough).
+passthrough_data(PID, Data) when is_binary(Data) -> gen_fsm:send_all_state_event(PID, { passthrough, Data }).
+connect(PID) -> connect(PID, undefined, undefined).
+connect(PID, From, ResponseToken) -> gen_fsm:send_all_state_event(PID, { connect, From, ResponseToken }).
+disconnect(PID) -> gen_fsm:send_all_state_event(PID, disconnect).
+
+-spec compress(EImap :: pid()) -> ok.
+compress(EImap) when is_pid(EImap) ->
+    send_command_to_queue(EImap, EImap, compress, eimap_command_compress, ok).
+
+-spec starttls(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+starttls(EImap, From, ResponseToken) when is_pid(EImap) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_starttls, ok).
+
+-spec capabilities(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+capabilities(EImap, From, ResponseToken) when is_pid(EImap) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_capability, ok).
+
+-spec login(EImap :: pid(), From :: pid(), ResponseToken :: any(), User :: list() | binary(), Pass :: list() | binary()) -> ok.
+login(EImap, From, ResponseToken, User, Pass) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_login, { User, Pass }).
+
+-spec logout(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+logout(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_logout, ok).
+
+-type status_property() :: messages | recent | uidnext | uidvalidity | unseen.
+-type status_properties() :: [status_property()].
+-spec get_folder_status(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: status_properties()) -> ok.
+get_folder_status(EImap, From, ResponseToken, Folder, Properties) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_status, { Folder, Properties }).
+
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()]) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties) ->
+    get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, infinity, nomax).
+
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, Depth, MaxSize) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { Folder, Properties, Depth, MaxSize }).
+
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()]) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, infinity, nomax }).
+
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties, Depth, MaxSize) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, Depth, MaxSize }).
+
+-spec get_folder_annotations(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()]) -> ok.
+get_folder_annotations(EImap, From, ResponseToken, Folder) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_annotation, Folder).
+
+-spec peek_message_headers_and_body(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()], MessageID :: [integer() | binary()]) -> ok.
+peek_message_headers_and_body(EImap, From, ResponseToken, Folder, MessageID) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_peek_message, MessageID, Folder).
+
+-spec get_path_tokens(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+get_path_tokens(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_namespace, ok).
+
+-spec noop(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+noop(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_noop, ok).
+
+
+%% gen_server API
+init(Options) ->
+    Host = proplists:get_value(host, Options, "127.0.0.1"),
+    Port = proplists:get_value(port, Options, 143),
+    TLS = proplists:get_value(tls, Options, false),
+    State = #state { host = Host, port = Port, tls  = TLS },
+    { ok, disconnected, State }.
+
+disconnected({ connect, Receiver, ResponseToken }, #state{ command_queue = CommandQueue, host = Host, port = Port, tls = TLS, socket = undefined } = State) ->
+    %lager:debug("CONNECTING! ~p ~p", [Receiver, ResponseToken]),
+    { {ok, Socket}, TlsState, SendCapabilitiesTo, NewCommandQueue } = create_socket(Host, Port, TLS, Receiver, ResponseToken, CommandQueue),
+    { Message, ResponseType } = eimap_command_capability:new_command(parse_serverid),
+    Command = #command{ message = Message, response_type = ResponseType,
+                        from = SendCapabilitiesTo, response_token = { connected, Receiver, ResponseToken },
+                        parse_state = eimap_command_capability },
+    { next_state, wait_response, State#state { socket = Socket, tls_state = TlsState, current_command = Command, command_queue = NewCommandQueue } };
+disconnected(Command, State) when is_record(Command, command) ->
+    { next_state, disconnected, enque_command(Command, State) }.
+
+passthrough(flush_passthrough_buffer, #state{ passthrough_send_buffer = Buffer } = State) ->
+    %lager:info("Passing through ~p", [Buffer]),
+    passthrough({ passthrough, Buffer }, State#state{ passthrough_send_buffer = <<>> });
+passthrough({ passthrough, Data }, #state{ socket = Socket, tls_state = true } = State) ->
+    %lager:info("Passing through ssl \"~s\"", [Data]),
+    ssl:send(Socket, deflated(Data, State)),
+    { next_state, passthrough, State };
+passthrough({ passthrough, Data }, #state{ socket = Socket } = State) ->
+    %lager:info("Passing through tcp \"~s\"", [Data]),
+    gen_tcp:send(Socket, deflated(Data, State)),
+    { next_state, passthrough, State };
+passthrough({ data, Data }, #state{ passthrough_recv = Receiver } = State) ->
+    %lager:info("Passing back ~p", [Data]),
+    Receiver ! { imap_server_response, Data },
+    { next_state, passthrough, State };
+passthrough(Command, State) when is_record(Command, command) ->
+    gen_fsm:send_event(self(), process_command_queue),
+    { next_state, idle, enque_command(Command, State) }.
+
+idle(process_command_queue, #state{ command_queue = Queue } = State) ->
+    case queue:out(Queue) of
+       { { value, Command }, ModifiedQueue } when is_record(Command, command) ->
+            %lager:info("Clearing queue of ~p", [Command]),
+            NewState = send_command(Command, State#state{ command_queue = ModifiedQueue }),
+            { next_state, wait_response, NewState };
+       { empty, ModifiedQueue } ->
+            NextState = next_state_after_emptied_queue(State),
+            %lager:info("Queue was empty moving on to ... ~p", [NextState]),
+            { next_state, NextState, State#state{ command_queue = ModifiedQueue } }
+    end;
+idle({ data, _Data }, State) ->
+    %%lager:info("Idling, server sent: ~p", [_Data]),
+    { next_state, idle, State };
+idle(Command, State) when is_record(Command, command) ->
+    %%lager:info("Idling"),
+    NewState = send_command(Command, State),
+    { next_state, wait_response, NewState };
+idle(_Event, State) ->
+    { next_state, idle, State }.
+
+next_state_after_emptied_queue(#state{ passthrough = true }) ->
+    gen_fsm:send_event(self(), flush_passthrough_buffer),
+    passthrough;
+next_state_after_emptied_queue(_State) ->
+    idle.
+
+
+%%TODO a variant that checks "#command{ from = undefined }" to avoid parsing responses which will go undelivered?
+wait_response(Command, State) when is_record(Command, command) ->
+    { next_state, wait_response, enque_command(Command, State) };
+wait_response({ data, _Data }, #state{ current_command = #command{ parse_state = undefined } } = State) ->
+    gen_fsm:send_event(self(), process_command_queue),
+    { next_state, idle, State };
+wait_response({ data, Data }, #state{ current_command = #command{ response_type = ResponseType, parse_state = CommandState , tag = Tag } } = State) ->

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

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

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

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

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

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

debian.tar.gz/test Added

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -17,7 +17,6 @@
 
 -module(eimap).
 -behaviour(gen_fsm).
--include("eimap.hrl").
 
 %% API
 -export([start_link/1,
@@ -33,12 +32,13 @@
          capabilities/3,
          login/5, logout/3,
          compress/1,
-         get_server_metadata/4,
+         get_server_metadata/4, get_server_metadata/6,
          get_folder_status/5,
-         get_folder_metadata/5,
+         get_folder_metadata/5, get_folder_metadata/7,
          get_folder_annotations/4,
-         get_message_headers_and_body/5,
-         get_path_tokens/3]).
+         peek_message_headers_and_body/5,
+         get_path_tokens/3,
+         noop/3]).
 
 %% gen_fsm callbacks
 -export([disconnected/2, idle/2, passthrough/2, wait_response/2, startingtls/2]).
@@ -47,26 +47,16 @@
 %% state record definition
 -record(state, { host, port, tls, tls_state = false, socket, server_id = <<>>,
                  command_serial = 1, command_queue = queue:new(),
-                 current_command, current_mbox, parse_state,
+                 current_command, current_mbox,
                  passthrough = false, passthrough_recv, passthrough_send_buffer = <<>>,
                  inflator, deflator}).
--record(command, { tag, mbox, message, from, response_token, parse_fun }).
+-record(command, { tag, mbox, message, from, response_type, response_token, parse_state }).
 
 -define(SSL_UPGRADE_TIMEOUT, 5000).
 -define(TCP_CONNECT_TIMEOUT, 5000).
 
--export([test/0]).
-test() ->
-    ServerConfig = #eimap_server_config{ host = "192.168.56.101", port = 143, tls = false },
-    { ok, Conn } = start_link(ServerConfig),
-    login(Conn, self(), undefined, "doe", "doe"),
-    get_folder_metadata(Conn, self(), undefined, "*", ["/shared/vendor/kolab/folder-type"]),
-    logout(Conn, self(), undefined),
-    connect(Conn).
-
-
 %% public API
-start_link(ServerConfig) when is_record(ServerConfig, eimap_server_config) -> gen_fsm:start_link(?MODULE, ServerConfig, []).
+start_link(Options) when is_list(Options) -> gen_fsm:start_link(?MODULE, Options, []).
 
 start_passthrough(PID, Receiver) when is_pid(Receiver)  -> gen_fsm:send_all_state_event(PID, { start_passthrough, Receiver } ).
 stop_passthrough(PID) -> gen_fsm:send_all_state_event(PID, stop_passthrough).
@@ -75,93 +65,80 @@
 connect(PID, From, ResponseToken) -> gen_fsm:send_all_state_event(PID, { connect, From, ResponseToken }).
 disconnect(PID) -> gen_fsm:send_all_state_event(PID, disconnect).
 
-compress(PID) when is_pid(PID) ->
-    Command = #command{ message = eimap_command_compress:new(ok),
-                        from = PID, response_token = compress,
-                        parse_fun = fun eimap_command_compress:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec compress(EImap :: pid()) -> ok.
+compress(EImap) when is_pid(EImap) ->
+    send_command_to_queue(EImap, EImap, compress, eimap_command_compress, ok).
 
-starttls(PID, From, ResponseToken) when is_pid(PID) ->
-    Command = #command{ message = eimap_command_starttls:new(ok),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_starttls:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec starttls(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+starttls(EImap, From, ResponseToken) when is_pid(EImap) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_starttls, ok).
 
-capabilities(PID, From, ResponseToken) when is_pid(PID) ->
-    Command = #command{ message = eimap_command_capability:new(noparams),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_capability:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec capabilities(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+capabilities(EImap, From, ResponseToken) when is_pid(EImap) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_capability, ok).
 
--spec login(PID :: pid(), From :: pid(), ResponseToken :: any(), User :: list() | binary(), Pass :: list() | binary()) -> ok.
-login(PID, From, ResponseToken, User, Pass) ->
-    Command = #command{ message = eimap_command_login:new({ User, Pass }),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_login:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec login(EImap :: pid(), From :: pid(), ResponseToken :: any(), User :: list() | binary(), Pass :: list() | binary()) -> ok.
+login(EImap, From, ResponseToken, User, Pass) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_login, { User, Pass }).
 
--spec logout(PID :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
-logout(PID, From, ResponseToken) ->
-    Command = #command{ message = eimap_command_logout:new(ok),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_logout:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec logout(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+logout(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_logout, ok).
 
 -type status_property() :: messages | recent | uidnext | uidvalidity | unseen.
 -type status_properties() :: [status_property()].
--spec get_folder_status(PID :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: status_properties()) -> ok.
-get_folder_status(PID, From, ResponseToken, Folder, Properties) ->
-    Command = #command{ message = eimap_command_status:new({ Folder, Properties }),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_status:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_folder_status(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: status_properties()) -> ok.
+get_folder_status(EImap, From, ResponseToken, Folder, Properties) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_status, { Folder, Properties }).
 
--spec get_folder_metadata(PID :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()]) -> ok.
-get_folder_metadata(PID, From, ResponseToken, Folder, Properties) ->
-    Command = #command{ message = eimap_command_getmetadata:new({ Folder, Properties}),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_getmetadata:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()]) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties) ->
+    get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, infinity, nomax).
 
--spec get_server_metadata(PID :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()]) -> ok.
-get_server_metadata(PID, From, ResponseToken, Properties) ->
-    Command = #command{ message = eimap_command_getmetadata:new({ <<>>, Properties}),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_getmetadata:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_folder_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: list() | binary(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_folder_metadata(EImap, From, ResponseToken, Folder, Properties, Depth, MaxSize) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { Folder, Properties, Depth, MaxSize }).
 
-get_folder_annotations(PID, From, ResponseToken, Folder) when is_list(Folder) ->
-    get_folder_annotations(PID, From, ResponseToken, list_to_binary(Folder));
-get_folder_annotations(PID, From, ResponseToken, Folder) when is_binary(Folder) ->
-    Command = #command{ message = eimap_command_annotation:new(Folder),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_annotation:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()]) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, infinity, nomax }).
 
-get_message_headers_and_body(PID, From, ResponseToken, Folder, MessageID) ->
-    %%lager:info("SELECT_DEBUG: peeking message ~p ~p", [Folder, MessageID]),
-    Command = #command{ mbox = Folder, message = eimap_command_peek_message:new(MessageID),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_peek_message:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
+-spec get_server_metadata(EImap :: pid(), From :: pid(), ResponseToken :: any(), Properties:: [list() | binary()], Depth :: infinity | integer(), MaxSize :: nomax | integer()) -> ok.
+get_server_metadata(EImap, From, ResponseToken, Properties, Depth, MaxSize) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_getmetadata, { <<>>, Properties, Depth, MaxSize }).
+
+-spec get_folder_annotations(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()]) -> ok.
+get_folder_annotations(EImap, From, ResponseToken, Folder) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_annotation, Folder).
+
+-spec peek_message_headers_and_body(EImap :: pid(), From :: pid(), ResponseToken :: any(), Folder :: [list() | binary()], MessageID :: [integer() | binary()]) -> ok.
+peek_message_headers_and_body(EImap, From, ResponseToken, Folder, MessageID) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_peek_message, MessageID, Folder).
+
+-spec get_path_tokens(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+get_path_tokens(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_namespace, ok).
+
+-spec noop(EImap :: pid(), From :: pid(), ResponseToken :: any()) -> ok.
+noop(EImap, From, ResponseToken) ->
+    send_command_to_queue(EImap, From, ResponseToken, eimap_command_noop, ok).
 
-get_path_tokens(PID, From, ResponseToken) ->
-    Command = #command{ message = eimap_command_namespace:new([]),
-                        from = From, response_token = ResponseToken,
-                        parse_fun = fun eimap_command_namespace:parse/2 },
-    gen_fsm:send_all_state_event(PID, { ready_command, Command }).
 
 %% gen_server API
-init(#eimap_server_config{ host = Host, port = Port, tls = TLS }) ->
+init(Options) ->
+    Host = proplists:get_value(host, Options, "127.0.0.1"),
+    Port = proplists:get_value(port, Options, 143),
+    TLS = proplists:get_value(tls, Options, false),
     State = #state { host = Host, port = Port, tls  = TLS },
     { ok, disconnected, State }.
 
 disconnected({ connect, Receiver, ResponseToken }, #state{ command_queue = CommandQueue, host = Host, port = Port, tls = TLS, socket = undefined } = State) ->
     %lager:debug("CONNECTING! ~p ~p", [Receiver, ResponseToken]),
     { {ok, Socket}, TlsState, SendCapabilitiesTo, NewCommandQueue } = create_socket(Host, Port, TLS, Receiver, ResponseToken, CommandQueue),
-    Command = #command{ message = eimap_command_capability:new([]),
+    { Message, ResponseType } = eimap_command_capability:new_command(parse_serverid),
+    Command = #command{ message = Message, response_type = ResponseType,
                         from = SendCapabilitiesTo, response_token = { connected, Receiver, ResponseToken },
-                        parse_fun = fun eimap_command_capability:parse/2 },
+                        parse_state = eimap_command_capability },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

erlang-eimap.dsc Changed