# Net::IMAP (Class)

In: | net/imap.rb
Parent: | Object

Net::IMAP implements Internet Message Access Protocol (IMAP) client functionality. The protocol is described in [IMAP].

## IMAP OVERVIEW

An IMAP client connects to a server, and then authenticates itself using either authenticate() or login(). Having authenticated itself, there is a range of commands available to it. Most work with mailboxes, which may be arranged in an hierarchical namespace, and each of which contains zero or more messages. How this is implemented on the server is implementation-dependent; on a UNIX server, it will frequently be implemented as a files in mailbox format within a hierarchy of directories.

To work on the messages within a mailbox, the client must first select that mailbox, using either select() or (for read-only access) examine(). Once the client has successfully selected a mailbox, they enter selected state, and that mailbox becomes the current mailbox, on which mail-item related commands implicitly operate.

Messages have two sorts of identifiers: message sequence numbers, and UIDs.

Message sequence numbers number messages within a mail box from 1 up to the number of items in the mail box. If new message arrives during a session, it receives a sequence number equal to the new size of the mail box. If messages are expunged from the mailbox, remaining messages have their sequence numbers "shuffled down" to fill the gaps.

UIDs, on the other hand, are permanently guaranteed not to identify another message within the same mailbox, even if the existing message is deleted. UIDs are required to be assigned in ascending (but not necessarily sequential) order within a mailbox; this means that if a non-IMAP client rearranges the order of mailitems within a mailbox, the UIDs have to be reassigned. An IMAP client cannot thus rearrange message orders.

## EXAMPLES OF USAGE

### List sender and subject of all recent messages in the default mailbox

      imap = Net::IMAP.new('mail.example.com')
      imap.authenticate('LOGIN', 'joe_user', 'joes_password')
      imap.examine('INBOX')
      imap.search(["RECENT"]).each do |message_id|
        envelope = imap.fetch(message_id, "ENVELOPE")[0].attr["ENVELOPE"]
        puts "#{envelope.from[0].name}: \t#{envelope.subject}"
      end

### Move all messages from April 2003 from "Mail/sent-mail" to "Mail/sent-apr03"

      imap = Net::IMAP.new('mail.example.com')
      imap.authenticate('LOGIN', 'joe_user', 'joes_password')
      imap.select('Mail/sent-mail')
      if not imap.list('Mail/', 'sent-apr03')
        imap.create('Mail/sent-apr03')
      end
      imap.search(["BEFORE", "30-Apr-2003", "SINCE", "1-Apr-2003"]).each do |message_id|
        imap.copy(message_id, "Mail/sent-apr03")
        imap.store(message_id, "+FLAGS", [:Deleted])
      end
      imap.expunge

## THREAD-SAFENESS

Net::IMAP supports concurrent threads. For example,

      imap = Net::IMAP.new("imap.foo.net", "imap2")
      imap.authenticate("cram-md5", "bar", "password")
      imap.select("inbox")
      fetch_thread = Thread.start { imap.fetch(1..-1, "UID") }
      search_result = imap.search(["BODY", "hello"])
      fetch_result = fetch_thread.value
      imap.disconnect

This script invokes the FETCH command and the SEARCH command concurrently.

## ERRORS

An IMAP server can send three different types of responses to indicate failure:

NO: | the attempted command could not be successfully completed. For instance, the username/password used for logging in are incorrect; the selected mailbox does not exists; etc.
BAD: | the request from the client does not follow the server’s understanding of the IMAP protocol. This includes attempting commands from the wrong client state; for instance, attempting to perform a SEARCH command without having SELECTed a current mailbox. It can also signal an internal server failure (such as a disk crash) has occurred.
BYE: | the server is saying goodbye. This can be part of a normal logout sequence, and can be used as part of a login sequence to indicate that the server is (for some reason) unwilling to accept our connection. As a response to any other command, it indicates either that the server is shutting down, or that the server is timing out the client connection due to inactivity.

These three error response are represented by the errors Net::IMAP::NoResponseError, Net::IMAP::BadResponseError, and Net::IMAP::ByeResponseError, all of which are subclasses of Net::IMAP::ResponseError. Essentially, all methods that involve sending a request to the server can generate one of these errors. Only the most pertinent instances have been documented below.

Because the IMAP class uses Sockets for communication, its methods are also susceptible to the various errors that can occur when working with sockets. These are generally represented as Errno errors. For instance, any method that involves sending a request to the server and/or receiving a response from it could raise an Errno::EPIPE error if the network connection unexpectedly goes down. See the socket(7), ip(7), tcp(7), socket(2), connect(2), and associated man pages.

Finally, a Net::IMAP::DataFormatError is thrown if low-level data is found to be in an incorrect format (for instance, when converting between UTF-8 and UTF-16), and Net::IMAP::ResponseParseError is thrown if a server response is non-parseable.

## References

[IMAP]
  M. Crispin, "INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1", RFC 2060, December 1996. (Note: since obsoleted by RFC 3501)
[LANGUAGE-TAGS]
  Alvestrand, H., "Tags for the Identification of Languages", RFC 1766, March 1995.
[MD5]
  Myers, J., and M. Rose, "The Content-MD5 Header Field", RFC 1864, October 1995.
[MIME-IMB]
  Freed, N., and N. Borenstein, "MIME (Multipurpose Internet Mail Extensions) Part One: Format of Internet Message Bodies", RFC 2045, November 1996.
[RFC-822]
  Crocker, D., "Standard for the Format of ARPA Internet Text Messages", STD 11, RFC 822, University of Delaware, August 1982.
[RFC-2087]
  Myers, J., "IMAP4 QUOTA extension", RFC 2087, January 1997.
[RFC-2086]
  Myers, J., "IMAP4 ACL extension", RFC 2086, January 1997.
[RFC-2195]
  Klensin, J., Catoe, R., and Krumviede, P., "IMAP/POP AUTHorize Extension for Simple Challenge/Response", RFC 2195, September 1997.
[SORT-THREAD-EXT]
  Crispin, M., "INTERNET MESSAGE ACCESS PROTOCOL - SORT and THREAD Extensions", draft-ietf-imapext-sort, May 2003.
[OSSL]
  www.openssl.org
[RSSL]
  savannah.gnu.org/projects/rubypki
[UTF7]
  Goldsmith, D. and Davis, M., "UTF-7: A Mail-Safe Transformation Format of Unicode", RFC 2152, May 1997.

## Methods

add_authenticator add_response_handler append authenticate capability check close copy create debug debug= decode_utf7 delete disconnect encode_utf7 examine expunge fetch getacl getquota getquotaroot list login logout lsub new noop remove_response_handler rename search select setacl setquota sort status store subscribe thread uid_copy uid_fetch uid_search uid_sort uid_store uid_thread unsubscribe

## Constants

SEEN | = | :Seen
| Flag indicating a message has been seen
ANSWERED | = | :Answered
| Flag indicating a message has been answered
FLAGGED | = | :Flagged
| Flag indicating a message has been flagged for special or urgent attention
DELETED | = | :Deleted
| Flag indicating a message has been marked for deletion. This will occur when the mailbox is closed or expunged.
DRAFT | = | :Draft
| Flag indicating a message is only a draft or work-in-progress version.
RECENT | = | :Recent
| Flag indicating that the message is "recent", meaning that this session is the first session in which the client has been notified of this message.
NOINFERIORS | = | :Noinferiors
| Flag indicating that a mailbox context name cannot contain children.
NOSELECT | = | :Noselect
| Flag indicating that a mailbox is not selected.
MARKED | = | :Marked
| Flag indicating that a mailbox has been marked "interesting" by the server; this commonly indicates that the mailbox contains new messages.
UNMARKED | = | :Unmarked
| Flag indicating that the mailbox does not contains new messages.
DATE_MONTH | = | %w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
ContinuationRequest | = | Struct.new(:data, :raw_data)
| Net::IMAP::ContinuationRequest represents command continuation requests. The command continuation request response is indicated by a "+" token instead of a tag. This form of response indicates that the server is ready to accept the continuation of a command from the client. The remainder of this response is a line of text.
      continue_req    ::= "+" SPACE (resp_text / base64)
#### Fields:
data: | Returns the data (Net::IMAP::ResponseText).
raw_data: | Returns the raw data string.
UntaggedResponse | = | Struct.new(:name, :data, :raw_data)
| Net::IMAP::UntaggedResponse represents untagged responses. Data transmitted by the server to the client and status responses that do not indicate command completion are prefixed with the token "*", and are called untagged responses.
      response_data   ::= "*" SPACE (resp_cond_state / resp_cond_bye /
                          mailbox_data / message_data / capability_data)
#### Fields:
name: | Returns the name such as "FLAGS", "LIST", "FETCH".…
data: | Returns the data such as an array of flag symbols,
     a ((<Net::IMAP::MailboxList>)) object....
raw_data: | Returns the raw data string.
TaggedResponse | = | Struct.new(:tag, :name, :data, :raw_data)
| Net::IMAP::TaggedResponse represents tagged responses. The server completion result response indicates the success or failure of the operation. It is tagged with the same tag as the client command which began the operation.
      response_tagged ::= tag SPACE resp_cond_state CRLF

      tag             ::= 1*<any ATOM_CHAR except "+">

      resp_cond_state ::= ("OK" / "NO" / "BAD") SPACE resp_text
#### Fields:
tag: | Returns the tag.
name: | Returns the name. the name is one of "OK", "NO", "BAD".
data: | Returns the data. See ((<Net::IMAP::ResponseText>)).
raw_data: | Returns the raw data string.
ResponseText | = | Struct.new(:code, :text)
| Net::IMAP::ResponseText represents texts of responses. The text may be prefixed by the response code.
      resp_text       ::= ["[" resp_text_code "]" SPACE] (text_mime2 / text)
                          ;; text SHOULD NOT begin with "[" or "="
#### Fields:
code: | Returns the response code. See ((<Net::IMAP::ResponseCode>)).
text: | Returns the text.
ResponseCode | = | Struct.new(:name, :data)
| Net::IMAP::ResponseCode represents response codes.
      resp_text_code  ::= "ALERT" / "PARSE" /
                          "PERMANENTFLAGS" SPACE "(" #(flag / "\*") ")" /
                          "READ-ONLY" / "READ-WRITE" / "TRYCREATE" /
                          "UIDVALIDITY" SPACE nz_number /
                          "UNSEEN" SPACE nz_number /
                          atom [SPACE 1*<any TEXT_CHAR except "]">]
#### Fields:
name: | Returns the name such as "ALERT", "PERMANENTFLAGS", "UIDVALIDITY".…
data: | Returns the data if it exists.
MailboxList | = | Struct.new(:attr, :delim, :name)
| Net::IMAP::MailboxList represents contents of the LIST response.
      mailbox_list    ::= "(" #("\Marked" / "\Noinferiors" /
                          "\Noselect" / "\Unmarked" / flag_extension) ")"
                          SPACE (<"> QUOTED_CHAR <"> / nil) SPACE mailbox
#### Fields:
attr: | Returns the name attributes. Each name attribute is a symbol capitalized by String#capitalize, such as :Noselect (not :NoSelect).
delim: | Returns the hierarchy delimiter
name: | Returns the mailbox name.
MailboxQuota | = | Struct.new(:mailbox, :usage, :quota)
| Net::IMAP::MailboxQuota represents contents of GETQUOTA response. This object can also be a response to GETQUOTAROOT. In the syntax specification below, the delimiter used with the "#" construct is a single space (SPACE).
       quota_list      ::= "(" #quota_resource ")"

       quota_resource  ::= atom SPACE number SPACE number

       quota_response  ::= "QUOTA" SPACE astring SPACE quota_list
#### Fields:
mailbox: | The mailbox with the associated quota.
usage: | Current storage usage of mailbox.
quota: | Quota limit imposed on mailbox.
MailboxQuotaRoot | = | Struct.new(:mailbox, :quotaroots)
| Net::IMAP::MailboxQuotaRoot represents part of the GETQUOTAROOT response. (GETQUOTAROOT can also return Net::IMAP::MailboxQuota.)
       quotaroot_response ::= "QUOTAROOT" SPACE astring *(SPACE astring)
#### Fields:
mailbox: | The mailbox with the associated quota.
quotaroots: | Zero or more quotaroots that effect the quota on the specified mailbox.
MailboxACLItem | = | Struct.new(:user, :rights)
| Net::IMAP::MailboxACLItem represents response from GETACL.
       acl_data        ::= "ACL" SPACE mailbox *(SPACE identifier SPACE rights)

       identifier      ::= astring

       rights          ::= astring
#### Fields:
user: | Login name that has certain rights to the mailbox that was specified with the getacl command.
rights: | The access rights the indicated user has to the mailbox.
StatusData | = | Struct.new(:mailbox, :attr)
| Net::IMAP::StatusData represents contents of the STATUS response. #### Fields:
mailbox: | Returns the mailbox name.
attr: | Returns a hash. Each key is one of "MESSAGES", "RECENT", "UIDNEXT", "UIDVALIDITY", "UNSEEN". Each value is a number.
FetchData | = | Struct.new(:seqno, :attr)
| Net::IMAP::FetchData represents contents of the FETCH response. #### Fields:
seqno: | Returns the message sequence number. (Note: not the unique identifier, even for the UID command response.)
attr: | Returns a hash. Each key is a data item name, and each value is its value. The current data items are: BODY A form of BODYSTRUCTURE without extension data. BODY[<section>]<<origin_octet>> A string expressing the body contents of the specified section. BODYSTRUCTURE An object that describes the [MIME-IMB] body structure of a message. See Net::IMAP::BodyTypeBasic, Net::IMAP::BodyTypeText, Net::IMAP::BodyTypeMessage, Net::IMAP::BodyTypeMultipart. ENVELOPE A Net::IMAP::Envelope object that describes the envelope structure of a message. FLAGS A array of flag symbols that are set for this message. flag symbols are capitalized by String#capitalize. INTERNALDATE A string representing the internal date of the message. RFC822 Equivalent to BODY[]. RFC822.HEADER Equivalent to BODY.PEEK[HEADER]. RFC822.SIZE A number expressing the [RFC-822] size of the message. RFC822.TEXT Equivalent to BODY[TEXT]. UID A number expressing the unique identifier of the message.
Envelope | = | Struct.new(:date, :subject, :from, :sender, :reply_to, :to, :cc, :bcc, :in_reply_to, :message_id)
| Net::IMAP::Envelope represents envelope structures of messages. #### Fields:
date: | Returns a string that represents the date.
subject: | Returns a string that represents the subject.
from: | Returns an array of Net::IMAP::Address that represents the from.
sender: | Returns an array of Net::IMAP::Address that represents the sender.
reply_to: | Returns an array of Net::IMAP::Address that represents the reply-to.
to: | Returns an array of Net::IMAP::Address that represents the to.
cc: | Returns an array of Net::IMAP::Address that represents the cc.
bcc: | Returns an array of Net::IMAP::Address that represents the bcc.
in_reply_to: | Returns a string that represents the in-reply-to.
message_id: | Returns a string that represents the message-id.
Address | = | Struct.new(:name, :route, :mailbox, :host)
| Net::IMAP::Address represents electronic mail addresses. #### Fields:
name: | Returns the phrase from [RFC-822] mailbox.
route: | Returns the route from [RFC-822] route-addr.
mailbox: | nil indicates end of [RFC-822] group. If non-nil and host is nil, returns [RFC-822] group name. Otherwise, returns [RFC-822] local-part
host: | nil indicates [RFC-822] group syntax. Otherwise, returns [RFC-822] domain name.
ContentDisposition | = | Struct.new(:dsp_type, :param)
| Net::IMAP::ContentDisposition represents Content-Disposition fields. #### Fields:
dsp_type: | Returns the disposition type.
param: | Returns a hash that represents parameters of the Content-Disposition field.
ThreadMember | = | Struct.new(:seqno, :children)
| Net::IMAP::ThreadMember represents a thread-node returned by Net::IMAP#thread #### Fields:
seqno: | The sequence number of this message.
children: | an array of Net::IMAP::ThreadMember objects for mail
items that are children of this in the thread.

## Attributes

client_thread | [RW] | The thread to receive exceptions.
greeting | [R] | Returns an initial greeting response from the server.
response_handlers | [R] | Returns all response handlers.
responses | [R] | Returns recorded untagged responses. For example:
      imap.select("inbox")
      p imap.responses["EXISTS"][-1]
      #=> 2
      p imap.responses["UIDVALIDITY"][-1]
      #=> 968263756

## Classes and Modules

Class Net::IMAP::BadResponseError
Class Net::IMAP::BodyTypeBasic
Class Net::IMAP::BodyTypeMessage
Class Net::IMAP::BodyTypeMultipart
Class Net::IMAP::BodyTypeText
Class Net::IMAP::ByeResponseError
Class Net::IMAP::CramMD5Authenticator
Class Net::IMAP::DataFormatError
Class Net::IMAP::Error
Class Net::IMAP::LoginAuthenticator
Class Net::IMAP::NoResponseError
Class Net::IMAP::ResponseError
Class Net::IMAP::ResponseParseError

## Included Modules

MonitorMixin OpenSSL SSL

## Public Class methods

debug()

Returns the debug mode.

[Source]

    # File net/imap.rb, line 261
        def self.debug
          return @@debug
        end

debug=(val)

Sets the debug mode.

[Source]

    # File net/imap.rb, line 266
        def self.debug=(val)
          return @@debug = val
        end

add_authenticator(auth_type, authenticator)

Adds an authenticator for Net::IMAP#authenticate. `auth_type` is the type of authentication this authenticator supports (for instance, "LOGIN"). The `authenticator` is an object which defines a process() method to handle authentication with the server. See Net::IMAP::LoginAuthenticator and Net::IMAP::CramMD5Authenticator for examples.

If `auth_type` refers to an existing authenticator, it will be replaced by the new one.

[Source]

    # File net/imap.rb, line 279
        def self.add_authenticator(auth_type, authenticator)
          @@authenticators[auth_type] = authenticator
        end

decode_utf7(s)

Decode a string from modified UTF-7 format to UTF-8.

UTF-7 is a 7-bit encoding of Unicode [UTF7]. IMAP uses a slightly modified version of this to encode mailbox names containing non-ASCII characters; see [IMAP] section 5.1.3.

Net::IMAP does not automatically encode and decode mailbox names to and from utf7.

[Source]

    # File net/imap.rb, line 812
        def self.decode_utf7(s)
          return s.gsub(/&(.*?)-/n) {
            if $1.empty?
              "&"
            else
              base64 = $1.tr(",", "/")
              x = base64.length % 4
              if x > 0
                base64.concat("=" * (4 - x))
              end
              u16tou8(base64.unpack("m")[0])
            end
          }
        end

encode_utf7(s)

Encode a string from UTF-8 format to modified UTF-7.

[Source]

    # File net/imap.rb, line 828
        def self.encode_utf7(s)
          return s.gsub(/(&)|([^\x20-\x25\x27-\x7e]+)/n) { |x|
            if $1
              "&-"
            else
              base64 = [u8tou16(x)].pack("m")
              "&" + base64.delete("=\n").tr("/", ",") + "-"
            end
          }
        end

new(host, port = PORT, usessl = false, certs = nil, verify = false)

Creates a new Net::IMAP object and connects it to the specified `port` (143 by default) on the named `host`. If `usessl` is true, then an attempt will be made to use SSL (now TLS) to connect to the server. For this to work OpenSSL [OSSL] and the Ruby OpenSSL [RSSL] extensions need to be installed. The `certs` parameter indicates the path or file containing the CA cert of the server, and the `verify` parameter is for the OpenSSL verification callback.

The most common errors are:

Errno::ECONNREFUSED: | connection refused by `host` or an intervening firewall.
Errno::ETIMEDOUT: | connection timed out (possibly due to packets being dropped by an intervening firewall).
Errno::NETUNREACH: | there is no route to that network.
SocketError: | hostname not known or other socket error.
Net::IMAP::ByeResponseError: | we connected to the host, but they immediately said goodbye to us.

[Source]

    # File net/imap.rb, line 866
        def initialize(host, port = PORT, usessl = false, certs = nil, verify = false)
          super()
          @host = host
          @port = port
          @tag_prefix = "RUBY"
          @tagno = 0
          @parser = ResponseParser.new
          @sock = TCPSocket.open(host, port)
          if usessl
            unless defined?(OpenSSL)
              raise "SSL extension not installed"
            end
            @usessl = true
            @sock = SSLSocket.new(@sock)

            # verify the server.

            @sock.ca_file = certs if certs && FileTest::file?(certs)
            @sock.ca_path = certs if certs && FileTest::directory?(certs)
            @sock.verify_mode = VERIFY_PEER if verify
            @sock.verify_callback = VerifyCallbackProc if defined?(VerifyCallbackProc)

            @sock.connect   # start ssl session.

          else
            @usessl = false
          end
          @responses = Hash.new([].freeze)
          @tagged_responses = {}
          @response_handlers = []
          @tag_arrival = new_cond

          @greeting = get_response
          if /\ABYE\z/ni =~ @greeting.name
            @sock.close
            raise ByeResponseError, resp[0]
          end

          @client_thread = Thread.current
          @receiver_thread = Thread.start {
            receive_responses
          }
        end

## Public Instance methods

disconnect()

Disconnects from the server.

[Source]

    # File net/imap.rb, line 284
        def disconnect
          @sock.shutdown unless @usessl
          @receiver_thread.join
          @sock.close
        end

capability()

Sends a CAPABILITY command, and returns an array of capabilities that the server supports. Each capability is a string. See [IMAP] for a list of possible capabilities.

Note that the Net::IMAP class does not modify its behaviour according to the capabilities of the server; it is up to the user of the class to ensure that a certain capability is supported by a server before using it.

[Source]

    # File net/imap.rb, line 300
        def capability
          synchronize do
            send_command("CAPABILITY")
            return @responses.delete("CAPABILITY")[-1]
          end
        end

noop()

Sends a NOOP command to the server. It does nothing.

[Source]

    # File net/imap.rb, line 308
        def noop
          send_command("NOOP")
        end

logout()

Sends a LOGOUT command to inform the server that the client is done with the connection.

[Source]

    # File net/imap.rb, line 314
        def logout
          send_command("LOGOUT")
        end

authenticate(auth_type, *args)

Sends an AUTHENTICATE command to authenticate the client. The `auth_type` parameter is a string that represents the authentication mechanism to be used. Currently Net::IMAP supports authentication mechanisms:

      LOGIN:: login using cleartext user and password.
      CRAM-MD5:: login with cleartext user and encrypted password
                 (see [RFC-2195] for a full description).  This
                 mechanism requires that the server have the user's
                 password stored in clear-text password.

For both these mechanisms, there should be two `args`: username and (cleartext) password. A server may not support one or other of these mechanisms; check capability() for a capability of the form "AUTH=LOGIN" or "AUTH=CRAM-MD5".

Authentication is done using the appropriate authenticator object: see @@authenticators for more information on plugging in your own authenticator.

For example:

       imap.authenticate('LOGIN', user, password)

A Net::IMAP::NoResponseError is raised if authentication fails.

[Source]

    # File net/imap.rb, line 343
        def authenticate(auth_type, *args)
          auth_type = auth_type.upcase
          unless @@authenticators.has_key?(auth_type)
            raise ArgumentError,
              format('unknown auth type - "%s"', auth_type)
          end
          authenticator = @@authenticators[auth_type].new(*args)
          send_command("AUTHENTICATE", auth_type) do |resp|
            if resp.instance_of?(ContinuationRequest)
              data = authenticator.process(resp.data.text.unpack("m")[0])
              send_data([data].pack("m").chomp)
            end
          end
        end

login(user, password)

Sends a LOGIN command to identify the client and carries the plaintext `password` authenticating this `user`. Note that, unlike calling authenticate() with an `auth_type` of "LOGIN", login() does not use the login authenticator.

A Net::IMAP::NoResponseError is raised if authentication fails.

[Source]

    # File net/imap.rb, line 364
        def login(user, password)
          send_command("LOGIN", user, password)
        end

select(mailbox)

Sends a SELECT command to select a `mailbox` so that messages in the `mailbox` can be accessed.

After you have selected a mailbox, you may retrieve the number of items in that mailbox from @responses["EXISTS"][-1], and the number of recent messages from @responses["RECENT"][-1]. Note that these values can change if new messages arrive during a session; see add_response_handler() for a way of detecting this event.

A Net::IMAP::NoResponseError is raised if the mailbox does not exist or is for some reason non-selectable.

[Source]

    # File net/imap.rb, line 380
        def select(mailbox)
          synchronize do
            @responses.clear
            send_command("SELECT", mailbox)
          end
        end

examine(mailbox)

Sends a EXAMINE command to select a `mailbox` so that messages in the `mailbox` can be accessed. Behaves the same as select(), except that the selected `mailbox` is identified as read-only.

A Net::IMAP::NoResponseError is raised if the mailbox does not exist or is for some reason non-examinable.

[Source]

    # File net/imap.rb, line 393
        def examine(mailbox)
          synchronize do
            @responses.clear
            send_command("EXAMINE", mailbox)
          end
        end

create(mailbox)

Sends a CREATE command to create a new `mailbox`.

A Net::IMAP::NoResponseError is raised if a mailbox with that name cannot be created.

[Source]

    # File net/imap.rb, line 404
        def create(mailbox)
          send_command("CREATE", mailbox)
        end

delete(mailbox)

Sends a DELETE command to remove the `mailbox`.

A Net::IMAP::NoResponseError is raised if a mailbox with that name cannot be deleted, either because it does not exist or because the client does not have permission to delete it.

[Source]

    # File net/imap.rb, line 413
        def delete(mailbox)
          send_command("DELETE", mailbox)
        end

rename(mailbox, newname)

Sends a RENAME command to change the name of the `mailbox` to `newname`.

A Net::IMAP::NoResponseError is raised if a mailbox with the name `mailbox` cannot be renamed to `newname` for whatever reason; for instance, because `mailbox` does not exist, or because there is already a mailbox with the name `newname`.

[Source]

    # File net/imap.rb, line 424
        def rename(mailbox, newname)
          send_command("RENAME", mailbox, newname)
        end

subscribe(mailbox)

Sends a SUBSCRIBE command to add the specified `mailbox` name to the server’s set of "active" or "subscribed" mailboxes as returned by lsub().

A Net::IMAP::NoResponseError is raised if `mailbox` cannot be subscribed to, for instance because it does not exist.

[Source]

    # File net/imap.rb, line 434
        def subscribe(mailbox)
          send_command("SUBSCRIBE", mailbox)
        end

unsubscribe(mailbox)

Sends a UNSUBSCRIBE command to remove the specified `mailbox` name from the server’s set of "active" or "subscribed" mailboxes.

A Net::IMAP::NoResponseError is raised if `mailbox` cannot be unsubscribed from, for instance because the client is not currently subscribed to it.

[Source]

    # File net/imap.rb, line 444
        def unsubscribe(mailbox)
          send_command("UNSUBSCRIBE", mailbox)
        end

list(refname, mailbox)

Sends a LIST command, and returns a subset of names from the complete set of all names available to the client. `refname` provides a context (for instance, a base directory in a directory-based mailbox hierarchy). `mailbox` specifies a mailbox or (via wilcards) mailboxes under that context. Two wildcards may be used in `mailbox`: ’*’, which matches all characters including the hierarchy delimiter (for instance, ’/’ on a UNIX-hosted directory-based mailbox hierarchy); and ’%’, which matches all characters except the hierarchy delimiter.

If `refname` is empty, `mailbox` is used directly to determine which mailboxes to match. If `mailbox` is empty, the root name of `refname` and the hierarchy delimiter are returned.

The return value is an array of +Net::IMAP::MailboxList+. For example:

      imap.create("foo/bar")
      imap.create("foo/baz")
      p imap.list("", "foo/%")
      #=> [#<Net::IMAP::MailboxList attr=[:Noselect], delim="/", name="foo/">, \\
           #<Net::IMAP::MailboxList attr=[:Noinferiors, :Marked], delim="/", name="foo/bar">, \\
           #<Net::IMAP::MailboxList attr=[:Noinferiors], delim="/", name="foo/baz">]

[Source]

    # File net/imap.rb, line 470
        def list(refname, mailbox)
          synchronize do
            send_command("LIST", refname, mailbox)
            return @responses.delete("LIST")
          end
        end

getquotaroot(mailbox)

Sends the GETQUOTAROOT command along with specified `mailbox`. This command is generally available to both admin and user. If mailbox exists, returns an array containing objects of Net::IMAP::MailboxQuotaRoot and Net::IMAP::MailboxQuota.

[Source]

    # File net/imap.rb, line 481
        def getquotaroot(mailbox)
          synchronize do
            send_command("GETQUOTAROOT", mailbox)
            result = []
            result.concat(@responses.delete("QUOTAROOT"))
            result.concat(@responses.delete("QUOTA"))
            return result
          end
        end

getquota(mailbox)

Sends the GETQUOTA command along with specified `mailbox`. If this mailbox exists, then an array containing a Net::IMAP::MailboxQuota object is returned. This command generally is only available to server admin.

[Source]

    # File net/imap.rb, line 495
        def getquota(mailbox)
          synchronize do
            send_command("GETQUOTA", mailbox)
            return @responses.delete("QUOTA")
          end
        end

setquota(mailbox, quota)

Sends a SETQUOTA command along with the specified `mailbox` and `quota`. If `quota` is nil, then quota will be unset for that mailbox. Typically one needs to be logged in as server admin for this to work. The IMAP quota commands are described in [RFC-2087].

[Source]

    # File net/imap.rb, line 507
        def setquota(mailbox, quota)
          if quota.nil?
            data = '()'
          else
            data = '(STORAGE ' + quota.to_s + ')'
          end
          send_command("SETQUOTA", mailbox, RawData.new(data))
        end

setacl(mailbox, user, rights)

Sends the SETACL command along with `mailbox`, `user` and the `rights` that user is to have on that mailbox. If `rights` is nil, then that user will be stripped of any rights to that mailbox. The IMAP ACL commands are described in [RFC-2086].

[Source]

    # File net/imap.rb, line 520
        def setacl(mailbox, user, rights)
          if rights.nil?
            send_command("SETACL", mailbox, user, "")
          else
            send_command("SETACL", mailbox, user, rights)
          end
        end

getacl(mailbox)

Send the GETACL command along with specified `mailbox`. If this mailbox exists, an array containing objects of Net::IMAP::MailboxACLItem will be returned.

[Source]

    # File net/imap.rb, line 531
        def getacl(mailbox)
          synchronize do
            send_command("GETACL", mailbox)
            return @responses.delete("ACL")[-1]
          end
        end

lsub(refname, mailbox)

Sends a LSUB command, and returns a subset of names from the set of names that the user has declared as being "active" or "subscribed". `refname` and `mailbox` are interpreted as for list(). The return value is an array of +Net::IMAP::MailboxList+.

[Source]

    # File net/imap.rb, line 543
        def lsub(refname, mailbox)
          synchronize do
            send_command("LSUB", refname, mailbox)
            return @responses.delete("LSUB")
          end
        end

status(mailbox, attr)

Sends a STATUS command, and returns the status of the indicated `mailbox`. `attr` is a list of one or more attributes that we are request the status of. Supported attributes include:

      MESSAGES:: the number of messages in the mailbox.
      RECENT:: the number of recent messages in the mailbox.
      UNSEEN:: the number of unseen messages in the mailbox.

The return value is a hash of attributes. For example:

      p imap.status("inbox", ["MESSAGES", "RECENT"])
      #=> {"RECENT"=>0, "MESSAGES"=>44}

A Net::IMAP::NoResponseError is raised if status values for `mailbox` cannot be returned, for instance because it does not exist.

[Source]

    # File net/imap.rb, line 566
        def status(mailbox, attr)
          synchronize do
            send_command("STATUS", mailbox, attr)
            return @responses.delete("STATUS")[-1].attr
          end
        end

append(mailbox, message, flags = nil, date_time = nil)

Sends a APPEND command to append the `message` to the end of the `mailbox`. The optional `flags` argument is an array of flags to initially assing to the new message. The optional `date_time` argument specifies the creation time to assign to the new message; it defaults to the current time. For example:

      imap.append("inbox", <<EOF.gsub(/\n/, "\r\n"), [:Seen], Time.now)
      Subject: hello
      From: shugo@ruby-lang.org
      To: shugo@ruby-lang.org

      hello world
      EOF

A Net::IMAP::NoResponseError is raised if the mailbox does not exist (it is not created automatically), or if the flags, date_time, or message arguments contain errors.

[Source]

    # File net/imap.rb, line 591
        def append(mailbox, message, flags = nil, date_time = nil)
          args = []
          if flags
            args.push(flags)
          end
          args.push(date_time) if date_time
          args.push(Literal.new(message))
          send_command("APPEND", mailbox, *args)
        end

check()

Sends a CHECK command to request a checkpoint of the currently selected mailbox. This performs implementation-specific housekeeping, for instance, reconciling the mailbox’s in-memory and on-disk state.

[Source]

    # File net/imap.rb, line 605
        def check
          send_command("CHECK")
        end

close()

Sends a CLOSE command to close the currently selected mailbox. The CLOSE command permanently removes from the mailbox all messages that have the \Deleted flag set.

[Source]

    # File net/imap.rb, line 612
        def close
          send_command("CLOSE")
        end

expunge()

Sends a EXPUNGE command to permanently remove from the currently selected mailbox all messages that have the \Deleted flag set.

[Source]

    # File net/imap.rb, line 618
        def expunge
          synchronize do
            send_command("EXPUNGE")
            return @responses.delete("EXPUNGE")
          end
        end

search(keys, charset = nil)

Sends a SEARCH command to search the mailbox for messages that match the given searching criteria, and returns message sequence numbers. `keys` can either be a string holding the entire search string, or a single-dimension array of search keywords and arguments. The following are some common search criteria; see [IMAP] section 6.4.4 for a full list.

<message set>: | a set of message sequence numbers. ’,’ indicates an interval, ’:’ indicates a range. For instance, ‘2,10:12,15’ means "2,10,11,12,15".
BEFORE <date>: | messages with an internal date strictly before <date>. The date argument has a format similar to 8-Aug-2002.
BODY <string>: | messages that contain <string> within their body.
CC <string>: | messages containing <string> in their CC field.
FROM <string>: | messages that contain <string> in their FROM field.
NEW: | messages with the \Recent, but not the \Seen, flag set.
NOT <search-key>: | negate the following search key.
OR <search-key> <search-key>: | "or" two search keys together.
ON <date>: | messages with an internal date exactly equal to <date>, which has a format similar to 8-Aug-2002.
SINCE <date>: | messages with an internal date on or after <date>.
SUBJECT <string>: | messages with <string> in their subject.
TO <string>: | messages with <string> in their TO field.

For example:

      p imap.search(["SUBJECT", "hello", "NOT", "NEW"])
      #=> [1, 6, 7, 8]

[Source]

    # File net/imap.rb, line 665
        def search(keys, charset = nil)
          return search_internal("SEARCH", keys, charset)
        end

uid_search(keys, charset = nil)

As for search(), but returns unique identifiers.

[Source]

    # File net/imap.rb, line 670
        def uid_search(keys, charset = nil)
          return search_internal("UID SEARCH", keys, charset)
        end

fetch(set, attr)

Sends a FETCH command to retrieve data associated with a message in the mailbox. The `set` parameter is a number or an array of numbers or a Range object. The number is a message sequence number. `attr` is a list of attributes to fetch; see the documentation for Net::IMAP::FetchData for a list of valid attributes. The return value is an array of Net::IMAP::FetchData. For example:

      p imap.fetch(6..8, "UID")
      #=> [#<Net::IMAP::FetchData seqno=6, attr={"UID"=>98}>, \\
           #<Net::IMAP::FetchData seqno=7, attr={"UID"=>99}>, \\
           #<Net::IMAP::FetchData seqno=8, attr={"UID"=>100}>]
      p imap.fetch(6, "BODY[HEADER.FIELDS (SUBJECT)]")
      #=> [#<Net::IMAP::FetchData seqno=6, attr={"BODY[HEADER.FIELDS (SUBJECT)]"=>"Subject: test\r\n\r\n"}>]
      data = imap.uid_fetch(98, ["RFC822.SIZE", "INTERNALDATE"])[0]
      p data.seqno
      #=> 6
      p data.attr["RFC822.SIZE"]
      #=> 611
      p data.attr["INTERNALDATE"]
      #=> "12-Oct-2000 22:40:59 +0900"
      p data.attr["UID"]
      #=> 98

[Source]

    # File net/imap.rb, line 697
        def fetch(set, attr)
          return fetch_internal("FETCH", set, attr)
        end

uid_fetch(set, attr)

As for fetch(), but `set` contains unique identifiers.

[Source]

    # File net/imap.rb, line 702
        def uid_fetch(set, attr)
          return fetch_internal("UID FETCH", set, attr)
        end

store(set, attr, flags)

Sends a STORE command to alter data associated with messages in the mailbox, in particular their flags. The `set` parameter is a number or an array of numbers or a Range object. Each number is a message sequence number. `attr` is the name of a data item to store: ‘FLAGS’ means to replace the message’s flag list with the provided one; ’+FLAGS’ means to add the provided flags; and ’-FLAGS’ means to remove them. `flags` is a list of flags.

The return value is an array of Net::IMAP::FetchData. For example:

      p imap.store(6..8, "+FLAGS", [:Deleted])
      #=> [#<Net::IMAP::FetchData seqno=6, attr={"FLAGS"=>[:Seen, :Deleted]}>, \\
           #<Net::IMAP::FetchData seqno=7, attr={"FLAGS"=>[:Seen, :Deleted]}>, \\
           #<Net::IMAP::FetchData seqno=8, attr={"FLAGS"=>[:Seen, :Deleted]}>]

[Source]

    # File net/imap.rb, line 720
        def store(set, attr, flags)
          return store_internal("STORE", set, attr, flags)
        end

uid_store(set, attr, flags)

As for store(), but `set` contains unique identifiers.

[Source]

    # File net/imap.rb, line 725
        def uid_store(set, attr, flags)
          return store_internal("UID STORE", set, attr, flags)
        end

copy(set, mailbox)

Sends a COPY command to copy the specified message(s) to the end of the specified destination `mailbox`. The `set` parameter is a number or an array of numbers or a Range object. The number is a message sequence number.

[Source]

    # File net/imap.rb, line 733
        def copy(set, mailbox)
          copy_internal("COPY", set, mailbox)
        end

uid_copy(set, mailbox)

As for copy(), but `set` contains unique identifiers.

[Source]

    # File net/imap.rb, line 738
        def uid_copy(set, mailbox)
          copy_internal("UID COPY", set, mailbox)
        end

sort(sort_keys, search_keys, charset)

Sends a SORT command to sort messages in the mailbox. Returns an array of message sequence numbers. For example:

      p imap.sort(["FROM"], ["ALL"], "US-ASCII")
      #=> [1, 2, 3, 5, 6, 7, 8, 4, 9]
      p imap.sort(["DATE"], ["SUBJECT", "hello"], "US-ASCII")
      #=> [6, 7, 8, 1]

See [SORT-THREAD-EXT] for more details.

[Source]

    # File net/imap.rb, line 751
        def sort(sort_keys, search_keys, charset)
          return sort_internal("SORT", sort_keys, search_keys, charset)
        end

uid_sort(sort_keys, search_keys, charset)

As for sort(), but returns an array of unique identifiers.

[Source]

    # File net/imap.rb, line 756
        def uid_sort(sort_keys, search_keys, charset)
          return sort_internal("UID SORT", sort_keys, search_keys, charset)
        end

add_response_handler(handler = Proc.new)

Adds a response handler. For example, to detect when the server sends us a new EXISTS response (which normally indicates new messages being added to the mail box), you could add the following handler after selecting the mailbox.

      imap.add_response_handler { |resp|
        if resp.kind_of?(Net::IMAP::UntaggedResponse) and resp.name == "EXISTS"
          puts "Mailbox now has #{resp.data} messages"
        end
      }

[Source]

    # File net/imap.rb, line 772
        def add_response_handler(handler = Proc.new)
          @response_handlers.push(handler)
        end

remove_response_handler(handler)

Removes the response handler.

[Source]

    # File net/imap.rb, line 777
        def remove_response_handler(handler)
          @response_handlers.delete(handler)
        end

thread(algorithm, search_keys, charset)

As for search(), but returns message sequence numbers in threaded format, as a Net::IMAP::ThreadMember tree. The supported algorithms are:

ORDEREDSUBJECT: | split into single-level threads according to subject, ordered by date.
REFERENCES: | split into threads by parent/child relationships determined by which message is a reply to which.

Unlike search(), `charset` is a required argument. US-ASCII and UTF-8 are sample values.

See [SORT-THREAD-EXT] for more details.

[Source]

    # File net/imap.rb, line 794
        def thread(algorithm, search_keys, charset)
          return thread_internal("THREAD", algorithm, search_keys, charset)
        end

uid_thread(algorithm, search_keys, charset)

As for thread(), but returns unique identifiers instead of message sequence numbers.

[Source]

    # File net/imap.rb, line 800
        def uid_thread(algorithm, search_keys, charset)
          return thread_internal("UID THREAD", algorithm, search_keys, charset)
        end

[Validate]