Net::IMAP

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, Net::IMAP::CramMD5Authenticator, and Net::IMAP::DigestMD5Authenticator for examples.

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

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

Returns the debug mode.

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

Sets the debug mode.

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

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

 
               # File net/imap.rb, line 1000
def self.decode_utf7(s)
  return s.gsub(/&([^-]+)?-/n) {
    if $1
      ($1.tr(",", "/") + "===").unpack1("m").encode(Encoding::UTF_8, Encoding::UTF_16BE)
    else
      "&"
    end
  }
end
            

The default port for IMAP connections, port 143

 
               # File net/imap.rb, line 306
def self.default_port
  return PORT
end
            

The default port for IMAPS connections, port 993

 
               # File net/imap.rb, line 311
def self.default_tls_port
  return SSL_PORT
end
            

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

 
               # File net/imap.rb, line 1011
def self.encode_utf7(s)
  return s.gsub(/(&)|[^\x20-\x7e]+/) {
    if $1
      "&-"
    else
      base64 = [$&.encode(Encoding::UTF_16BE)].pack("m0")
      "&" + base64.delete("=").tr("/", ",") + "-"
    end
  }.force_encoding("ASCII-8BIT")
end
            

Formats time as an IMAP-style date.

 
               # File net/imap.rb, line 1023
def self.format_date(time)
  return time.strftime('%d-%b-%Y')
end
            

Formats time as an IMAP-style date-time.

 
               # File net/imap.rb, line 1028
def self.format_datetime(time)
  return time.strftime('%d-%b-%Y %H:%M %z')
end
            

Returns the max number of flags interned to symbols.

 
               # File net/imap.rb, line 281
def self.max_flag_count
  return @@max_flag_count
end
            

Sets the max number of flags interned to symbols.

 
               # File net/imap.rb, line 286
def self.max_flag_count=(count)
  @@max_flag_count = count
end
            

Creates a new Net::IMAP object and connects it to the specified host.

options is an option hash, each key of which is a symbol.

The available options are:

port

Port number (default value is 143 for imap, or 993 for imaps)

ssl

If options 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. If options is a hash, it's passed to OpenSSL::SSL::SSLContext#set_params as parameters.

open_timeout

Seconds to wait until a connection is opened

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::ENETUNREACH

There is no route to that network.

SocketError

Hostname not known or other socket error.

Net::IMAP::ByeResponseError

The connected to the host was successful, but it immediately said goodbye.

 
               # File net/imap.rb, line 1071
def initialize(host, port_or_options = {},
               usessl = false, certs = nil, verify = true)
  super()
  @host = host
  begin
    options = port_or_options.to_hash
  rescue NoMethodError
    # for backward compatibility
    options = {}
    options[:port] = port_or_options
    if usessl
      options[:ssl] = create_ssl_params(certs, verify)
    end
  end
  @port = options[:port] || (options[:ssl] ? SSL_PORT : PORT)
  @tag_prefix = "RUBY"
  @tagno = 0
  @open_timeout = options[:open_timeout] || 30
  @parser = ResponseParser.new
  @sock = tcp_socket(@host, @port)
  begin
    if options[:ssl]
      start_tls_session(options[:ssl])
      @usessl = true
    else
      @usessl = false
    end
    @responses = Hash.new([].freeze)
    @tagged_responses = {}
    @response_handlers = []
    @tagged_response_arrival = new_cond
    @continued_command_tag = nil
    @continuation_request_arrival = new_cond
    @continuation_request_exception = nil
    @idle_done_cond = nil
    @logout_command_tag = nil
    @debug_output_bol = true
    @exception = nil

    @greeting = get_response
    if @greeting.nil?
      raise Error, "connection closed"
    end
    if @greeting.name == "BYE"
      raise ByeResponseError, @greeting
    end

    @client_thread = Thread.current
    @receiver_thread = Thread.start {
      begin
        receive_responses
      rescue Exception
      end
    }
    @receiver_thread_terminating = false
  rescue Exception
    @sock.close
    raise
  end
end
            

Adds a response handler. For example, to detect when the server sends a new EXISTS response (which normally indicates new messages being added to the mailbox), 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
}

 
               # File net/imap.rb, line 906
def add_response_handler(handler = nil, &block)
  raise ArgumentError, "two Procs are passed" if handler && block
  @response_handlers.push(block || handler)
end
            

Sends a APPEND command to append the message to the end of the mailbox. The optional flags argument is an array of flags initially passed 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.

 
               # File net/imap.rb, line 699
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
            

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 the 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 of these mechanisms, there should be two args: username and (cleartext) password. A server may not support one or the 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.

 
               # File net/imap.rb, line 417
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])
      s = [data].pack("m0")
      send_string_data(s)
      put_string(CRLF)
    end
  end
end
            

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.

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

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.

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

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.

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

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

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

Sends a CREATE command to create a new mailbox.

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

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

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.

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

Disconnects from the server.

 
               # File net/imap.rb, line 322
def disconnect
  return if disconnected?
  begin
    begin
      # try to call SSL::SSLSocket#io.
      @sock.io.shutdown
    rescue NoMethodError
      # @sock is not an SSL::SSLSocket.
      @sock.shutdown
    end
  rescue Errno::ENOTCONN
    # ignore `Errno::ENOTCONN: Socket is not connected' on some platforms.
  rescue Exception => e
    @receiver_thread.raise(e)
  end
  @receiver_thread.join
  synchronize do
    @sock.close
  end
  raise e if e
end
            

Returns true if disconnected from the server.

 
               # File net/imap.rb, line 345
def disconnected?
  return @sock.closed?
end
            

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.

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

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

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

Sends a FETCH command to retrieve data associated with a message in the mailbox.

The set parameter is a number or a range between two numbers, or an array of those. The number is a message sequence number, where -1 represents a '*' for use in range notation like 100..-1 being interpreted as '100:*'. Beware that the exclude_end? property of a Range object is ignored, and the contents of a range are independent of the order of the range endpoints as per the protocol specification, so 1…5, 5..1 and 5…1 are all equivalent to 1..5.

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 or nil (instead of an empty array) if there is no matching message.

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

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

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

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

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 is generally only available to server admin.

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

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

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

Sends an IDLE command that waits for notifications of new or expunged messages. Yields responses from the server during the IDLE.

Use idle_done() to leave IDLE.

If timeout is given, this method returns after timeout seconds passed. timeout can be used for keep-alive. For example, the following code checks the connection for each 60 seconds.

loop do
  imap.idle(60) do |res|
    ...
  end
end

 
               # File net/imap.rb, line 953
def idle(timeout = nil, &response_handler)
  raise LocalJumpError, "no block given" unless response_handler

  response = nil

  synchronize do
    tag = Thread.current[:net_imap_tag] = generate_tag
    put_string("#{tag} IDLE#{CRLF}")

    begin
      add_response_handler(&response_handler)
      @idle_done_cond = new_cond
      @idle_done_cond.wait(timeout)
      @idle_done_cond = nil
      if @receiver_thread_terminating
        raise @exception || Net::IMAP::Error.new("connection closed")
      end
    ensure
      unless @receiver_thread_terminating
        remove_response_handler(response_handler)
        put_string("DONE#{CRLF}")
        response = get_tagged_response(tag, "IDLE")
      end
    end
  end

  return response
end
            

Leaves IDLE.

 
               # File net/imap.rb, line 983
def idle_done
  synchronize do
    if @idle_done_cond.nil?
      raise Net::IMAP::Error, "not during IDLE"
    end
    @idle_done_cond.signal
  end
end
            

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 wildcards) 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">]

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

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.

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

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

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

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.

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

Sends a MOVE command to move the specified message(s) to the end of the specified destination mailbox. The set parameter is a number, an array of numbers, or a Range object. The number is a message sequence number. The IMAP MOVE extension is described in [RFC-6851].

 
               # File net/imap.rb, line 867
def move(set, mailbox)
  copy_internal("MOVE", set, mailbox)
end
            

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

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

Removes the response handler.

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

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.

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

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]

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

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[-1], and the number of recent messages from @responses[-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.

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

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

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

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 a server admin for this to work. The IMAP quota commands are described in [RFC-2087].

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

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.

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

Sends a STARTTLS command to start TLS session.

 
               # File net/imap.rb, line 378
def starttls(options = {}, verify = true)
  send_command("STARTTLS") do |resp|
    if resp.kind_of?(TaggedResponse) && resp.name == "OK"
      begin
        # for backward compatibility
        certs = options.to_str
        options = create_ssl_params(certs, verify)
      rescue NoMethodError
      end
      start_tls_session(options)
    end
  end
end
            

Sends a STATUS command, and returns the status of the indicated mailbox. attr is a list of one or more attributes whose statuses are to be requested. 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.

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

Sends a STORE command to alter data associated with messages in the mailbox, in particular their flags. The set parameter is a number, 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' will replace the message's flag list with the provided one, '+FLAGS' will add the provided flags, and '-FLAGS' will 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]}>]

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

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.

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

Similar to 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.

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

Similar to copy(), but set contains unique identifiers.

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

Similar to fetch(), but set contains unique identifiers.

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

Similar to move(), but set contains unique identifiers.

 
               # File net/imap.rb, line 872
def uid_move(set, mailbox)
  copy_internal("UID MOVE", set, mailbox)
end
            

Similar to search(), but returns unique identifiers.

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

Similar to sort(), but returns an array of unique identifiers.

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

Similar to store(), but set contains unique identifiers.

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

Similar to thread(), but returns unique identifiers instead of message sequence numbers.

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

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.

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

Sends a XLIST 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 wildcards) 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 XLIST command is like the LIST command except that the flags returned refer to the function of the folder/mailbox, e.g. :Sent

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

imap.create("foo/bar")
imap.create("foo/baz")
p imap.xlist("", "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">]

 
               # File net/imap.rb, line 578
def xlist(refname, mailbox)
  synchronize do
    send_command("XLIST", refname, mailbox)
    return @responses.delete("XLIST")
  end
end