Class: Net::IMAP
Relationships & Source Files | |
Namespace Children | |
Modules:
| |
Classes:
Address,
BodyTypeAttachment,
BodyTypeBasic,
BodyTypeExtension,
BodyTypeMessage,
BodyTypeMultipart,
BodyTypeText,
ContentDisposition,
ContinuationRequest,
CramMD5Authenticator,
DigestMD5Authenticator,
Envelope,
FetchData,
LoginAuthenticator,
MailboxACLItem,
MailboxList,
MailboxQuota,
MailboxQuotaRoot,
PlainAuthenticator,
ResponseCode,
ResponseParser,
ResponseText,
StatusData,
TaggedResponse,
ThreadMember,
UntaggedResponse
| |
Exceptions:
| |
Super Chains via Extension / Inclusion / Inheritance | |
Instance Chain:
self,
SSL,
OpenSSL,
MonitorMixin
|
|
Inherits: | Object |
Defined in: | lib/net/imap.rb |
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 ||
envelope = imap.fetch(, "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 ||
imap.copy(, "Mail/sent-apr03")
imap.store(, "+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]
-
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]
-
- [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
-
ANSWERED =
Flag indicating a message has been answered.
:Answered
-
DATE_MONTH =
# File 'lib/net/imap.rb', line 1359%w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
-
DELETED =
Flag indicating a message has been marked for deletion. This will occur when the mailbox is closed or expunged.
:Deleted
-
DRAFT =
Flag indicating a message is only a draft or work-in-progress version.
:Draft
-
FLAGGED =
Flag indicating a message has been flagged for special or urgent attention.
:Flagged
-
MARKED =
Flag indicating that a mailbox has been marked “interesting” by the server; this commonly indicates that the mailbox contains new messages.
:Marked
-
NOINFERIORS =
Flag indicating that a mailbox context name cannot contain children.
:Noinferiors
-
NOSELECT =
Flag indicating that a mailbox is not selected.
:Noselect
-
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.
:Recent
-
SEEN =
Flag indicating a message has been seen.
:Seen
-
UNMARKED =
Flag indicating that the mailbox does not contains new messages.
:Unmarked
Class Attribute Summary
-
.debug
rw
Returns the debug mode.
-
.debug=(val)
rw
Sets the debug mode.
-
.max_flag_count
rw
Returns the max number of flags interned to symbols.
-
.max_flag_count=(count)
rw
Sets the max number of flags interned to symbols.
Class Method Summary
-
.add_authenticator(auth_type, authenticator)
Adds an authenticator for #authenticate.
-
.decode_utf7(s)
Decode a string from modified UTF-7 format to UTF-8.
-
.default_imap_port
Alias for .default_port.
-
.default_imaps_port
Alias for .default_tls_port.
-
.default_port
(also: .default_imap_port)
The default port for
IMAP
connections, port 143. -
.default_ssl_port
Alias for .default_tls_port.
-
.default_tls_port
(also: .default_imaps_port, .default_ssl_port)
The default port for IMAPS connections, port 993.
-
.encode_utf7(s)
Encode a string from UTF-8 format to modified UTF-7.
-
.format_date(time)
Formats
time
as an IMAP-style date. -
.format_datetime(time)
Formats
time
as an IMAP-style date-time. -
.new(host, options = {}) ⇒ IMAP
constructor
private
Creates a new
IMAP
object and connects it to the specifiedhost
.
Instance Attribute Summary
-
#client_thread
rw
The thread to receive exceptions.
-
#disconnected? ⇒ Boolean
readonly
Returns true if disconnected from the server.
-
#greeting
readonly
Returns an initial greeting response from the server.
-
#response_handlers
readonly
Returns all response handlers.
-
#responses
readonly
Returns recorded untagged responses.
Instance Method Summary
-
#add_response_handler(handler = Proc.new)
Adds a response handler.
-
#append(mailbox, message, flags = nil, date_time = nil)
Sends a APPEND command to append the
message
to the end of themailbox
. -
#authenticate(auth_type, *args)
Sends an AUTHENTICATE command to authenticate the client.
-
#capability
Sends a CAPABILITY command, and returns an array of capabilities that the server supports.
-
#check
Sends a CHECK command to request a checkpoint of the currently selected mailbox.
-
#close
Sends a CLOSE command to close the currently selected mailbox.
-
#copy(set, mailbox)
Sends a COPY command to copy the specified message(s) to the end of the specified destination
mailbox
. -
#create(mailbox)
Sends a CREATE command to create a new
mailbox
. -
#delete(mailbox)
Sends a DELETE command to remove the
mailbox
. -
#disconnect
Disconnects from the server.
-
#examine(mailbox)
Sends a EXAMINE command to select a
mailbox
so that messages in themailbox
can be accessed. -
#expunge
Sends a EXPUNGE command to permanently remove from the currently selected mailbox all messages that have the Deleted flag set.
-
#fetch(set, attr)
Sends a FETCH command to retrieve data associated with a message in the mailbox.
-
#getacl(mailbox)
Send the GETACL command along with a specified
mailbox
. -
#getquota(mailbox)
Sends the GETQUOTA command along with specified
mailbox
. -
#getquotaroot(mailbox)
Sends the GETQUOTAROOT command along with the specified
mailbox
. -
#idle(timeout = nil, &response_handler)
Sends an IDLE command that waits for notifications of new or expunged messages.
-
#idle_done
Leaves IDLE.
-
#list(refname, mailbox)
Sends a LIST command, and returns a subset of names from the complete set of all names available to the client.
-
#login(user, password)
Sends a LOGIN command to identify the client and carries the plaintext
password
authenticating thisuser
. -
#logout
Sends a LOGOUT command to inform the server that the client is done with the connection.
-
#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
andmailbox
are interpreted as for #list(). -
#move(set, mailbox)
Sends a MOVE command to move the specified message(s) to the end of the specified destination
mailbox
. -
#noop
Sends a NOOP command to the server.
-
#remove_response_handler(handler)
Removes the response handler.
-
#rename(mailbox, newname)
Sends a RENAME command to change the name of the
mailbox
tonewname
. -
#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.
-
#select(mailbox)
Sends a SELECT command to select a
mailbox
so that messages in themailbox
can be accessed. -
#setacl(mailbox, user, rights)
Sends the SETACL command along with
mailbox
,user
and therights
that user is to have on that mailbox. -
#setquota(mailbox, quota)
Sends a SETQUOTA command along with the specified
mailbox
andquota
. -
#sort(sort_keys, search_keys, charset)
Sends a SORT command to sort messages in the mailbox.
-
#starttls(options = {}, verify = true)
Sends a STARTTLS command to start TLS session.
-
#status(mailbox, attr)
Sends a STATUS command, and returns the status of the indicated
mailbox
. -
#store(set, attr, flags)
Sends a STORE command to alter data associated with messages in the mailbox, in particular their flags.
-
#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(). -
#thread(algorithm, search_keys, charset)
Similar to #search(), but returns message sequence numbers in threaded format, as a ThreadMember tree.
-
#uid_copy(set, mailbox)
Similar to #copy(), but
set
contains unique identifiers. -
#uid_fetch(set, attr)
Similar to #fetch(), but
set
contains unique identifiers. -
#uid_move(set, mailbox)
Similar to #move(), but
set
contains unique identifiers. -
#uid_search(keys, charset = nil)
Similar to #search(), but returns unique identifiers.
-
#uid_sort(sort_keys, search_keys, charset)
Similar to #sort(), but returns an array of unique identifiers.
-
#uid_store(set, attr, flags)
Similar to #store(), but
set
contains unique identifiers. -
#uid_thread(algorithm, search_keys, charset)
Similar to #thread(), but returns unique identifiers instead of message sequence numbers.
-
#unsubscribe(mailbox)
Sends a UNSUBSCRIBE command to remove the specified
mailbox
name from the server's set of “active” or “subscribed” mailboxes. -
#xlist(refname, mailbox)
Sends a XLIST command, and returns a subset of names from the complete set of all names available to the client.
- #copy_internal(cmd, set, mailbox) private
- #create_ssl_params(certs = nil, verify = true) private
- #fetch_internal(cmd, set, attr) private
- #generate_tag private
- #get_response private
- #get_tagged_response(tag, cmd) private
- #normalize_searching_criteria(keys) private
- #put_string(str) private
- #receive_responses private
- #record_response(name, data) private
- #search_internal(cmd, keys, charset) private
- #send_command(cmd, *args, &block) private
- #send_data(data) private
- #send_list_data(list) private
- #send_literal(str) private
- #send_number_data(num) private
- #send_quoted_string(str) private
- #send_string_data(str) private
- #send_symbol_data(symbol) private
- #send_time_data(time) private
- #sort_internal(cmd, sort_keys, search_keys, charset) private
- #start_tls_session(params = {}) private
- #store_internal(cmd, set, attr, flags) private
- #thread_internal(cmd, algorithm, search_keys, charset) private
- #validate_data(data) private
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.
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 'lib/net/imap.rb', line 1064
def initialize(host, = {}, usessl = false, certs = nil, verify = true) super() @host = host begin = .to_hash rescue NoMethodError # for backward compatibility = {} [:port] = if usessl [:ssl] = create_ssl_params(certs, verify) end end @port = [:port] || ( [:ssl] ? SSL_PORT : PORT) @tag_prefix = "RUBY" @tagno = 0 @parser = ResponseParser.new @sock = TCPSocket.open(@host, @port) begin if [:ssl] start_tls_session( [:ssl]) @usessl = true else @usessl = false end @responses = Hash.new([].freeze) @tagged_responses = {} @response_handlers = [] @tagged_response_arrival = new_cond @continuation_request_arrival = new_cond @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.
# File 'lib/net/imap.rb', line 265
def self.debug return @@debug end
.debug=(val) (rw)
Sets the debug mode.
# File 'lib/net/imap.rb', line 270
def self.debug=(val) return @@debug = val end
.max_flag_count (rw)
Returns the max number of flags interned to symbols.
# File 'lib/net/imap.rb', line 275
def self.max_flag_count return @@max_flag_count end
.max_flag_count=(count) (rw)
Sets the max number of flags interned to symbols.
# File 'lib/net/imap.rb', line 280
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.
# File 'lib/net/imap.rb', line 295
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.
# File 'lib/net/imap.rb', line 994
def self.decode_utf7(s) return s.gsub(/&([^-]+)?-/n) { if $1 ($1.tr(",", "/") + "===").unpack("m")[0].encode(Encoding::UTF_8, Encoding::UTF_16BE) else "&" end } end
.default_imap_port
Alias for .default_port.
# File 'lib/net/imap.rb', line 310
alias default_imap_port default_port
.default_imaps_port
Alias for .default_tls_port.
# File 'lib/net/imap.rb', line 311
alias default_imaps_port default_tls_port
.default_port Also known as: .default_imap_port
The default port for IMAP
connections, port 143
# File 'lib/net/imap.rb', line 300
def self.default_port return PORT end
.default_ssl_port
Alias for .default_tls_port.
# File 'lib/net/imap.rb', line 312
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
# File 'lib/net/imap.rb', line 305
def self.default_tls_port return SSL_PORT end
.encode_utf7(s)
Encode a string from UTF-8 format to modified UTF-7.
# File 'lib/net/imap.rb', line 1005
def self.encode_utf7(s) return s.gsub(/(&)|[^\x20-\x7e]+/) { if $1 "&-" else base64 = [$&.encode(Encoding::UTF_16BE)].pack("m") "&" + base64.delete("=\n").tr("/", ",") + "-" end }.force_encoding("ASCII-8BIT") end
.format_date(time)
Formats time
as an IMAP-style date.
# File 'lib/net/imap.rb', line 1017
def self.format_date(time) return time.strftime('%d-%b-%Y') end
.format_datetime(time)
Formats time
as an IMAP-style date-time.
# File 'lib/net/imap.rb', line 1022
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.
# File 'lib/net/imap.rb', line 225
attr_accessor :client_thread
#disconnected? ⇒ Boolean
(readonly)
Returns true if disconnected from the server.
# File 'lib/net/imap.rb', line 340
def disconnected? return @sock.closed? end
#greeting (readonly)
Returns an initial greeting response from the server.
# File 'lib/net/imap.rb', line 210
attr_reader :greeting
#response_handlers (readonly)
Returns all response handlers.
# File 'lib/net/imap.rb', line 222
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
# File 'lib/net/imap.rb', line 219
attr_reader :responses
Instance Method Details
#add_response_handler(handler = Proc.new)
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 'lib/net/imap.rb', line 901
def add_response_handler(handler = Proc.new) @response_handlers.push(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.
# File 'lib/net/imap.rb', line 694
def append(mailbox, , flags = nil, date_time = nil) args = [] if flags args.push(flags) end args.push(date_time) if date_time args.push(Literal.new( )) 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.
# File 'lib/net/imap.rb', line 412
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("m").gsub(/\n/, "") 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.
# File 'lib/net/imap.rb', line 354
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.
# File 'lib/net/imap.rb', line 708
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.
# File 'lib/net/imap.rb', line 715
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.
# File 'lib/net/imap.rb', line 848
def copy(set, mailbox) copy_internal("COPY", set, mailbox) end
#copy_internal(cmd, set, mailbox) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1417
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.
# File 'lib/net/imap.rb', line 475
def create(mailbox) send_command("CREATE", mailbox) end
#create_ssl_params(certs = nil, verify = true) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1456
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.
# File 'lib/net/imap.rb', line 484
def delete(mailbox) send_command("DELETE", mailbox) end
#disconnect
Disconnects from the server.
# File 'lib/net/imap.rb', line 316
def disconnect 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 unless @sock.closed? @sock.close end 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.
# File 'lib/net/imap.rb', line 464
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.
# File 'lib/net/imap.rb', line 721
def expunge synchronize do send_command("EXPUNGE") return @responses.delete("EXPUNGE") end 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 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
# File 'lib/net/imap.rb', line 812
def fetch(set, attr) return fetch_internal("FETCH", set, attr) end
#fetch_internal(cmd, set, attr) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1389
def fetch_internal(cmd, set, attr) 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") send_command(cmd, MessageSet.new(set), attr) return @responses.delete("FETCH") end end
#generate_tag (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1259
def generate_tag @tagno += 1 return format("%s%04d", @tag_prefix, @tagno) end
#get_response (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1204
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 1188
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.
# File 'lib/net/imap.rb', line 634
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.
# File 'lib/net/imap.rb', line 598
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.
# File 'lib/net/imap.rb', line 584
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
# File 'lib/net/imap.rb', line 947
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 Net::IMAP::Error, "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.
#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">]
# File 'lib/net/imap.rb', line 541
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.
# File 'lib/net/imap.rb', line 435
def login(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.
# File 'lib/net/imap.rb', line 368
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.
# File 'lib/net/imap.rb', line 646
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].
# File 'lib/net/imap.rb', line 862
def move(set, mailbox) copy_internal("MOVE", set, mailbox) end
#noop
Sends a NOOP command to the server. It does nothing.
# File 'lib/net/imap.rb', line 362
def noop send_command("NOOP") end
#normalize_searching_criteria(keys) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1445
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 1264
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 1122
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 if resp.tag == @logout_command_tag return 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 1224
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.
# File 'lib/net/imap.rb', line 906
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
.
# File 'lib/net/imap.rb', line 495
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]
# File 'lib/net/imap.rb', line 768
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 1373
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.
# File 'lib/net/imap.rb', line 451
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 1231
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) 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) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1296
def send_data(data) case data when nil put_string("NIL") when String send_string_data(data) when Integer send_number_data(data) when Array send_list_data(data) when Time send_time_data(data) when Symbol send_symbol_data(data) else data.send_data(self) end end
#send_list_data(list) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1345
def send_list_data(list) put_string("(") first = true list.each do |i| if first first = false else put_string(" ") end send_data(i) end put_string(")") end
#send_literal(str) (private)
# File 'lib/net/imap.rb', line 1334
def send_literal(str) put_string("{" + str.bytesize.to_s + "}" + CRLF) @continuation_request_arrival.wait raise @exception if @exception put_string(str) end
#send_number_data(num) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1341
def send_number_data(num) put_string(num.to_s) end
#send_quoted_string(str) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1330
def send_quoted_string(str) put_string('"' + str.gsub(/["\\]/n, "\\\\\\&") + '"') end
#send_string_data(str) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1315
def send_string_data(str) case str when "" put_string('""') when /[\x80-\xff\r\n]/n # literal send_literal(str) 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 1369
def send_symbol_data(symbol) put_string("\\" + symbol.to_s) end
#send_time_data(time) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1361
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].
# File 'lib/net/imap.rb', line 623
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].
# File 'lib/net/imap.rb', line 610
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.
# File 'lib/net/imap.rb', line 880
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 1421
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 1473
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.connect 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.
# File 'lib/net/imap.rb', line 373
def starttls( = {}, verify = true) send_command("STARTTLS") do |resp| if resp.kind_of?(TaggedResponse) && resp.name == "OK" begin # for backward compatibility certs = .to_str = create_ssl_params(certs, verify) rescue NoMethodError end start_tls_session( ) 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.
# File 'lib/net/imap.rb', line 669
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]}>]
# File 'lib/net/imap.rb', line 835
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 1406
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.
# File 'lib/net/imap.rb', line 505
def subscribe(mailbox) send_command("SUBSCRIBE", mailbox) 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.
# File 'lib/net/imap.rb', line 923
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 1434
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.
# File 'lib/net/imap.rb', line 853
def uid_copy(set, mailbox) copy_internal("UID COPY", set, mailbox) end
#uid_fetch(set, attr)
Similar to #fetch(), but set
contains unique identifiers.
# File 'lib/net/imap.rb', line 817
def uid_fetch(set, attr) return fetch_internal("UID FETCH", set, attr) end
#uid_move(set, mailbox)
Similar to #move(), but set
contains unique identifiers.
# File 'lib/net/imap.rb', line 867
def uid_move(set, mailbox) copy_internal("UID MOVE", set, mailbox) end
#uid_search(keys, charset = nil)
Similar to #search(), but returns unique identifiers.
# File 'lib/net/imap.rb', line 773
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.
# File 'lib/net/imap.rb', line 885
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.
# File 'lib/net/imap.rb', line 840
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.
# File 'lib/net/imap.rb', line 929
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.
# File 'lib/net/imap.rb', line 515
def unsubscribe(mailbox) send_command("UNSUBSCRIBE", mailbox) end
#validate_data(data) (private)
[ GitHub ]# File 'lib/net/imap.rb', line 1279
def validate_data(data) case data when nil when String when Integer NumValidator.ensure_number(data) when Array data.each do |i| validate_data(i) 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">]
# File 'lib/net/imap.rb', line 573
def xlist(refname, mailbox) synchronize do send_command("XLIST", refname, mailbox) return @responses.delete("XLIST") end end