LISTING

The following methods can be used on an account to list mailboxes in a folder of an account:

list_all(folder)

Lists all the available mailboxes in the folder (string), and returns a table that contains strings, the available mailboxes, and a table that contains strings, the available folders.

list_subscribed(folder)

Lists all the subscribed mailboxes in the folder (string), and returns a table that contains strings, the subscribed mailboxes, and a table that contains strings, the subscribed folders.

The following methods can be used on an account to list mailboxes, using wildcards, in a folder of an account. The ‘*’ wildcard, matches any character and the ‘%’ matches any character except the folder delimiter, ie. non-recursively:

list_all(folder, mailbox)

Lists all the available mailboxes in the folder (string) with the name mailbox (string), and returns a table that contains strings, the available mailboxes, and a table that contains strings, the available folders. Wildcards may only be used in the mailbox argument.

list_subscribed(folder, mailbox)

Lists all the subscribed mailboxes in the folder (string) with the name mailbox (string), and returns a table that contains strings, the subscribed mailboxes, and a table that contains strings, the subscribed folders. Wildcards may only be used in the mailbox argument.

Examples:

mailboxes, folders = myaccount:list_subscribed('myfolder')
mailboxes, folders = myaccount:list_all('myfolder/mysubfolder', '*')

MANIPULATING

The following methods can be used to manipulate mailboxes in an account:

create_mailbox(name)

Creates the name (string) mailbox.

delete_mailbox(name)

Deletes the name (string) mailbox.

rename_mailbox(oldname, newname)

Renames the oldname (string) mailbox to newname (string).

subscribe_mailbox(name)

Subscribes the name (string) mailbox.

unsubscribe_mailbox(name)

Unsubscribes the name (string) mailbox.

Examples:

myaccount:create_mailbox('mymailbox')
myaccount:subscribe_mailbox('mymailbox')
myaccount:unsubscribe_mailbox('myfolder/mymailbox')
myaccount:delete_mailbox('myfolder/mymailbox')

CHECKING

The following methods can be used to check the status of a mailbox:

check_status()

The check_status() method gets the current status of a mailbox, and returns four values of number type: the total number of messages, the number of recent messages, the number of unseen messages in the mailbox, and the next UID to be assigned to a new message in the mailbox.

enter_idle()

The enter_idle() method implements the IMAP IDLE (RFC 2177) extension. By using this extension it's not necessary to poll the server for changes to the selected mailbox (ie. using the check_status() method), but instead the server sends an update when there is a change in the mailbox (eg. in case of new mail). When the enter_idle() method has been called no more commands in the configuration file are executed until an update is received, at which point the enter_idle() method returns. For the enter_idle() to work, the IDLE extension has to be supported by the IMAP server.

The enter_idle() method returns a value of type boolean: “true” if the IDLE extension is supported and there was a update in the mailbox, and “false” if the IDLE extension is not supported, in which case the method returns immediately. When the aforementioned return value was “true”, an additional second value of type string is also returned, indicating the event received from the server, which is useful when the wakeonany option has been enabled.

Apart from an event received by the server, the SIGUSR1 or SIGUSR2 signals can also interrupt the IDLE mode at any time, and the execution of the configuration file will then continue from the next line after the enter_idle(). In this case only the value “true” is returned.

Examples:

exist, unread, unseen, uidnext = myaccount.mymailbox:check_status()
update = myaccount.mymailbox:enter_idle()
update, event = myaccount.mymailbox:enter_idle()

SEARCHING

The searching methods in this subsection can be applied to any mailbox. They return a special form of table, that contains the messages that match the searching method. This table can be combined with other tables using logic theory. There are three available operations, that implement logical “or”, logical “and” and logical “not”.

The logical “or” is implemented using the ‘+’ operator:

results = myaccount.mymailbox:is_unseen() +
          myaccount.mymailbox:is_larger(100000)

The logical “and” is implemented using the ‘*’ operator:

results = myaccount.mymailbox:is_unseen() *
          myaccount.mymailbox:is_larger(100000)

The logical “not” is implemented using the ‘-’ operator:

results = myaccount.mymailbox:is_unseen() -
          myaccount.mymailbox:is_larger(100000)

The three logical operators can be combined in the same expression. The logical “and” has higher precedence than the logical “or” and the logical “not”, with the latter two having the same precedence, and parentheses may be used to change this behaviour:

results = myaccount.mymailbox:is_unseen() +
          myaccount.mymailbox:is_larger(100000) *
          myaccount.mymailbox:contain_subject('test')

results = ( myaccount.mymailbox:is_unseen() +
            myaccount.mymailbox:is_larger(100000) ) *
            myaccount.mymailbox:contain_subject('test')

The returned tables of the searching methods can also be stored in variables and then further processed:

unseen = myaccount.myaccount:is_unseen()
larger = myaccount.mymailbox:is_larger(100000)
subject = myaccount.mymailbox:contain_subject('test')
results = unseen + larger * subject

A composite filter that includes one or more simple rules can be defined:

myfilter = function ()
	       return myaccount.mymailbox:is_unseen() +
	              myaccount.mymailbox:is_larger(100000) *
                      myaccount.mymailbox:contain_subject('test')
           end

results = myfilter()

Composite filters can may be more dynamic by adding arguments:

myfilter = function (mailbox, size, subject)
	       return mailbox:is_unseen() +
                      mailbox:is_larger(size) *
                      mailbox:contain_subject(subject)
           end

results = myfilter(myaccount.mailbox, 100000, 'test')

It is also possible to combine the searching methods in different mailboxes, either at the same or different accounts, for example when the same actions will be executed on messages residing in different mailboxes or accounts.

results = myaccount.mymailbox:is_unseen() +
	  myaccount.myothermailbox:is_larger(100000) +
	  myotheraccount.myothermailbox:contain_subject('test')

And for those that want to know more about the return values of the following methods, it is a table which contains tables with two values: the mailbox (table) the message belongs to, and the message UID (number) which points to the matching message. For examples on iterating these returned tables, or creating new tables of this format (they are actually metatables implementing sets), see the samples/extend.lua file.

{
    { <myaccount.mymailbox>, 1 },
    { <myaccount.mymailbox>, 3 },
    { <myaccount.myothermailbox>, 5 },
    { <myothermailbox.myothermailbox>, 7},
    { ... },
    ...
}

The following method can be used to get all messages in a mailbox:

select_all()

All messages.

The following methods can be used to search for messages that are in a specific state:

is_answered()

Messages that have been answered.

is_deleted()

Messages that are marked for later removal.

is_draft()

Messages that have not completed composition.

is_flagged()

Messages that are flagged for urgent/special attention.

is_new()

Messages that are recently arrived (this session is the first to have been notified about these messages) and have not been read.

is_old()

Messages that are not recently arrived (this session is not the first to have been notified about these messages) and have not been read.

is_recent()

Messages that are recently arrived (this session is the first to have been notified about these messages).

is_seen()

Messages that have been read.

is_unanswered()

Messages that have not been answered.

is_undeleted()

Messages that are not marked for later removal.

is_undraft()

Messages that have completed composition.

is_unflagged()

Messages that are not flagged for urgent/special attention.

is_unseen()

Messages that have not been read.

The following method can be used to search for messages that have a specific keyword flag set:

has_keyword(flag)

Messages with the specified keyword flag (string) set.

has_unkeyword(flag)

Messages without the specified keyword flag (string) set.

The following methods can be used to search for messages based on their size:

is_larger(size)

Messages that are larger than the size (number) in octets (bytes).

is_smaller(size)

Messages that are smaller than the size (number) in octets (bytes).

The following methods can be used to search for messages based on their age:

is_newer(age)

Messages that are newer than the age (number) in days.

is_older(age)

Messages that are older than the age (number) in days.

The following methods can be used to search for messages based on their arrival or sent date, in the “day-month-year” form, where day is the day of the month as a decimal number (01-31), month is the abbreviated month ( “Jan”, “Feb”, “Mar”, “Apr”, “May”, “Jun”, “Jul”, “Aug”, “Sep”, “Oct”, “Nov”, “Dec”) and year is the year as decimal number including the century (eg. 2007):

arrived_before(date)

messages that have arrived earlier than the date (string), where date is in the “day-month-year” form.

arrived_on(date)

Messages that have arrived within the date (string), where date is in the “day-month-year” form.

arrived_since(date)

Messages that have arrived within or later than the date (string), where date is in the “day-month-year” form.

sent_before(date)

Messages that have been sent earlier than the date (string), where date is in the “day-month-year” form.

sent_on(date)

Messages that have been sent within the date (string), where date is in the “day-month-year” form.

sent_since(date)

Messages that have been sent within or later than the date (string), where date is in the “day-month-year” form.

The following methods can be used to do case-insensitive searching, for messages that contain a specific word or phrase:

contain_bcc(string)

Messages that contain the string (string) in the “Bcc” header field.

contain_cc(string)

Messages that contain the string (string) in the “Cc” header field.

contain_from(string)

Messages that contain the string (string) in the “From” header field.

contain_subject(string)

Messages that contain the string (string) in the “Subject” header field.

contain_to(string)

Messages that contain the string (string) in the “To” header field.

contain_field(field, string)

Messages that contain the string (string) in the field (string) header field.

contain_body(string)

Messages that contain the string (string) in the message body.

contain_message(string)

Messages that contain the string (string) in the message.

The following methods can be used to do case-sensitive searching, for messages that match a specific regular expression pattern. The matching mechanism that is used to support this is based on the Perl-compatible regular expressions (PCRE), and more information about the patterns and modifiers that can be used, is available in the relevant documentation at http://pcre.org/original/doc/html/.

This way of searching is not supported by the IMAP protocol, and this means that what actually happens under the hood, is that the relevant parts of all the messages are downloaded and matched locally. It is therefore recommended to use these methods with meta-searching (see following section), in order to narrow down the set of messages that should be searched, and thus minimize what will be downloaded.

Note that due to Lua using backslash ‘\’ as an escape character for its strings, one has to use double backslashes in order to insert a single backslash inside a regular expression pattern:

match_bcc(pattern)

Messages that match the regular expression pattern (string) in the “Bcc” header field.

match_cc(pattern)

Messages that match the regular expression pattern (string) in the “Cc” header field.

match_from(pattern)

Messages that match the regular expression pattern (string) in the “From” header field.

match_subject(pattern)

Messages that match the regular expression pattern (string) in the “Subject” header field.

match_to(pattern)

Messages that match the regular expression pattern (string) in the “To” header field.

match_field(field, pattern)

Messages that match the regular expression pattern (string) in the field (string) header field.

match_header(pattern)

Messages that match the regular expression pattern (string) in the message header.

match_body(pattern)

Messages that match the regular expression pattern (string) in the message body.

match_message(pattern)

Messages that match the regular expression pattern (string) in the message.

The following method can be used to search for messages using user queries based on the IMAP specification (RFC 3501 Section 6.4.4):

send_query(criteria)

Searches messages by sending an IMAP search query as described in the search criteria (string).

Examples:

results = myaccount.mymailbox:select_all()
results = myaccount.mymailbox:is_new()
results = myaccount.mymailbox:is_recent()
results = myaccount.mymailbox:is_larger(100000)
results = myaccount.mymailbox:is_older(10)
results = myaccount.mymailbox:has_keyword('MyFlag')
results = myaccount.mymailbox:arrived_before('01-Jan-2007')
results = myaccount.mymailbox:sent_since('01-Jan-2007')
results = myaccount.mymailbox:contain_subject('test')
results = myaccount.mymailbox:contain_field('Sender', 'user@host')
results = myaccount.mymailbox:contain_body('hello world')
results = myaccount.mymailbox:match_from('.*(user1|user2)@host')
results = myaccount.mymailbox:send_query('ALL')

results = myaccount['mymailbox']:is_new()
results = myaccount['myfolder/mymailbox']:is_recent()

META-SEARCHING

The results of the searching methods can be searched further on in the same way as searching is done in mailboxes. The difference is that instead of doing the search in the whole mailbox, ie. in all the messages, it is instead done only to those messages that were returned in a previous search.

Examples:

results:match_message('^[Hh]ello world!?$')
myaccount.mymailbox:is_new():match_body('^[Ww]orld, hello!?$')

PROCESSING

The processing methods are applied to the results that searching returned.

The following method can be used to delete messages in a mailbox:

delete_messages()

Deletes the messages that matched.

The following methods can be used to copy and move messages in a mailbox at the same or different accounts. If the destination mailbox is in a different account than the source mailbox, then the messages are downloaded and then uploaded to the destination:

copy_messages(destination)

Copies the messages to the destination, which is a mailbox at an account.

move_messages(destination)

Moves the messages to the destination, which is a mailbox at an account.

The following methods can be used to mark messages in a mailbox:

mark_answered()

Marks the messages as answered.

mark_deleted()

Marks the messages for later removal.

mark_draft()

Marks the messages as draft.

mark_flagged()

Marks the messages for urgent/special attention.

mark_seen()

Marks the messages as read.

unmark_answered()

Unmarks the messages that have been marked as answered.

unmark_deleted()

Unmarks the messages that have been marked for later removal.

unmark_draft()

Unmarks the messages that have been marked as draft.

unmark_flagged()

Unmarks the messages that have been marked for urgent/special attention.

unmark_seen()

Unmarks the messages that have been marked as read.

The following methods can be used to flag messages in a mailbox. The standard system flags are “\Answered”, “\Deleted”, “\Draft”, “\Flagged”, “\Seen”, while if the server supports it, new user keywords may be defined:

add_flags(flags)

Adds the flags (table that contains strings) to the messages.

remove_flags(flags)

Removes the flags (table that contains strings) from the messages.

replace_flags(flags)

Replaces the flags (table that contains strings) of the messages.

Examples:

results:delete_messages()
results:copy_messages(myaccount.myothermailbox)
results:move_messages(myotheraccount.mymailbox)
results:mark_seen()
results:unmark_flagged()
results:add_flags({ 'MyFlag', '\\Seen' })
results:remove_flags({ '\\Seen' })

results:move_messages(myotheraccount['myfolder/mymailbox'])

FETCHING

The following methods can be used to fetch parts of messages. The methods return a string. The downloaded message parts are cached locally, so they can be reused inside the same program session:

fetch_message()

Fetches the header and body of the message.

fetch_header()

Fetches the header of the message.

fetch_body()

Fetches the body of the messages.

fetch_field(field)

Fetches the specified header field (string) of the message.

fetch_part(part)

Fetches the specified part (string) of the message.

The following methods can be used to fetch details about the state of a message:

fetch_flags()

Fetches the flags of the message. Returns a table of strings.

fetch_date()

Fetches the internal date of the message. Returns a string.

fetch_size()

Fetches the size of the message. Returns a number.

fetch_structure()

Fetches the body structure of the message. Returns a table that has as keys the parts of the message, and as values a table that has one mandatory element, the type (string) of the part, and two optional elements, the size (number) and name (string) of the part.

APPENDING

The following methods can be used to append a message to a mailbox:

append_message(message)

Appends the message (string) to the mailbox.

append_message(message, flags, date)

Appends the message (string) to the mailbox, setting the specified flags (table of strings), as returned by fetch_flags(), and date (string), as returned by fetch_date().

Examples:

myaccount.mymailbox[2]:fetch_message()
myaccount.mymailbox[3]:fetch_field('subject')
myaccount.mymailbox[5]:fetch_part('1.1')

myaccount['mymailbox'][7]:fetch_message()
myaccount['myfolder/mymailbox'][11]:fetch_message()

myaccount.mymailbox:append_message(message)