net-imap 0.3.4 → 0.5.6

data/lib/net/imap/fetch_data.rb

@@ -0,0 +1,597 @@
+# frozen_string_literal: true
+
+module Net
+  class IMAP < Protocol
+
+    # Net::IMAP::FetchStruct is the superclass for FetchData and UIDFetchData.
+    # Net::IMAP#fetch, Net::IMAP#uid_fetch, Net::IMAP#store, and
+    # Net::IMAP#uid_store all return arrays of FetchStruct objects.
+    #
+    # === Fetch attributes
+    #
+    # See {[IMAP4rev1 §7.4.2]}[https://www.rfc-editor.org/rfc/rfc3501.html#section-7.4.2]
+    # and {[IMAP4rev2 §7.5.2]}[https://www.rfc-editor.org/rfc/rfc9051.html#section-7.5.2]
+    # for a full description of the standard fetch response data items, and
+    # Net::IMAP@Message+envelope+and+body+structure for other relevant RFCs.
+    #
+    # ==== Static fetch data items
+    #
+    # Most message attributes are static, and must never change for a given
+    # <tt>(server, account, mailbox, UIDVALIDITY, UID)</tt> tuple.
+    #
+    # The static fetch data items defined by both
+    # IMAP4rev1[https://www.rfc-editor.org/rfc/rfc3501.html] and
+    # IMAP4rev2[https://www.rfc-editor.org/rfc/rfc9051.html] are:
+    #
+    # * <b><tt>"UID"</tt></b> --- See #uid.
+    # * <b><tt>"BODY"</tt></b> --- See #body.
+    # * <b><tt>"BODY[#{section_spec}]"</tt></b>,
+    #   <b><tt>"BODY[#{section_spec}]<#{offset}>"</tt></b> --- See #message,
+    #   #part, #header, #header_fields, #header_fields_not, #mime, and #text.
+    # * <b><tt>"BODYSTRUCTURE"</tt></b> --- See #bodystructure.
+    # * <b><tt>"ENVELOPE"</tt></b> --- See #envelope.
+    # * <b><tt>"INTERNALDATE"</tt></b> --- See #internaldate.
+    # * <b><tt>"RFC822.SIZE"</tt></b> --- See #rfc822_size.
+    #
+    # IMAP4rev2[https://www.rfc-editor.org/rfc/rfc9051.html] adds the
+    # additional fetch items from the +BINARY+ extension
+    # {[RFC3516]}[https://www.rfc-editor.org/rfc/rfc3516.html]:
+    #
+    # * <b><tt>"BINARY[#{part}]"</tt></b>,
+    #   <b><tt>"BINARY[#{part}]<#{offset}>"</tt></b> -- See #binary.
+    # * <b><tt>"BINARY.SIZE[#{part}]"</tt></b> -- See #binary_size.
+    #
+    # Several static message attributes in
+    # IMAP4rev1[https://www.rfc-editor.org/rfc/rfc3501.html] are obsolete and
+    # been removed from
+    # IMAP4rev2[https://www.rfc-editor.org/rfc/rfc9051.html]:
+    #
+    # * <b><tt>"RFC822"</tt></b> --- See #rfc822 or replace with
+    #   <tt>"BODY[]"</tt> and #message.
+    # * <b><tt>"RFC822.HEADER"</tt></b> --- See #rfc822_header or replace with
+    #   <tt>"BODY[HEADER]"</tt> and #header.
+    # * <b><tt>"RFC822.TEXT"</tt></b> --- See #rfc822_text or replace with
+    #   <tt>"BODY[TEXT]"</tt> and #text.
+    #
+    # Net::IMAP supports static attributes defined by the following extensions:
+    # * +OBJECTID+ {[RFC8474]}[https://www.rfc-editor.org/rfc/rfc8474.html]
+    #   * <b><tt>"EMAILID"</tt></b> --- See #emailid.
+    #   * <b><tt>"THREADID"</tt></b> --- See #threadid.
+    #
+    # * +X-GM-EXT-1+ {[non-standard Gmail
+    #   extension]}[https://developers.google.com/gmail/imap/imap-extensions]
+    #   * <b><tt>"X-GM-MSGID"</tt></b> --- unique message ID.  Access via #attr.
+    #   * <b><tt>"X-GM-THRID"</tt></b> --- Thread ID.  Access via #attr.
+    #
+    # [NOTE:]
+    #     Additional static fields are defined in other \IMAP extensions, but
+    #     Net::IMAP can't parse them yet.
+    #
+    # ==== Dynamic message attributes
+    #
+    # Some message attributes can be dynamically changed, for example using the
+    # {STORE command}[rdoc-ref:Net::IMAP#store].
+    #
+    # The only dynamic message attribute defined by
+    # IMAP4rev1[https://www.rfc-editor.org/rfc/rfc3501.html] and
+    # IMAP4rev2[https://www.rfc-editor.org/rfc/rfc9051.html] is:
+    #
+    # * <b><tt>"FLAGS"</tt></b> --- See #flags.
+    #
+    # Net::IMAP supports dynamic attributes defined by the following extensions:
+    #
+    # * +CONDSTORE+ {[RFC7162]}[https://www.rfc-editor.org/rfc/rfc7162.html]:
+    #   * <b><tt>"MODSEQ"</tt></b> --- See #modseq.
+    # * +X-GM-EXT-1+ {[non-standard Gmail
+    #   extension]}[https://developers.google.com/gmail/imap/imap-extensions]
+    #   * <b><tt>"X-GM-LABELS"</tt></b> --- Gmail labels.  Access via #attr.
+    #
+    # [NOTE:]
+    #     Additional dynamic fields are defined in other \IMAP extensions, but
+    #     Net::IMAP can't parse them yet.
+    #
+    # === Implicitly setting <tt>\Seen</tt> and using +PEEK+
+    #
+    # Unless the mailbox has been opened as read-only, fetching
+    # <tt>BODY[#{section}]</tt> or <tt>BINARY[#{section}]</tt>
+    # will implicitly set the <tt>\Seen</tt> flag.  To avoid this, fetch using
+    # <tt>BODY.PEEK[#{section}]</tt> or <tt>BINARY.PEEK[#{section}]</tt>
+    # instead.
+    #
+    # [NOTE:]
+    #   The data will always be _returned_ without the <tt>".PEEK"</tt> suffix,
+    #   as <tt>BODY[#{specifier}]</tt> or <tt>BINARY[#{section}]</tt>.
+    #
+    class FetchStruct < Struct
+      ##
+      # method: attr
+      # :call-seq: attr -> hash
+      #
+      # Each key specifies a message attribute, and the value is the
+      # corresponding data item.  Standard data items have corresponding
+      # accessor methods.  The definitions of each attribute type is documented
+      # on its accessor.
+
+      # :call-seq: attr_upcase -> hash
+      #
+      # A transformation of #attr, with all the keys converted to upper case.
+      #
+      # Header field names are case-preserved but not case-sensitive, so this is
+      # used by #header_fields and #header_fields_not.
+      def attr_upcase; attr.transform_keys(&:upcase) end
+
+      # :call-seq:
+      #   body -> body structure or nil
+      #
+      # Returns an alternate form of #bodystructure, without any extension data.
+      #
+      # This is the same as getting the value for <tt>"BODY"</tt> from #attr.
+      #
+      # [NOTE:]
+      #   Use #message, #part, #header, #header_fields, #header_fields_not,
+      #   #text, or #mime to retrieve <tt>BODY[#{section_spec}]</tt> attributes.
+      def body; attr["BODY"] end
+
+      # :call-seq:
+      #   message(offset: bytes) -> string or nil
+      #
+      # The RFC5322[https://www.rfc-editor.org/rfc/rfc5322.html]
+      # expression of the entire message, as a string.
+      #
+      # See #part for a description of +offset+.
+      #
+      # <em>RFC5322 messages can be parsed using the "mail" gem.</em>
+      #
+      # This is the same as getting the value for <tt>"BODY[]"</tt> or
+      # <tt>"BODY[]<#{offset}>"</tt> from #attr.
+      #
+      # See also: #header, #text, and #mime.
+      def message(offset: nil) attr[body_section_attr(offset: offset)] end
+
+      # :call-seq:
+      #   part(*part_nums, offset: bytes) -> string or nil
+      #
+      # The string representation of a particular MIME part.
+      #
+      # +part_nums+ forms a path of MIME part numbers, counting up from +1+,
+      # which may specify an arbitrarily nested part, similarly to Array#dig.
+      # Messages that don't use MIME, or MIME messages that are not multipart
+      # and don't hold an encapsulated message, only have part +1+.
+      #
+      # If a zero-based +offset+ is given, the returned string is a substring of
+      # the entire contents, starting at that origin octet.  This means that
+      # <tt>BODY[]<0></tt> MAY be truncated, but <tt>BODY[]</tt> is never
+      # truncated.
+      #
+      # This is the same as getting the value of
+      # <tt>"BODY[#{part_nums.join(".")}]"</tt> or
+      # <tt>"BODY[#{part_nums.join(".")}]<#{offset}>"</tt> from #attr.
+      #
+      # See also: #message, #header, #text, and #mime.
+      def part(index, *subparts, offset: nil)
+        attr[body_section_attr([index, *subparts], offset: offset)]
+      end
+
+      # :call-seq:
+      #   header(*part_nums,                offset: nil) -> string or nil
+      #   header(*part_nums, fields: names, offset: nil) -> string or nil
+      #   header(*part_nums, except: names, offset: nil) -> string or nil
+      #
+      # The {[RFC5322]}[https://www.rfc-editor.org/rfc/rfc5322.html] header of a
+      # message or of an encapsulated
+      # {[MIME-IMT]}[https://www.rfc-editor.org/rfc/rfc2046.html]
+      # MESSAGE/RFC822 or MESSAGE/GLOBAL message.
+      #
+      # <em>Headers can be parsed using the "mail" gem.</em>
+      #
+      # See #part for a description of +part_nums+ and +offset+.
+      #
+      # ==== Without +fields+ or +except+
+      # This is the same as getting the value from #attr for one of:
+      # * <tt>BODY[HEADER]</tt>
+      # * <tt>BODY[HEADER]<#{offset}></tt>
+      # * <tt>BODY[#{part_nums.join "."}.HEADER]"</tt>
+      # * <tt>BODY[#{part_nums.join "."}.HEADER]<#{offset}>"</tt>
+      #
+      # ==== With +fields+
+      # When +fields+ is sent, returns a subset of the header which contains
+      # only the header fields that match one of the names in the list.
+      #
+      # This is the same as getting the value from #attr_upcase for one of:
+      # * <tt>BODY[HEADER.FIELDS (#{names.join " "})]</tt>
+      # * <tt>BODY[HEADER.FIELDS (#{names.join " "})]<#{offset}></tt>
+      # * <tt>BODY[#{part_nums.join "."}.HEADER.FIELDS (#{names.join " "})]</tt>
+      # * <tt>BODY[#{part_nums.join "."}.HEADER.FIELDS (#{names.join " "})]<#{offset}></tt>
+      #
+      # See also: #header_fields
+      #
+      # ==== With +except+
+      # When +except+ is sent, returns a subset of the header which contains
+      # only the header fields that do _not_ match one of the names in the list.
+      #
+      # This is the same as getting the value from #attr_upcase for one of:
+      # * <tt>BODY[HEADER.FIELDS.NOT (#{names.join " "})]</tt>
+      # * <tt>BODY[HEADER.FIELDS.NOT (#{names.join " "})]<#{offset}></tt>
+      # * <tt>BODY[#{part_nums.join "."}.HEADER.FIELDS.NOT (#{names.join " "})]</tt>
+      # * <tt>BODY[#{part_nums.join "."}.HEADER.FIELDS.NOT (#{names.join " "})]<#{offset}></tt>
+      #
+      # See also: #header_fields_not
+      def header(*part_nums, fields: nil, except: nil, offset: nil)
+        fields && except and
+          raise ArgumentError, "conflicting 'fields' and 'except' arguments"
+        if fields
+          text = "HEADER.FIELDS (%s)" % [fields.join(" ").upcase]
+          attr_upcase[body_section_attr(part_nums, text, offset: offset)]
+        elsif except
+          text = "HEADER.FIELDS.NOT (%s)" % [except.join(" ").upcase]
+          attr_upcase[body_section_attr(part_nums, text, offset: offset)]
+        else
+          attr[body_section_attr(part_nums, "HEADER", offset: offset)]
+        end
+      end
+
+      # :call-seq:
+      #   header_fields(*names, part: [], offset: nil) -> string or nil
+      #
+      # The result from #header when called with <tt>fields: names</tt>.
+      def header_fields(first, *rest, part: [], offset: nil)
+        header(*part, fields: [first, *rest], offset: offset)
+      end
+
+      # :call-seq:
+      #   header_fields_not(*names, part: [], offset: nil) -> string or nil
+      #
+      # The result from #header when called with <tt>except: names</tt>.
+      def header_fields_not(first, *rest, part: [], offset: nil)
+        header(*part, except: [first, *rest], offset: offset)
+      end
+
+      # :call-seq:
+      #   mime(*part_nums)                -> string or nil
+      #   mime(*part_nums, offset: bytes) -> string or nil
+      #
+      # The {[MIME-IMB]}[https://www.rfc-editor.org/rfc/rfc2045.html] header for
+      # a message part, if it was fetched.
+      #
+      # See #part for a description of +part_nums+ and +offset+.
+      #
+      # This is the same as getting the value for
+      # <tt>"BODY[#{part_nums}.MIME]"</tt> or
+      # <tt>"BODY[#{part_nums}.MIME]<#{offset}>"</tt> from #attr.
+      #
+      # See also: #message, #header, and #text.
+      def mime(part, *subparts, offset: nil)
+        attr[body_section_attr([part, *subparts], "MIME", offset: offset)]
+      end
+
+      # :call-seq:
+      #   text(*part_nums)                -> string or nil
+      #   text(*part_nums, offset: bytes) -> string or nil
+      #
+      # The text body of a message or a message part, if it was fetched,
+      # omitting the {[RFC5322]}[https://www.rfc-editor.org/rfc/rfc5322.html]
+      # header.
+      #
+      # See #part for a description of +part_nums+ and +offset+.
+      #
+      # This is the same as getting the value from #attr for one of:
+      # * <tt>"BODY[TEXT]"</tt>,
+      # * <tt>"BODY[TEXT]<#{offset}>"</tt>,
+      # * <tt>"BODY[#{section}.TEXT]"</tt>, or
+      # * <tt>"BODY[#{section}.TEXT]<#{offset}>"</tt>.
+      #
+      # See also: #message, #header, and #mime.
+      def text(*part, offset: nil)
+        attr[body_section_attr(part, "TEXT", offset: offset)]
+      end
+
+      # :call-seq:
+      #   bodystructure -> BodyStructure struct or nil
+      #
+      # A BodyStructure object that describes the message, if it was fetched.
+      #
+      # This is the same as getting the value for <tt>"BODYSTRUCTURE"</tt> from
+      # #attr.
+      def bodystructure; attr["BODYSTRUCTURE"] end
+
+      alias body_structure bodystructure
+
+      # :call-seq: envelope -> Envelope or nil
+      #
+      # An Envelope object that describes the envelope structure of a message.
+      # See the documentation for Envelope for a description of the envelope
+      # structure attributes.
+      #
+      # This is the same as getting the value for <tt>"ENVELOPE"</tt> from
+      # #attr.
+      def envelope; attr["ENVELOPE"] end
+
+      # :call-seq: flags -> array of Symbols and Strings, or nil
+      #
+      # A array of flags that are set for this message.  System flags are
+      # symbols that have been capitalized by String#capitalize.  Keyword flags
+      # are strings and their case is not changed.
+      #
+      # This is the same as getting the value for <tt>"FLAGS"</tt> from #attr.
+      #
+      # [NOTE:]
+      #   The +FLAGS+ field is dynamic, and can change for a uniquely identified
+      #   message.
+      def flags; attr["FLAGS"] end
+
+      # :call-seq: internaldate -> Time or nil
+      #
+      # The internal date and time of the message on the server.  This is not
+      # the date and time in the [RFC5322[https://www.rfc-editor.org/rfc/rfc5322]]
+      # header, but rather a date and time which reflects when the message was
+      # received.
+      #
+      # This is similar to getting the value for <tt>"INTERNALDATE"</tt> from
+      # #attr.
+      #
+      # [NOTE:]
+      #   <tt>attr["INTERNALDATE"]</tt> returns a string, and this method
+      #   returns a Time object.
+      def internaldate
+        attr["INTERNALDATE"]&.then { IMAP.decode_time _1 }
+      end
+
+      alias internal_date internaldate
+
+      # :call-seq: rfc822 -> String or nil
+      #
+      # Semantically equivalent to #message with no arguments.
+      #
+      # This is the same as getting the value for <tt>"RFC822"</tt> from #attr.
+      #
+      # [NOTE:]
+      #   +IMAP4rev2+ deprecates <tt>RFC822</tt>.
+      def rfc822; attr["RFC822"] end
+
+      # :call-seq: rfc822_size -> Integer or nil
+      #
+      # A number expressing the [RFC5322[https://www.rfc-editor.org/rfc/rfc5322]]
+      # size of the message.
+      #
+      # This is the same as getting the value for <tt>"RFC822.SIZE"</tt> from
+      # #attr.
+      #
+      # [NOTE:]
+      #   \IMAP was originally developed for the older
+      #   RFC822[https://www.rfc-editor.org/rfc/rfc822.html] standard, and as a
+      #   consequence several fetch items in \IMAP incorporate "RFC822" in their
+      #   name.  With the exception of +RFC822.SIZE+, there are more modern
+      #   replacements; for example, the modern version of +RFC822.HEADER+ is
+      #   <tt>BODY.PEEK[HEADER]</tt>.  In all cases, "RFC822" should be
+      #   interpreted as a reference to the updated
+      #   RFC5322[https://www.rfc-editor.org/rfc/rfc5322.html] standard.
+      def rfc822_size; attr["RFC822.SIZE"] end
+
+      # NOTE: a bug in rdoc 6.7 prevents us from adding a call-seq to
+      # rfc822_size _and_ aliasing size => rfc822_size.  Is it because this
+      # class inherits from Struct?
+
+      # Alias for: rfc822_size
+      def size; rfc822_size end
+
+
+      # :call-seq: rfc822_header -> String or nil
+      #
+      # Semantically equivalent to #header, with no arguments.
+      #
+      # This is the same as getting the value for <tt>"RFC822.HEADER"</tt> from #attr.
+      #
+      # [NOTE:]
+      #   +IMAP4rev2+ deprecates <tt>RFC822.HEADER</tt>.
+      def rfc822_header; attr["RFC822.HEADER"] end
+
+      # :call-seq: rfc822_text -> String or nil
+      #
+      # Semantically equivalent to #text, with no arguments.
+      #
+      # This is the same as getting the value for <tt>"RFC822.TEXT"</tt> from
+      # #attr.
+      #
+      # [NOTE:]
+      #   +IMAP4rev2+ deprecates <tt>RFC822.TEXT</tt>.
+      def rfc822_text; attr["RFC822.TEXT"] end
+
+      # :call-seq: uid -> Integer or nil
+      #
+      # A number expressing the unique identifier of the message.
+      #
+      # This is the same as getting the value for <tt>"UID"</tt> from #attr.
+      #
+      # [NOTE:]
+      #   For UIDFetchData, this returns the uniqueid at the beginning of the
+      #   +UIDFETCH+ response, _not_ the value from #attr.
+      def uid; attr["UID"] end
+
+      # :call-seq:
+      #   binary(*part_nums, offset: nil) -> string or nil
+      #
+      # Returns the binary representation of a particular MIME part, which has
+      # already been decoded according to its Content-Transfer-Encoding.
+      #
+      # See #part for a description of +part_nums+ and +offset+.
+      #
+      # This is the same as getting the value of
+      # <tt>"BINARY[#{part_nums.join(".")}]"</tt> or
+      # <tt>"BINARY[#{part_nums.join(".")}]<#{offset}>"</tt> from #attr.
+      #
+      # The server must support either
+      # IMAP4rev2[https://www.rfc-editor.org/rfc/rfc9051.html]
+      # or the +BINARY+ extension
+      # {[RFC3516]}[https://www.rfc-editor.org/rfc/rfc3516.html].
+      #
+      # See also: #binary_size, #mime
+      def binary(*part_nums, offset: nil)
+        attr[section_attr("BINARY", part_nums, offset: offset)]
+      end
+
+      # :call-seq:
+      #   binary_size(*part_nums) -> integer or nil
+      #
+      # Returns the decoded size of a particular MIME part (the size to expect
+      # in response to a <tt>BINARY</tt> fetch request).
+      #
+      # See #part for a description of +part_nums+.
+      #
+      # This is the same as getting the value of
+      # <tt>"BINARY.SIZE[#{part_nums.join(".")}]"</tt> from #attr.
+      #
+      # The server must support either
+      # IMAP4rev2[https://www.rfc-editor.org/rfc/rfc9051.html]
+      # or the +BINARY+ extension
+      # {[RFC3516]}[https://www.rfc-editor.org/rfc/rfc3516.html].
+      #
+      # See also: #binary, #mime
+      def binary_size(*part_nums)
+        attr[section_attr("BINARY.SIZE", part_nums)]
+      end
+
+      # :call-seq: modseq -> Integer or nil
+      #
+      # The modification sequence number associated with this IMAP message.
+      #
+      # This is the same as getting the value for <tt>"MODSEQ"</tt> from #attr.
+      #
+      # The server must support the +CONDSTORE+ extension
+      # {[RFC7162]}[https://www.rfc-editor.org/rfc/rfc7162.html].
+      #
+      # [NOTE:]
+      #   The +MODSEQ+ field is dynamic, and can change for a uniquely
+      #   identified message.
+      def modseq; attr["MODSEQ"] end
+
+      # :call-seq: emailid -> string or nil
+      #
+      # An ObjectID that uniquely identifies the immutable content of a single
+      # message.
+      #
+      # The server must return the same +EMAILID+ for both the source and
+      # destination messages after a COPY or MOVE command.  However, it is
+      # possible for different messages with the same EMAILID to have different
+      # mutable attributes, such as flags.
+      #
+      # This is the same as getting the value for <tt>"EMAILID"</tt> from
+      # #attr.
+      #
+      # The server must support the +OBJECTID+ extension
+      # {[RFC8474]}[https://www.rfc-editor.org/rfc/rfc8474.html].
+      def emailid; attr["EMAILID"] end
+
+      # :call-seq: threadid -> string or nil
+      #
+      # An ObjectID that uniquely identifies a set of messages that the server
+      # believes should be grouped together.
+      #
+      # It is generally based on some combination of References, In-Reply-To,
+      # and Subject, but the exact implementation is left up to the server
+      # implementation.  The server should return the same thread identifier for
+      # related messages, even if they are in different mailboxes.
+      #
+      # This is the same as getting the value for <tt>"THREADID"</tt> from
+      # #attr.
+      #
+      # The server must support the +OBJECTID+ extension
+      # {[RFC8474]}[https://www.rfc-editor.org/rfc/rfc8474.html].
+      def threadid; attr["THREADID"] end
+
+      private
+
+      def body_section_attr(...) section_attr("BODY", ...) end
+
+      def section_attr(attr, part = [], text = nil, offset: nil)
+        spec = Array(part).flatten.map { Integer(_1) }
+        spec << text if text
+        spec = spec.join(".")
+        if offset then "%s[%s]<%d>" % [attr, spec, Integer(offset)] else "%s[%s]" % [attr, spec] end
+      end
+    end
+
+    # Net::IMAP::FetchData represents the contents of a +FETCH+ response.
+    # Net::IMAP#fetch, Net::IMAP#uid_fetch, Net::IMAP#store, and
+    # Net::IMAP#uid_store all return arrays of FetchData objects, except when
+    # the +UIDONLY+ extension is enabled.
+    #
+    # See FetchStruct documentation for a list of standard message attributes.
+    class FetchData < FetchStruct.new(:seqno, :attr)
+      ##
+      # method: seqno
+      # :call-seq: seqno -> Integer
+      #
+      # The message sequence number.
+      #
+      # [NOTE:]
+      #   This is not the same as the unique identifier (UID), not even for the
+      #   Net::IMAP#uid_fetch result.  The UID is available from #uid, if it was
+      #   returned.
+      #
+      # [NOTE:]
+      #   UIDFetchData will raise a NoMethodError.
+
+      ##
+      # method: attr
+      # :call-seq: attr -> hash
+      #
+      # Each key specifies a message attribute, and the value is the
+      # corresponding data item.  Standard data items have corresponding
+      # accessor methods.  The definitions of each attribute type is documented
+      # on its accessor.
+      #
+      # See FetchStruct documentation for message attribute accessors.
+      #
+      # [NOTE:]
+      #   #seqno is not a message attribute.
+    end
+
+    # Net::IMAP::UIDFetchData represents the contents of a +UIDFETCH+ response,
+    # When the +UIDONLY+ extension has been enabled, Net::IMAP#uid_fetch and
+    # Net::IMAP#uid_store will both return an array of UIDFetchData objects.
+    #
+    # UIDFetchData contains the same message attributes as FetchData.  However,
+    # +UIDFETCH+ responses return the UID at the beginning of the response,
+    # replacing FetchData#seqno.  UIDFetchData never contains a message sequence
+    # number.
+    #
+    # See FetchStruct documentation for a list of standard message attributes.
+    class UIDFetchData < FetchStruct.new(:uid, :attr)
+      ##
+      # method: uid
+      # call-seq: uid -> Integer
+      #
+      # A number expressing the unique identifier of the message.
+      #
+      # [NOTE:]
+      #   Although #attr may _also_ have a redundant +UID+ attribute, #uid
+      #   returns the uniqueid at the beginning of the +UIDFETCH+ response.
+
+      ##
+      # method: attr
+      # call-seq: attr -> hash
+      #
+      # Each key specifies a message attribute, and the value is the
+      # corresponding data item.  Standard data items have corresponding
+      # accessor methods.  The definitions of each attribute type is documented
+      # on its accessor.
+      #
+      # See FetchStruct documentation for message attribute accessors.
+      #
+      # [NOTE:]
+      #   #uid is not a message attribute.  Although the server may return a
+      #   +UID+ message attribute, it is not required to.  #uid is taken from
+      #   its corresponding +UIDFETCH+ field.
+
+      # UIDFetchData will print a warning if <tt>#attr["UID"]</tt> is present
+      # but not identical to #uid.
+      def initialize(...)
+        super
+        attr and
+          attr_uid = attr["UID"] and
+          attr_uid != uid and
+          warn "#{self.class} UIDs do not match (#{attr_uid} != #{uid})"
+      end
+    end
+  end
+end

data/lib/net/imap/flags.rb

@@ -71,7 +71,7 @@ module Net
     # Mailbox name attributes are not case-sensitive.  <em>The current
     # implementation</em> normalizes mailbox attribute case using
     # String#capitalize, such as +:Noselect+ (not +:NoSelect+).  The constants
-    # (such as NO_SELECT) can also be used for comparison.  The contants have
+    # (such as NO_SELECT) can also be used for comparison.  The constants have
     # been defined both with and without underscores between words.
     #
     # <em>The descriptions here were copied from</em> {[RFC-9051 §