123456789_123456789_123456789_123456789_123456789_

Class: Net::IMAP

Overview

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 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 mailbox from 1 up to the number of items in the mailbox. If a new message arrives during a session, it receives a sequence number equal to the new size of the mailbox. 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 thus cannot 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 Safety

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 exist; 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 your 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 NoResponseError, BadResponseError, and ByeResponseError, all of which are subclasses of 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 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 ResponseParseError is thrown if a server response is non-parseable.

References

[IMAP]
  1. 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.

Constant Summary

Class Attribute Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(host, options = {}) ⇒ IMAP (private)

Creates a new 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.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1073

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

Class Attribute Details

.debug (rw)

Returns the debug mode.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 273

def self.debug
  return @@debug
end

.debug=(val) (rw)

Sets the debug mode.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 278

def self.debug=(val)
  return @@debug = val
end

.max_flag_count (rw)

Returns the max number of flags interned to symbols.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 283

def self.max_flag_count
  return @@max_flag_count
end

.max_flag_count=(count) (rw)

Sets the max number of flags interned to symbols.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 288

def self.max_flag_count=(count)
  @@max_flag_count = count
end

Class Method Details

.add_authenticator(auth_type, authenticator)

Adds an authenticator for #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 IMAP::LoginAuthenticator, IMAP::CramMD5Authenticator, and IMAP::DigestMD5Authenticator for examples.

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 303

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.

IMAP does not automatically encode and decode mailbox names to and from UTF-7.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1002

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

.default_imap_port

Alias for .default_port.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 318

alias default_imap_port default_port

.default_imaps_port

Alias for .default_tls_port.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 319

alias default_imaps_port default_tls_port

.default_port Also known as: .default_imap_port

The default port for IMAP connections, port 143

[ GitHub ]

  
# File 'lib/net/imap.rb', line 308

def self.default_port
  return PORT
end

.default_ssl_port

Alias for .default_tls_port.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 320

alias default_ssl_port default_tls_port

.default_tls_port Also known as: .default_imaps_port, .default_ssl_port

The default port for IMAPS connections, port 993

[ GitHub ]

  
# File 'lib/net/imap.rb', line 313

def self.default_tls_port
  return SSL_PORT
end

.encode_utf7(s)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1013

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

.format_date(time)

Formats time as an IMAP-style date.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1025

def self.format_date(time)
  return time.strftime('%d-%b-%Y')
end

.format_datetime(time)

Formats time as an IMAP-style date-time.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1030

def self.format_datetime(time)
  return time.strftime('%d-%b-%Y %H:%M %z')
end

Instance Attribute Details

#client_thread (rw)

The thread to receive exceptions.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 233

attr_accessor :client_thread

#disconnected?Boolean (readonly)

Returns true if disconnected from the server.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 347

def disconnected?
  return @sock.closed?
end

#greeting (readonly)

Returns an initial greeting response from the server.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 213

attr_reader :greeting

#open_timeout (readonly)

Seconds to wait until a connection is opened. If the IMAP object cannot open a connection within this time, it raises a Net::OpenTimeout exception. The default value is 30 seconds.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 230

attr_reader :open_timeout

#response_handlers (readonly)

Returns all response handlers.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 225

attr_reader :response_handlers

#responses (readonly)

Returns recorded untagged responses. For example:

imap.select("inbox")
p imap.responses["EXISTS"][-1]
#=> 2
p imap.responses["UIDVALIDITY"][-1]
#=> 968263756
[ GitHub ]

  
# File 'lib/net/imap.rb', line 222

attr_reader :responses

Instance Method Details

#add_response_handler(handler = nil, &block)

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
}

Raises:

  • (ArgumentError)
[ GitHub ]

  
# File 'lib/net/imap.rb', line 908

def add_response_handler(handler = nil, &block)
  raise ArgumentError, "two Procs are passed" if handler && block
  @response_handlers.push(block || handler)
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 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 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.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 701

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

#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 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 IMAP::NoResponseError is raised if authentication fails.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 419

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

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 361

def capability
  synchronize do
    send_command("CAPABILITY")
    return @responses.delete("CAPABILITY")[-1]
  end
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.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 715

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.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 722

def close
  send_command("CLOSE")
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, an array of numbers, or a Range object. The number is a message sequence number.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 855

def copy(set, mailbox)
  copy_internal("COPY", set, mailbox)
end

#copy_internal(cmd, set, mailbox) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1461

def copy_internal(cmd, set, mailbox)
  send_command(cmd, MessageSet.new(set), mailbox)
end

#create(mailbox)

Sends a CREATE command to create a new mailbox.

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 482

def create(mailbox)
  send_command("CREATE", mailbox)
end

#create_ssl_params(certs = nil, verify = true) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1500

def create_ssl_params(certs = nil, verify = true)
  params = {}
  if certs
    if File.file?(certs)
      params[:ca_file] = certs
    elsif File.directory?(certs)
      params[:ca_path] = certs
    end
  end
  if verify
    params[:verify_mode] = VERIFY_PEER
  else
    params[:verify_mode] = VERIFY_NONE
  end
  return params
end

#delete(mailbox)

Sends a DELETE command to remove the mailbox.

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 491

def delete(mailbox)
  send_command("DELETE", mailbox)
end

#disconnect

Disconnects from the server.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 324

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

#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 IMAP::NoResponseError is raised if the mailbox does not exist or is for some reason non-examinable.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 471

def examine(mailbox)
  synchronize do
    @responses.clear
    send_command("EXAMINE", mailbox)
  end
end

#expunge

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 728

def expunge
  synchronize do
    send_command("EXPUNGE")
    return @responses.delete("EXPUNGE")
  end
end

#fetch(set, attr, mod = nil)

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 IMAP::FetchData for a list of valid attributes.

The return value is an array of 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
[ GitHub ]

  
# File 'lib/net/imap.rb', line 819

def fetch(set, attr, mod = nil)
  return fetch_internal("FETCH", set, attr, mod)
end

#fetch_internal(cmd, set, attr, mod = nil) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1429

def fetch_internal(cmd, set, attr, mod = nil)
  case attr
  when String then
    attr = RawData.new(attr)
  when Array then
    attr = attr.map { |arg|
      arg.is_a?(String) ? RawData.new(arg) : arg
    }
  end

  synchronize do
    @responses.delete("FETCH")
    if mod
      send_command(cmd, MessageSet.new(set), attr, mod)
    else
      send_command(cmd, MessageSet.new(set), attr)
    end
    return @responses.delete("FETCH")
  end
end

#generate_tag (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1285

def generate_tag
  @tagno += 1
  return format("%s%04d", @tag_prefix, @tagno)
end

#get_response (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1230

def get_response
  buff = String.new
  while true
    s = @sock.gets(CRLF)
    break unless s
    buff.concat(s)
    if /\{(\d+)\}\r\n/n =~ s
      s = @sock.read($1.to_i)
      buff.concat(s)
    else
      break
    end
  end
  return nil if buff.length == 0
  if @@debug
    $stderr.print(buff.gsub(/^/n, "S: "))
  end
  return @parser.parse(buff)
end

#get_tagged_response(tag, cmd) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1214

def get_tagged_response(tag, cmd)
  until @tagged_responses.key?(tag)
    raise @exception if @exception
    @tagged_response_arrival.wait
  end
  resp = @tagged_responses.delete(tag)
  case resp.name
  when /\A(?:NO)\z/ni
    raise NoResponseError, resp
  when /\A(?:BAD)\z/ni
    raise BadResponseError, resp
  else
    return resp
  end
end

#getacl(mailbox)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 641

def getacl(mailbox)
  synchronize do
    send_command("GETACL", mailbox)
    return @responses.delete("ACL")[-1]
  end
end

#getquota(mailbox)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 605

def getquota(mailbox)
  synchronize do
    send_command("GETQUOTA", mailbox)
    return @responses.delete("QUOTA")
  end
end

#getquotaroot(mailbox)

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 IMAP::MailboxQuotaRoot and IMAP::MailboxQuota.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 591

def getquotaroot(mailbox)
  synchronize do
    send_command("GETQUOTAROOT", mailbox)
    result = []
    result.concat(@responses.delete("QUOTAROOT"))
    result.concat(@responses.delete("QUOTA"))
    return result
  end
end

#idle(timeout = nil, &response_handler)

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

Raises:

  • (LocalJumpError)
[ GitHub ]

  
# File 'lib/net/imap.rb', line 955

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

#idle_done

Leaves IDLE.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 985

def idle_done
  synchronize do
    if @idle_done_cond.nil?
      raise Net::IMAP::Error, "not during IDLE"
    end
    @idle_done_cond.signal
  end
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 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 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">]
[ GitHub ]

  
# File 'lib/net/imap.rb', line 548

def list(refname, mailbox)
  synchronize do
    send_command("LIST", refname, mailbox)
    return @responses.delete("LIST")
  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 IMAP::NoResponseError is raised if authentication fails.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 442

def (user, password)
  send_command("LOGIN", user, password)
end

#logout

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 375

def logout
  send_command("LOGOUT")
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 IMAP::MailboxList.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 653

def lsub(refname, mailbox)
  synchronize do
    send_command("LSUB", refname, mailbox)
    return @responses.delete("LSUB")
  end
end

#move(set, mailbox)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 869

def move(set, mailbox)
  copy_internal("MOVE", set, mailbox)
end

#noop

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 369

def noop
  send_command("NOOP")
end

#normalize_searching_criteria(keys) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1489

def normalize_searching_criteria(keys)
  keys.collect! do |i|
    case i
    when -1, Range, Array
      MessageSet.new(i)
    else
      i
    end
  end
end

#put_string(str) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1290

def put_string(str)
  @sock.print(str)
  if @@debug
    if @debug_output_bol
      $stderr.print("C: ")
    end
    $stderr.print(str.gsub(/\n(?!\z)/n, "\nC: "))
    if /\r\n\z/n.match(str)
      @debug_output_bol = true
    else
      @debug_output_bol = false
    end
  end
end

#receive_responses (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1143

def receive_responses
  connection_closed = false
  until connection_closed
    synchronize do
      @exception = nil
    end
    begin
      resp = get_response
    rescue Exception => e
      synchronize do
        @sock.close
        @exception = e
      end
      break
    end
    unless resp
      synchronize do
        @exception = EOFError.new("end of file reached")
      end
      break
    end
    begin
      synchronize do
        case resp
        when TaggedResponse
          @tagged_responses[resp.tag] = resp
          @tagged_response_arrival.broadcast
          case resp.tag
          when @logout_command_tag
            return
          when @continued_command_tag
            @continuation_request_exception =
              RESPONSE_ERRORS[resp.name].new(resp)
            @continuation_request_arrival.signal
          end
        when UntaggedResponse
          record_response(resp.name, resp.data)
          if resp.data.instance_of?(ResponseText) &&
              (code = resp.data.code)
            record_response(code.name, code.data)
          end
          if resp.name == "BYE" && @logout_command_tag.nil?
            @sock.close
            @exception = ByeResponseError.new(resp)
            connection_closed = true
          end
        when ContinuationRequest
          @continuation_request_arrival.signal
        end
        @response_handlers.each do |handler|
          handler.call(resp)
        end
      end
    rescue Exception => e
      @exception = e
      synchronize do
        @tagged_response_arrival.broadcast
        @continuation_request_arrival.broadcast
      end
    end
  end
  synchronize do
    @receiver_thread_terminating = true
    @tagged_response_arrival.broadcast
    @continuation_request_arrival.broadcast
    if @idle_done_cond
      @idle_done_cond.signal
    end
  end
end

#record_response(name, data) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1250

def record_response(name, data)
  unless @responses.has_key?(name)
    @responses[name] = []
  end
  @responses[name].push(data)
end

#remove_response_handler(handler)

Removes the response handler.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 914

def remove_response_handler(handler)
  @response_handlers.delete(handler)
end

#rename(mailbox, newname)

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

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 502

def rename(mailbox, newname)
  send_command("RENAME", mailbox, newname)
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]
[ GitHub ]

  
# File 'lib/net/imap.rb', line 775

def search(keys, charset = nil)
  return search_internal("SEARCH", keys, charset)
end

#search_internal(cmd, keys, charset) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1413

def search_internal(cmd, keys, charset)
  if keys.instance_of?(String)
    keys = [RawData.new(keys)]
  else
    normalize_searching_criteria(keys)
  end
  synchronize do
    if charset
      send_command(cmd, "CHARSET", charset, *keys)
    else
      send_command(cmd, *keys)
    end
    return @responses.delete("SEARCH")[-1]
  end
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[-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 IMAP::NoResponseError is raised if the mailbox does not exist or is for some reason non-selectable.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 458

def select(mailbox)
  synchronize do
    @responses.clear
    send_command("SELECT", mailbox)
  end
end

#send_command(cmd, *args, &block) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1257

def send_command(cmd, *args, &block)
  synchronize do
    args.each do |i|
      validate_data(i)
    end
    tag = generate_tag
    put_string(tag + " " + cmd)
    args.each do |i|
      put_string(" ")
      send_data(i, tag)
    end
    put_string(CRLF)
    if cmd == "LOGOUT"
      @logout_command_tag = tag
    end
    if block
      add_response_handler(&block)
    end
    begin
      return get_tagged_response(tag, cmd)
    ensure
      if block
        remove_response_handler(block)
      end
    end
  end
end

#send_data(data, tag = nil) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1326

def send_data(data, tag = nil)
  case data
  when nil
    put_string("NIL")
  when String
    send_string_data(data, tag)
  when Integer
    send_number_data(data)
  when Array
    send_list_data(data, tag)
  when Time
    send_time_data(data)
  when Symbol
    send_symbol_data(data)
  else
    data.send_data(self, tag)
  end
end

#send_list_data(list, tag = nil) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1385

def send_list_data(list, tag = nil)
  put_string("(")
  first = true
  list.each do |i|
    if first
      first = false
    else
      put_string(" ")
    end
    send_data(i, tag)
  end
  put_string(")")
end

#send_literal(str, tag = nil) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1364

def send_literal(str, tag = nil)
  synchronize do
    put_string("{" + str.bytesize.to_s + "}" + CRLF)
    @continued_command_tag = tag
    @continuation_request_exception = nil
    begin
      @continuation_request_arrival.wait
      e = @continuation_request_exception || @exception
      raise e if e
      put_string(str)
    ensure
      @continued_command_tag = nil
      @continuation_request_exception = nil
    end
  end
end

#send_number_data(num) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1381

def send_number_data(num)
  put_string(num.to_s)
end

#send_quoted_string(str) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1360

def send_quoted_string(str)
  put_string('"' + str.gsub(/["\\]/n, "\\\\\\&") + '"')
end

#send_string_data(str, tag = nil) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1345

def send_string_data(str, tag = nil)
  case str
  when ""
    put_string('""')
  when /[\x80-\xff\r\n]/n
    # literal
    send_literal(str, tag)
  when /[(){ \x00-\x1f\x7f%*"\\]/n
    # quoted string
    send_quoted_string(str)
  else
    put_string(str)
  end
end

#send_symbol_data(symbol) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1409

def send_symbol_data(symbol)
  put_string("\\" + symbol.to_s)
end

#send_time_data(time) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1401

def send_time_data(time)
  t = time.dup.gmtime
  s = format('"%2d-%3s-%4d %02d:%02d:%02d +0000"',
             t.day, DATE_MONTH[t.month - 1], t.year,
             t.hour, t.min, t.sec)
  put_string(s)
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].

[ GitHub ]

  
# File 'lib/net/imap.rb', line 630

def setacl(mailbox, user, rights)
  if rights.nil?
    send_command("SETACL", mailbox, user, "")
  else
    send_command("SETACL", mailbox, user, rights)
  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 a server admin for this to work. The IMAP quota commands are described in [RFC-2087].

[ GitHub ]

  
# File 'lib/net/imap.rb', line 617

def setquota(mailbox, quota)
  if quota.nil?
    data = '()'
  else
    data = '(STORAGE ' + quota.to_s + ')'
  end
  send_command("SETQUOTA", mailbox, RawData.new(data))
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.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 887

def sort(sort_keys, search_keys, charset)
  return sort_internal("SORT", sort_keys, search_keys, charset)
end

#sort_internal(cmd, sort_keys, search_keys, charset) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1465

def sort_internal(cmd, sort_keys, search_keys, charset)
  if search_keys.instance_of?(String)
    search_keys = [RawData.new(search_keys)]
  else
    normalize_searching_criteria(search_keys)
  end
  normalize_searching_criteria(search_keys)
  synchronize do
    send_command(cmd, sort_keys, charset, *search_keys)
    return @responses.delete("SORT")[-1]
  end
end

#start_tls_session(params = {}) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1517

def start_tls_session(params = {})
  unless defined?(OpenSSL::SSL)
    raise "SSL extension not installed"
  end
  if @sock.kind_of?(OpenSSL::SSL::SSLSocket)
    raise RuntimeError, "already using SSL"
  end
  begin
    params = params.to_hash
  rescue NoMethodError
    params = {}
  end
  context = SSLContext.new
  context.set_params(params)
  if defined?(VerifyCallbackProc)
    context.verify_callback = VerifyCallbackProc
  end
  @sock = SSLSocket.new(@sock, context)
  @sock.sync_close = true
  @sock.hostname = @host if @sock.respond_to? :hostname=
  ssl_socket_connect(@sock, @open_timeout)
  if context.verify_mode != VERIFY_NONE
    @sock.post_connection_check(@host)
  end
end

#starttls(options = {}, verify = true)

Sends a STARTTLS command to start TLS session.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 380

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

#status(mailbox, attr)

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 IMAP::NoResponseError is raised if status values for mailbox cannot be returned; for instance, because it does not exist.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 676

def status(mailbox, attr)
  synchronize do
    send_command("STATUS", mailbox, attr)
    return @responses.delete("STATUS")[-1].attr
  end
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, 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 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]}>]
[ GitHub ]

  
# File 'lib/net/imap.rb', line 842

def store(set, attr, flags)
  return store_internal("STORE", set, attr, flags)
end

#store_internal(cmd, set, attr, flags) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1450

def store_internal(cmd, set, attr, flags)
  if attr.instance_of?(String)
    attr = RawData.new(attr)
  end
  synchronize do
    @responses.delete("FETCH")
    send_command(cmd, MessageSet.new(set), attr, flags)
    return @responses.delete("FETCH")
  end
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 IMAP::NoResponseError is raised if mailbox cannot be subscribed to; for instance, because it does not exist.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 512

def subscribe(mailbox)
  send_command("SUBSCRIBE", mailbox)
end

#tcp_socket(host, port) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1134

def tcp_socket(host, port)
  s = Socket.tcp(host, port, :connect_timeout => @open_timeout)
  s.setsockopt(:SOL_SOCKET, :SO_KEEPALIVE, true)
  s
rescue Errno::ETIMEDOUT
  raise Net::OpenTimeout, "Timeout to open TCP connection to " +
    "#{host}:#{port} (exceeds #{@open_timeout} seconds)"
end

#thread(algorithm, search_keys, charset)

Similar to #search(), but returns message sequence numbers in threaded format, as a 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.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 931

def thread(algorithm, search_keys, charset)
  return thread_internal("THREAD", algorithm, search_keys, charset)
end

#thread_internal(cmd, algorithm, search_keys, charset) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1478

def thread_internal(cmd, algorithm, search_keys, charset)
  if search_keys.instance_of?(String)
    search_keys = [RawData.new(search_keys)]
  else
    normalize_searching_criteria(search_keys)
  end
  normalize_searching_criteria(search_keys)
  send_command(cmd, algorithm, charset, *search_keys)
  return @responses.delete("THREAD")[-1]
end

#uid_copy(set, mailbox)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 860

def uid_copy(set, mailbox)
  copy_internal("UID COPY", set, mailbox)
end

#uid_fetch(set, attr, mod = nil)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 824

def uid_fetch(set, attr, mod = nil)
  return fetch_internal("UID FETCH", set, attr, mod)
end

#uid_move(set, mailbox)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 874

def uid_move(set, mailbox)
  copy_internal("UID MOVE", set, mailbox)
end

#uid_search(keys, charset = nil)

Similar to #search(), but returns unique identifiers.

[ GitHub ]

  
# File 'lib/net/imap.rb', line 780

def uid_search(keys, charset = nil)
  return search_internal("UID SEARCH", keys, charset)
end

#uid_sort(sort_keys, search_keys, charset)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 892

def uid_sort(sort_keys, search_keys, charset)
  return sort_internal("UID SORT", sort_keys, search_keys, charset)
end

#uid_store(set, attr, flags)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 847

def uid_store(set, attr, flags)
  return store_internal("UID STORE", set, attr, flags)
end

#uid_thread(algorithm, search_keys, charset)

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 937

def uid_thread(algorithm, search_keys, charset)
  return thread_internal("UID THREAD", algorithm, search_keys, charset)
end

#unsubscribe(mailbox)

Sends a UNSUBSCRIBE command to remove the specified mailbox name from the server's set of “active” or “subscribed” mailboxes.

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

[ GitHub ]

  
# File 'lib/net/imap.rb', line 522

def unsubscribe(mailbox)
  send_command("UNSUBSCRIBE", mailbox)
end

#validate_data(data) (private)

[ GitHub ]

  
# File 'lib/net/imap.rb', line 1305

def validate_data(data)
  case data
  when nil
  when String
  when Integer
    NumValidator.ensure_number(data)
  when Array
    if data[0] == 'CHANGEDSINCE'
      NumValidator.ensure_mod_sequence_value(data[1])
    else
      data.each do |i|
        validate_data(i)
      end
    end
  when Time
  when Symbol
  else
    data.validate
  end
end

#xlist(refname, mailbox)

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 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">]
[ GitHub ]

  
# File 'lib/net/imap.rb', line 580

def xlist(refname, mailbox)
  synchronize do
    send_command("XLIST", refname, mailbox)
    return @responses.delete("XLIST")
  end
end