net-imap 0.4.20 → 0.5.0

data/lib/net/imap/response_data.rb

@@ -5,9 +5,6 @@ module Net
     autoload :FetchData,        "#{__dir__}/fetch_data"
     autoload :SearchResult,     "#{__dir__}/search_result"
     autoload :SequenceSet,      "#{__dir__}/sequence_set"
-    autoload :UIDPlusData,      "#{__dir__}/uidplus_data"
-    autoload :AppendUIDData,    "#{__dir__}/uidplus_data"
-    autoload :CopyUIDData,      "#{__dir__}/uidplus_data"
 
     # Net::IMAP::ContinuationRequest represents command continuation requests.
     #
@@ -327,6 +324,60 @@ module Net
       # code data can take.
     end
 
+    # Net::IMAP::UIDPlusData represents the ResponseCode#data that accompanies
+    # the +APPENDUID+ and +COPYUID+ response codes.
+    #
+    # See [[UIDPLUS[https://www.rfc-editor.org/rfc/rfc4315.html]].
+    #
+    # ==== Capability requirement
+    #
+    # The +UIDPLUS+ capability[rdoc-ref:Net::IMAP#capability] must be supported.
+    # A server that supports +UIDPLUS+ should send a UIDPlusData object inside
+    # every TaggedResponse returned by the append[rdoc-ref:Net::IMAP#append],
+    # copy[rdoc-ref:Net::IMAP#copy], move[rdoc-ref:Net::IMAP#move], {uid
+    # copy}[rdoc-ref:Net::IMAP#uid_copy], and {uid
+    # move}[rdoc-ref:Net::IMAP#uid_move] commands---unless the destination
+    # mailbox reports +UIDNOTSTICKY+.
+    #
+    #--
+    # TODO: support MULTIAPPEND
+    #++
+    #
+    class UIDPlusData < Struct.new(:uidvalidity, :source_uids, :assigned_uids)
+      ##
+      # method: uidvalidity
+      # :call-seq: uidvalidity -> nonzero uint32
+      #
+      # The UIDVALIDITY of the destination mailbox.
+
+      ##
+      # method: source_uids
+      # :call-seq: source_uids -> nil or an array of nonzero uint32
+      #
+      # The UIDs of the copied or moved messages.
+      #
+      # Note:: Returns +nil+ for Net::IMAP#append.
+
+      ##
+      # method: assigned_uids
+      # :call-seq: assigned_uids -> an array of nonzero uint32
+      #
+      # The newly assigned UIDs of the copied, moved, or appended messages.
+      #
+      # Note:: This always returns an array, even when it contains only one UID.
+
+      ##
+      # :call-seq: uid_mapping -> nil or a hash
+      #
+      # Returns a hash mapping each source UID to the newly assigned destination
+      # UID.
+      #
+      # Note:: Returns +nil+ for Net::IMAP#append.
+      def uid_mapping
+        source_uids&.zip(assigned_uids)&.to_h
+      end
+    end
+
     # Net::IMAP::MailboxList represents contents of the LIST response,
     # representing a single mailbox path.
     #
@@ -888,7 +939,8 @@ module Net
       # for something else?
       #++
       def media_subtype
-        warn("media_subtype is obsolete, use subtype instead.\n", uplevel: 1)
+        warn("media_subtype is obsolete, use subtype instead.\n",
+             uplevel: 1, category: :deprecated)
         return subtype
       end
     end
@@ -933,7 +985,8 @@ module Net
       # generate a warning message to +stderr+, then return
       # the value of +subtype+.
       def media_subtype
-        warn("media_subtype is obsolete, use subtype instead.\n", uplevel: 1)
+        warn("media_subtype is obsolete, use subtype instead.\n",
+             uplevel: 1, category: :deprecated)
         return subtype
       end
     end
@@ -989,77 +1042,6 @@ module Net
       end
     end
 
-    # BodyTypeAttachment is not used and will be removed in an upcoming release.
-    #
-    # === Bug Analysis
-    #
-    # \IMAP body structures are parenthesized lists and assign their fields
-    # positionally, so missing fields change the interpretation of all
-    # following fields.  Additionally, different body types have a different
-    # number of required fields, followed by optional "extension" fields.
-    #
-    # BodyTypeAttachment was previously returned when a "message/rfc822" part,
-    # which should be sent as <tt>body-type-msg</tt> with ten required fields,
-    # was actually sent as a <tt>body-type-basic</tt> with _seven_ required
-    # fields.
-    #
-    #   basic => type, subtype, param, id, desc, enc, octets, md5=nil,  dsp=nil, lang=nil, loc=nil, *ext
-    #   msg   => type, subtype, param, id, desc, enc, octets, envelope, body,    lines,    md5=nil, ...
-    #
-    # Normally, +envelope+ and +md5+ are incompatible, but Net::IMAP leniently
-    # allowed buggy servers to send +NIL+ for +envelope+.  As a result, when a
-    # server sent a <tt>message/rfc822</tt> part with +NIL+ for +md5+ and a
-    # non-<tt>NIL</tt> +dsp+, Net::IMAP misinterpreted the
-    # <tt>Content-Disposition</tt> as if it were a strange body type.  In all
-    # reported cases, the <tt>Content-Disposition</tt> was "attachment", so
-    # BodyTypeAttachment was created as the workaround.
-    #
-    # === Current behavior
-    #
-    # When interpreted strictly, +envelope+ and +md5+ are incompatible.  So the
-    # current parsing algorithm peeks ahead after it has received the seventh
-    # body field.  If the next token is not the start of an +envelope+, we assume
-    # the server has incorrectly sent us a <tt>body-type-basic</tt> and return
-    # BodyTypeBasic.  As a result, what was previously BodyTypeMessage#body =>
-    # BodyTypeAttachment is now BodyTypeBasic#disposition => ContentDisposition.
-    #
-    class BodyTypeAttachment < Struct.new(:dsp_type, :_unused_, :param)
-      # *invalid for BodyTypeAttachment*
-      def media_type
-        warn(<<~WARN, uplevel: 1)
-          BodyTypeAttachment#media_type is obsolete.  Use dsp_type instead.
-        WARN
-        dsp_type
-      end
-
-      # *invalid for BodyTypeAttachment*
-      def subtype
-        warn("BodyTypeAttachment#subtype is obsolete.\n", uplevel: 1)
-        nil
-      end
-
-      ##
-      # method: dsp_type
-      # :call-seq: dsp_type -> string
-      #
-      # Returns the content disposition type, as defined by
-      # [DISPOSITION[https://tools.ietf.org/html/rfc2183]].
-
-      ##
-      # method: param
-      # :call-seq: param -> hash
-      #
-      # Returns a hash representing parameters of the Content-Disposition
-      # field, as defined by [DISPOSITION[https://tools.ietf.org/html/rfc2183]].
-
-      ##
-      def multipart?
-        return false
-      end
-    end
-
-    deprecate_constant :BodyTypeAttachment
-
     # Net::IMAP::BodyTypeMultipart represents body structures of messages and
     # message parts, when <tt>Content-Type</tt> is <tt>multipart/*</tt>.
     class BodyTypeMultipart < Struct.new(:media_type, :subtype,
@@ -1131,29 +1113,11 @@ module Net
       # generate a warning message to +stderr+, then return
       # the value of +subtype+.
       def media_subtype
-        warn("media_subtype is obsolete, use subtype instead.\n", uplevel: 1)
+        warn("media_subtype is obsolete, use subtype instead.\n",
+             uplevel: 1, category: :deprecated)
         return subtype
       end
     end
 
-    # === Obsolete
-    # BodyTypeExtension is not used and will be removed in an upcoming release.
-    #
-    # >>>
-    #   BodyTypeExtension was (incorrectly) used for <tt>message/*</tt> parts
-    #   (besides <tt>message/rfc822</tt>, which correctly uses BodyTypeMessage).
-    #
-    #   Net::IMAP now (correctly) parses all message types (other than
-    #   <tt>message/rfc822</tt> or <tt>message/global</tt>) as BodyTypeBasic.
-    class BodyTypeExtension < Struct.new(:media_type, :subtype,
-                                         :params, :content_id,
-                                         :description, :encoding, :size)
-      def multipart?
-        return false
-      end
-    end
-
-    deprecate_constant :BodyTypeExtension
-
   end
 end

data/lib/net/imap/response_parser.rb

@@ -13,17 +13,13 @@ module Net
 
       attr_reader :config
 
-      # Creates a new ResponseParser.
-      #
-      # When +config+ is frozen or global, the parser #config inherits from it.
-      # Otherwise, +config+ will be used directly.
+      # :call-seq: Net::IMAP::ResponseParser.new -> Net::IMAP::ResponseParser
       def initialize(config: Config.global)
         @str = nil
         @pos = nil
         @lex_state = nil
         @token = nil
         @config = Config[config]
-        @config = @config.new if @config == Config.global || @config.frozen?
       end
 
       # :call-seq:
@@ -1321,31 +1317,19 @@ module Net
       #   header-fld-name = astring
       #
       # NOTE: Previously, Net::IMAP recreated the raw original source string.
-      # Now, it grabs the raw encoded value using @str and @pos.  A future
-      # version may simply return the decoded astring value.  Although that is
-      # technically incompatible, it should almost never make a difference: all
-      # standard header field names are valid atoms:
+      # Now, it returns the decoded astring value.  Although this is technically
+      # incompatible, it should almost never make a difference: all standard
+      # header field names are valid atoms:
       #
       # https://www.iana.org/assignments/message-headers/message-headers.xhtml
       #
-      # Although RFC3501 allows any astring, RFC5322-valid header names are one
-      # or more of the printable US-ASCII characters, except SP and colon.  So
-      # empty string isn't valid, and literals aren't needed and should not be
-      # used.  This is explicitly unchanged by [I18N-HDRS] (RFC6532).
-      #
-      # RFC5233:
+      # See also RFC5233:
       #     optional-field  =   field-name ":" unstructured CRLF
       #     field-name      =   1*ftext
       #     ftext           =   %d33-57 /          ; Printable US-ASCII
       #                         %d59-126           ;  characters not including
       #                                            ;  ":".
-      def header_fld_name
-        assert_no_lookahead
-        start = @pos
-        astring
-        end_pos = @token ? @pos - 1 : @pos
-        @str[start...end_pos]
-      end
+      alias header_fld_name astring
 
       # mailbox-data    =  "FLAGS" SP flag-list / "LIST" SP mailbox-list /
       #                    "LSUB" SP mailbox-list / "SEARCH" *(SP nz-number) /
@@ -1867,10 +1851,11 @@ module Net
       #
       # n.b, uniqueid ⊂ uid-set.  To avoid inconsistent return types, we always
       # match uid_set even if that returns a single-member array.
+      #
       def resp_code_apnd__data
         validity = number; SP!
         dst_uids = uid_set # uniqueid ⊂ uid-set
-        AppendUID(validity, dst_uids)
+        UIDPlusData.new(validity, nil, dst_uids)
       end
 
       # already matched:  "COPYUID"
@@ -1880,25 +1865,7 @@ module Net
         validity = number;  SP!
         src_uids = uid_set; SP!
         dst_uids = uid_set
-        CopyUID(validity, src_uids, dst_uids)
-      end
-
-      def AppendUID(...) DeprecatedUIDPlus(...) || AppendUIDData.new(...) end
-      def CopyUID(...)   DeprecatedUIDPlus(...) || CopyUIDData.new(...)   end
-
-      # TODO: remove this code in the v0.6.0 release
-      def DeprecatedUIDPlus(validity, src_uids = nil, dst_uids)
-        return unless config.parser_use_deprecated_uidplus_data
-        compact_uid_sets = [src_uids, dst_uids].compact
-        count = compact_uid_sets.map { _1.count_with_duplicates }.max
-        max   = config.parser_max_deprecated_uidplus_data_size
-        if count <= max
-          src_uids &&= src_uids.each_ordered_number.to_a
-          dst_uids   = dst_uids.each_ordered_number.to_a
-          UIDPlusData.new(validity, src_uids, dst_uids)
-        elsif config.parser_use_deprecated_uidplus_data != :up_to_max_size
-          parse_error("uid-set is too large: %d > %d", count, max)
-        end
+        UIDPlusData.new(validity, src_uids, dst_uids)
       end
 
       ADDRESS_REGEXP = /\G
@@ -2024,9 +1991,15 @@ module Net
       #      uniqueid        = nz-number
       #                          ; Strictly ascending
       def uid_set
-        set = sequence_set
-        parse_error("uid-set cannot contain '*'") if set.include_star?
-        set
+        token = match(T_NUMBER, T_ATOM)
+        case token.symbol
+        when T_NUMBER then [Integer(token.value)]
+        when T_ATOM
+          token.value.split(",").flat_map {|range|
+            range = range.split(":").map {|uniqueid| Integer(uniqueid) }
+            range.size == 1 ? range : Range.new(range.min, range.max).to_a
+          }
+        end
       end
 
       def nil_atom

data/lib/net/imap/sasl/authentication_exchange.rb

@@ -4,44 +4,76 @@ module Net
   class IMAP
     module SASL
 
-      # This API is *experimental*, and may change.
+      # AuthenticationExchange is used internally by Net::IMAP#authenticate.
+      # But the API is still *experimental*, and may change.
       #
       # TODO: catch exceptions in #process and send #cancel_response.
       # TODO: raise an error if the command succeeds after being canceled.
       # TODO: use with more clients, to verify the API can accommodate them.
+      # TODO: pass ClientAdapter#service to SASL.authenticator
       #
-      # Create an AuthenticationExchange from a client adapter and a mechanism
-      # authenticator:
-      #     def authenticate(mechanism, ...)
-      #       authenticator = SASL.authenticator(mechanism, ...)
-      #       SASL::AuthenticationExchange.new(
-      #         sasl_adapter, mechanism, authenticator
-      #       ).authenticate
-      #     end
-      #
-      #     private
+      # An AuthenticationExchange represents a single attempt to authenticate
+      # a SASL client to a SASL server.  It is created from a client adapter, a
+      # mechanism name, and a mechanism authenticator.  When #authenticate is
+      # called, it will send the appropriate authenticate command to the server,
+      # returning the client response on success and raising an exception on
+      # failure.
       #
-      #     def sasl_adapter = MyClientAdapter.new(self, &method(:send_command))
+      # In most cases, the client will not need to use
+      # SASL::AuthenticationExchange directly at all.  Instead, use
+      # SASL::ClientAdapter#authenticate.  If customizations are needed, the
+      # custom client adapter is probably the best place for that code.
       #
-      # Or delegate creation of the authenticator to ::build:
       #     def authenticate(...)
-      #       SASL::AuthenticationExchange.build(sasl_adapter, ...)
-      #         .authenticate
+      #       MyClient::SASLAdapter.new(self).authenticate(...)
       #     end
       #
-      # As a convenience, ::authenticate combines ::build and #authenticate:
+      # SASL::ClientAdapter#authenticate delegates to ::authenticate, like so:
+      #
       #     def authenticate(...)
+      #       sasl_adapter = MyClient::SASLAdapter.new(self)
       #       SASL::AuthenticationExchange.authenticate(sasl_adapter, ...)
       #     end
       #
-      # Likewise, ClientAdapter#authenticate delegates to #authenticate:
-      #     def authenticate(...) = sasl_adapter.authenticate(...)
+      # ::authenticate simply delegates to ::build and #authenticate, like so:
+      #
+      #     def authenticate(...)
+      #       sasl_adapter = MyClient::SASLAdapter.new(self)
+      #       SASL::AuthenticationExchange
+      #         .build(sasl_adapter, ...)
+      #         .authenticate
+      #     end
+      #
+      # And ::build delegates to SASL.authenticator and ::new, like so:
+      #
+      #     def authenticate(mechanism, ...)
+      #       sasl_adapter = MyClient::SASLAdapter.new(self)
+      #       authenticator = SASL.authenticator(mechanism, ...)
+      #       SASL::AuthenticationExchange
+      #         .new(sasl_adapter, mechanism, authenticator)
+      #         .authenticate
+      #     end
       #
       class AuthenticationExchange
         # Convenience method for <tt>build(...).authenticate</tt>
+        #
+        # See also: SASL::ClientAdapter#authenticate
         def self.authenticate(...) build(...).authenticate end
 
-        # Use +registry+ to override the global Authenticators registry.
+        # Convenience method to combine the creation of a new authenticator and
+        # a new Authentication exchange.
+        #
+        # +client+ must be an instance of SASL::ClientAdapter.
+        #
+        # +mechanism+ must be a SASL mechanism name, as a string or symbol.
+        #
+        # +sasl_ir+ allows or disallows sending an "initial response", depending
+        # also on whether the server capabilities, mechanism authenticator, and
+        # client adapter all support it.  Defaults to +true+.
+        #
+        # +mechanism+, +args+, +kwargs+, and +block+ are all forwarded to
+        # SASL.authenticator.  Use the +registry+ kwarg to override the global
+        # SASL::Authenticators registry.
         def self.build(client, mechanism, *args, sasl_ir: true, **kwargs, &block)
           authenticator = SASL.authenticator(mechanism, *args, **kwargs, &block)
           new(client, mechanism, authenticator, sasl_ir: sasl_ir)
@@ -51,7 +83,7 @@ module Net
 
         def initialize(client, mechanism, authenticator, sasl_ir: true)
           @client = client
-          @mechanism = -mechanism.to_s.upcase.tr(?_, ?-)
+          @mechanism = Authenticators.normalize_name(mechanism)
           @authenticator = authenticator
           @sasl_ir = sasl_ir
           @processed = false

data/lib/net/imap/sasl/authenticators.rb

@@ -21,6 +21,10 @@ module Net::IMAP::SASL
   # ScramSHA1Authenticator for examples.
   class Authenticators
 
+    # Normalize the mechanism name as an uppercase string, with underscores
+    # converted to dashes.
+    def self.normalize_name(mechanism) -(mechanism.to_s.upcase.tr(?_, ?-)) end
+
     # Create a new Authenticators registry.
     #
     # This class is usually not instantiated directly.  Use SASL.authenticators
@@ -65,7 +69,6 @@ module Net::IMAP::SASL
     # lazily loaded from <tt>Net::IMAP::SASL::#{name}Authenticator</tt> (case is
     # preserved and non-alphanumeric characters are removed..
     def add_authenticator(name, authenticator = nil)
-      key = -name.to_s.upcase.tr(?_, ?-)
       authenticator ||= begin
         class_name = "#{name.gsub(/[^a-zA-Z0-9]/, "")}Authenticator".to_sym
         auth_class = nil
@@ -74,17 +77,18 @@ module Net::IMAP::SASL
           auth_class.new(*creds, **props, &block)
         }
       end
+      key = Authenticators.normalize_name(name)
       @authenticators[key] = authenticator
     end
 
     # Removes the authenticator registered for +name+
     def remove_authenticator(name)
-      key = -name.to_s.upcase.tr(?_, ?-)
+      key = Authenticators.normalize_name(name)
       @authenticators.delete(key)
     end
 
     def mechanism?(name)
-      key = -name.to_s.upcase.tr(?_, ?-)
+      key = Authenticators.normalize_name(name)
       @authenticators.key?(key)
     end
 
@@ -105,7 +109,7 @@ module Net::IMAP::SASL
     #   only.  Protocol client users should see refer to their client's
     #   documentation, e.g. Net::IMAP#authenticate.
     def authenticator(mechanism, ...)
-      key = -mechanism.to_s.upcase.tr(?_, ?-)
+      key = Authenticators.normalize_name(mechanism)
       auth = @authenticators.fetch(key) do
         raise ArgumentError, 'unknown auth type - "%s"' % key
       end

data/lib/net/imap/sasl/client_adapter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module Net
   class IMAP
     module SASL
@@ -8,42 +10,76 @@ module Net
       #
       # TODO: use with more clients, to verify the API can accommodate them.
       #
-      # An abstract base class for implementing a SASL authentication exchange.
-      # Different clients will each have their own adapter subclass, overridden
-      # to match their needs.
+      # Represents the client to a SASL::AuthenticationExchange.  By default,
+      # most methods simply delegate to #client.  Clients should subclass
+      # SASL::ClientAdapter and override methods as needed to match the
+      # semantics of this API to their API.
       #
-      # Although the default implementations _may_ be sufficient, subclasses
-      # will probably need to override some methods.  Additionally, subclasses
-      # may need to include a protocol adapter mixin, if the default
+      # Subclasses should also include a protocol adapter mixin when the default
       # ProtocolAdapters::Generic isn't sufficient.
+      #
+      # === Protocol Requirements
+      #
+      # {RFC4422 §4}[https://www.rfc-editor.org/rfc/rfc4422.html#section-4]
+      # lists requirements for protocol specifications to offer SASL.  Where
+      # possible, ClientAdapter delegates the handling of these requirements to
+      # SASL::ProtocolAdapters.
       class ClientAdapter
+        extend Forwardable
+
         include ProtocolAdapters::Generic
 
-        attr_reader :client, :command_proc
+        # The client that handles communication with the protocol server.
+        #
+        # Most ClientAdapter methods are simply delegated to #client by default.
+        attr_reader :client
 
         # +command_proc+ can used to avoid exposing private methods on #client.
-        # It should run a command with the arguments sent to it, yield each
-        # continuation payload, respond to the server with the result of each
-        # yield, and return the result.  Non-successful results *MUST* raise an
-        # exception.  Exceptions in the block *MUST* cause the command to fail.
+        # It's value is set by the block that is passed to ::new, and it is used
+        # by the default implementation of #run_command.  Subclasses that
+        # override #run_command may use #command_proc for any other purpose they
+        # find useful.
         #
-        # Subclasses that override #run_command may use #command_proc for
-        # other purposes.
+        # In the default implementation of #run_command, command_proc is called
+        # with the protocols authenticate +command+ name, the +mechanism+ name,
+        # an _optional_ +initial_response+ argument, and a +continuations+
+        # block.  command_proc must run the protocol command with the arguments
+        # sent to it, _yield_ the payload of each continuation, respond to the
+        # continuation with the result of each _yield_, and _return_ the
+        # command's successful result.  Non-successful results *MUST* raise
+        # an exception.
+        attr_reader :command_proc
+
+        # By default, this simply sets the #client and #command_proc attributes.
+        # Subclasses may override it, for example: to set the appropriate
+        # command_proc automatically.
         def initialize(client, &command_proc)
           @client, @command_proc = client, command_proc
         end
 
-        # Delegates to AuthenticationExchange.authenticate.
+        # Attempt to authenticate #client to the server.
+        #
+        # By default, this simply delegates to
+        # AuthenticationExchange.authenticate.
         def authenticate(...) AuthenticationExchange.authenticate(self, ...) end
 
-        # Do the protocol and server both support an initial response?
-        def sasl_ir_capable?; client.sasl_ir_capable? end
+        ##
+        # method: sasl_ir_capable?
+        # Do the protocol, server, and client all support an initial response?
+        def_delegator :client, :sasl_ir_capable?
 
-        # Does the server advertise support for the mechanism?
-        def auth_capable?(mechanism); client.auth_capable?(mechanism) end
+        ##
+        # method: auth_capable?
+        # call-seq: auth_capable?(mechanism)
+        #
+        # Does the server advertise support for the +mechanism+?
+        def_delegator :client, :auth_capable?
 
-        # Runs the authenticate command with +mechanism+ and +initial_response+.
-        # When +initial_response+ is nil, an initial response must NOT be sent.
+        # Calls command_proc with +command_name+ (see
+        # SASL::ProtocolAdapters::Generic#command_name),
+        # +mechanism+, +initial_response+, and a +continuations_handler+ block.
+        # The +initial_response+ is optional; when it's nil, it won't be sent to
+        # command_proc.
         #
         # Yields each continuation payload, responds to the server with the
         # result of each yield, and returns the result.  Non-successful results
@@ -51,21 +87,36 @@ module Net
         # command to fail.
         #
         # Subclasses that override this may use #command_proc differently.
-        def run_command(mechanism, initial_response = nil, &block)
+        def run_command(mechanism, initial_response = nil, &continuations_handler)
           command_proc or raise Error, "initialize with block or override"
           args = [command_name, mechanism, initial_response].compact
-          command_proc.call(*args, &block)
+          command_proc.call(*args, &continuations_handler)
         end
 
+        ##
+        # method: host
+        # The hostname to which the client connected.
+        def_delegator :client, :host
+
+        ##
+        # method: port
+        # The destination port to which the client connected.
+        def_delegator :client, :port
+
         # Returns an array of server responses errors raised by run_command.
         # Exceptions in this array won't drop the connection.
         def response_errors; [] end
 
-        # Drop the connection gracefully.
-        def drop_connection;  client.drop_connection end
+        ##
+        # method: drop_connection
+        # Drop the connection gracefully, sending a "LOGOUT" command as needed.
+        def_delegator :client, :drop_connection
+
+        ##
+        # method: drop_connection!
+        # Drop the connection abruptly, closing the socket without logging out.
+        def_delegator :client, :drop_connection!
 
-        # Drop the connection abruptly.
-        def drop_connection!; client.drop_connection! end
       end
     end
   end

data/lib/net/imap/sasl/cram_md5_authenticator.rb

@@ -20,7 +20,7 @@ class Net::IMAP::SASL::CramMD5Authenticator
                  warn_deprecation: true,
                  **)
     if warn_deprecation
-      warn "WARNING: CRAM-MD5 mechanism is deprecated." # TODO: recommend SCRAM
+      warn "WARNING: CRAM-MD5 mechanism is deprecated.", category: :deprecated
     end
     require "digest/md5"
     @user = authcid || username || user