net-imap 0.6.4.1 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 032600f694434b77edab2496c4bff9a7adc5c912301c0a7b386706dfccdc2345
-  data.tar.gz: 69dd23250cda6c1eb7a9bbeabe10969389c10047f12610d6bec3407d23e16854
+  metadata.gz: cd2bbaf7d6564739894405f3066c772976b48062ea2c696b741d10aa34ebbed6
+  data.tar.gz: 1fa2b00d9869e60e44be3a3aea1e058f0974705aef5a41a62f4ea25ee4fda48d
 SHA512:
-  metadata.gz: 98ede1ee28c608ceea04bd5a00a114029da96eae454dc222cb046308c625241df423ceac7811322e6f641f3899ba1ca7a7d3f1bbfbf839632d2cf1a01c963c59
-  data.tar.gz: 810b3514de99b738216d7d49c917a05ee0c73211530bd81fe55540d158736dd7ba84f841d13f6d959b3dca01c3e32d792e500e7ee8f8eb5a2ab6899a53bf095e
+  metadata.gz: dc1083920d0f196a21db61ef8282be1aa214e43b38ba18bf5ada58fa16d9b007f2169332fc0df2e5799e2ec1e76f15b1469d0c2401e851feb0409237b7f60ee2
+  data.tar.gz: 4b9c9ba8892b67ec86c39f4ad3f28c5dd91ad785def8b9324175a0f6bac6940dffde3499135f045a911dde98646afff687c2bd6381117f14bdf68de244f03dea

data/.simplecov

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+SimpleCov.configure do
+  formatter SimpleCov::Formatter::HTMLFormatter
+
+  enable_coverage  :branch
+  enable_coverage  :method
+  enable_coverage  :eval
+
+  skip "/test/"
+  skip "/rakelib/"
+  cover "lib/**/*.rb"
+
+  group "Parser",     %w[lib/net/imap/response_parser.rb
+                         lib/net/imap/response_parser]
+
+  group "Client",     %w[lib/net/imap.rb
+                         lib/net/imap/connection_state.rb
+                         lib/net/imap/deprecated_client_options.rb
+                         lib/net/imap/errors.rb
+                         lib/net/imap/response_reader.rb]
+
+  group "Config",     %w[lib/net/imap/config.rb
+                         lib/net/imap/config]
+
+  group "Data Types", %w[lib/net/imap/flags.rb
+                         lib/net/imap/sequence_set.rb] +
+                         [%r{lib/net/imap/\w*_data\.rb},
+                          %r{lib/net/imap/\w*_result.rb},
+                          %r{lib/net/imap/data_\w+\.rb}]
+
+  group "SASL",       %w[lib/net/imap/sasl.rb
+                         lib/net/imap/sasl
+                         lib/net/imap/sasl_adapter.rb
+                         lib/net/imap/authenticators.rb]
+
+  group "StringPrep", %w[lib/net/imap/stringprep.rb
+                         lib/net/imap/stringprep]
+end

data/Gemfile

@@ -20,7 +20,5 @@ gem "benchmark-driver", require: false
 gem "vernier", require: false, platform: :mri
 
 group :test do
-  gem "simplecov",        require: false, platforms: %i[mri windows]
-  gem "simplecov-html",   require: false, platforms: %i[mri windows]
-  gem "simplecov-json",   require: false, platforms: %i[mri windows]
+  gem "simplecov", ">= 1.0.0", require: false, platforms: %i[mri windows]
 end

data/Rakefile

@@ -11,3 +11,14 @@ Rake::TestTask.new(:test) do |t|
 end
 
 task :default => :test
+
+desc "Output coverage data report, and error when threshholds aren't met"
+task "coverage:report" do
+  require "simplecov"
+  SimpleCov.collate "coverage/.resultset.json" do
+    coverage(:line) do
+      minimum           90
+      minimum_per_file  40
+    end
+  end
+end

data/lib/net/imap/command_data.rb

@@ -15,6 +15,9 @@ module Net
       case data
       when nil
       when String
+        if data.include?("\0")
+          raise DataFormatError, "String argument contains NULL byte"
+        end
       when Integer
         # Covers modseq-valzer, which is the largest valid IMAP integer
         if data.negative?
@@ -55,28 +58,39 @@ module Net
       end
     end
 
+    UNQUOTABLE_CHARS = /\0\r\n/
+    ASTRING_SPECIALS = /[(){ \x00-\x1f\x7f%*"\\]/
+    private_constant :UNQUOTABLE_CHARS, :ASTRING_SPECIALS
+
+    # Sends generic strings formatted as +astring+:
+    # * as an atom (note: this is based on +ASTRING-CHAR+, not +ATOM-CHAR+)
+    # * as a quoted string
+    # * as a literal (may send non-synchronizing)
+    #
+    # NOTE: This does not validate that +str+ contains no +NULL+ bytes.
     def send_string_data(str, tag = nil)
       if str.empty?
+        # same as send_quoted_string(str), but incompatible encoding is allowed
         put_string('""')
-      elsif str.match?(/[\r\n]/n)
-        # literal, because multiline
-        send_literal(str, tag)
-      elsif !str.ascii_only?
-        if @utf8_strings
-          # quoted string
-          send_quoted_string(str)
-        else
-          # literal, because of non-ASCII bytes
-          send_literal(str, tag)
-        end
-      elsif str.match?(/[(){ \x00-\x1f\x7f%*"\\]/n)
-        # quoted string
+      elsif str.ascii_only? && !str.match?(ASTRING_SPECIALS)
+        # valid +astring+ atom: non-empty, ASCII only, no ASTRING_SPECIALS
+        put_string(str)
+      elsif text_encodable?(str) && !str.match?(UNQUOTABLE_CHARS)
         send_quoted_string(str)
       else
-        put_string(str)
+        send_literal(str, tag)
       end
     end
 
+    # Encodable as +text+ (which is a superset of +quoted+):
+    # * ASCII only (for any ASCII compatible encoding)
+    # * or valid UTF-8 (when the connection supports it)
+    def text_encodable?(str)
+      str.ascii_only? || (utf8_enabled? &&
+                          str.encoding == Encoding::UTF_8 &&
+                          str.valid_encoding?)
+    end
+
     def send_quoted_string(str) = QuotedString.new(data: str).send_data(self)
 
     def send_binary_literal(*, **) = send_literal(*, **, binary: true)
@@ -108,8 +122,7 @@ module Net
         @continuation_request_exception = nil
         begin
           @continuation_request_arrival.wait
-          e = @continuation_request_exception || @exception
-          raise e if e
+          reraise @continuation_request_exception || @exception
           put_string(str)
         ensure
           @continued_command_tag = nil
@@ -154,6 +167,9 @@ module Net
     def send_date_data(date) put_string Net::IMAP.encode_date(date) end
     def send_time_data(time) put_string Net::IMAP.encode_time(time) end
 
+    # NOTE: Currently for internal use only.  The API is expected to change.
+    Command = Data.define(:tag, :name) # :nodoc:
+
     CommandData = Data.define(:data) do # :nodoc:
       def self.validate(...)
         data = new(...)
@@ -271,6 +287,17 @@ module Net
       private_class_method :extract_literal
     end
 
+    # Please note that +ATOM-CHAR+ and +atom+ are not the same as +ASTRING-char+
+    # and the atom form of +astring+.  +astring+ allows <tt>]</tt>, but +atom+
+    # does not.
+    #
+    # Generic string arguments in Net::IMAP use +astring+, so they will send as
+    # atoms even if they contain <tt>]</tt>.
+    #
+    # This class is used by:
+    # * to validate generic symbol arguments, as the superclass of Flag
+    # * to validate #enable +capabilities+
+    # * to validate #store (and #uid_store) +attr+
     class Atom < CommandData # :nodoc:
       def initialize(**)
         super

data/lib/net/imap/errors.rb

@@ -279,7 +279,11 @@ module Net
     #
     # This is different from UnknownResponseError: the response has been
     # rejected.  Although it may be parsable, the server is forbidden from
-    # sending it in the current context.  The client should automatically
+    # sending it in the current context.
+    #
+    # This could be caused by a bug in the server or in Net::IMAP.  Or it
+    # might indicate a malicious server, a man-in-the-middle attack, or
+    # client-side command injection.  So the client should automatically
     # disconnect, abruptly (without logout).
     #
     # Note that InvalidResponseError does not inherit from ResponseError: it
@@ -288,6 +292,67 @@ module Net
     class InvalidResponseError < Error
     end
 
+    # Error raised when the server sends a tagged #response that is invalid for
+    # the #command #state.
+    #
+    # This could be caused by a bug in the server or in Net::IMAP.  Or it
+    # might indicate a malicious server, a man-in-the-middle attack, or
+    # client-side command injection, so the client should disconnect
+    # automatically and abruptly (without logout).
+    class InvalidTaggedResponseError < InvalidResponseError
+      # A symbol representing the state of the matching tagged command.
+      #
+      # +:unknown+::
+      #   #response does not match any known command (#command will be +nil+).
+      # +:unstarted+::
+      #   Any tagged #response is invalid before #command starts sending.
+      # +:incomplete+::
+      #   A tagged +OK+ #response is invalid before #command is fully sent.
+      # +:completed+::
+      #   Multiple tagged responses were received for the same command.
+      #
+      # NOTE: Command state is neither anticipated nor remembered indefinitely.
+      # +:unknown+ is used before the matching command is called and after the
+      # it is forgotten.
+      #
+      # NOTE: This version of Net::IMAP does not detect or raise an exception
+      # for all of these states.
+      attr_reader :state
+
+      # Metadata about the matching IMAP command.
+      #
+      # Returns +nil+ when #state is +:unknown+.
+      #
+      # NOTE: The non-nil return type is an unstable API, for debug only.  It
+      # may be changed by any release, without warning or deprecation.
+      attr_reader :command
+
+      # The TaggedResponse which triggered this error
+      attr_reader :response
+
+      def initialize(state, response:, command: nil)
+        response => TaggedResponse[tag:, name: status]
+        case [state, status, command]
+        in :unknown,                _,    nil
+        in :incomplete,             "OK", {tag: ^tag, name:}
+        in :unstarted | :completed, _,    {tag: ^tag, name:}
+        end
+        @state, @command, @response = state, command, response
+        cmd_desc = name ? "#{state} #{name}" : state
+        super "Received tagged #{status} to #{cmd_desc} command (tag=#{tag})"
+      rescue NoMatchingPatternError => err
+        raise ArgumentError, err.message
+      end
+
+      def detailed_message(**)
+        "#{message}.\n" \
+          "Disconnecting: This could indicate a malicious server, a " \
+          "man-in-the-middle attack, a client-side command injection, or " \
+          "a bug in net-imap.\n" \
+          "response.data=#{response.data.inspect}"
+      end
+    end
+
     # Error raised upon an unknown response from the server.
     #
     # This is different from InvalidResponseError: the response may be a

data/lib/net/imap.rb

@@ -326,6 +326,11 @@ module Net
   #
   #   <em>In general, #capable? should be used rather than explicitly sending a
   #   +CAPABILITY+ command to the server.</em>
+  # - #enable: Enables backwards incompatible server extensions.
+  #   <em>Requires the +ENABLE+ or +IMAP4rev2+ capability.</em>
+  # - #enabled: Returns a set of enabled server extensions.
+  # - #enabled?: Returns whether a server extension has been enabled.
+  # - #utf8_enabled?: Returns whether UTF-8 string encoding has been enabled.
   #
   # === Handling server responses
   #
@@ -552,6 +557,7 @@ module Net
   # ==== RFC6855: <tt>UTF8=ACCEPT</tt>, <tt>UTF8=ONLY</tt>
   #
   # - See #enable for information about support for UTF-8 string encoding.
+  # - #utf8_enabled?: Returns whether UTF-8 string encoding has been enabled.
   #
   # ==== RFC7162: +CONDSTORE+
   #
@@ -813,7 +819,7 @@ module Net
   # * {IMAP URLAUTH Authorization Mechanism Registry}[https://www.iana.org/assignments/urlauth-authorization-mechanism-registry/urlauth-authorization-mechanism-registry.xhtml]
   #
   class IMAP < Protocol
-    VERSION = "0.6.4.1"
+    VERSION = "0.6.5"
 
     # Aliases for supported capabilities, to be used with the #enable command.
     ENABLE_ALIASES = {
@@ -821,6 +827,11 @@ module Net
       "UTF8=ONLY" => "UTF8=ACCEPT",
     }.freeze
 
+    # Aliases for supported capabilities, to be used with #enabled?.
+    ENABLED_ALIASES = {
+      utf8: Set.new(%w[UTF8=ACCEPT IMAP4REV2]).freeze,
+    }.freeze
+
     dir = File.expand_path("imap", __dir__)
     autoload :ConnectionState,        "#{dir}/connection_state"
     autoload :ResponseReader,         "#{dir}/response_reader"
@@ -1110,11 +1121,11 @@ module Net
       @ssl_ctx_params, @ssl_ctx = build_ssl_ctx(ssl)
 
       # Basic Client State
-      @utf8_strings = false
       @debug_output_bol = true
       @exception = nil
       @greeting = nil
       @capabilities = nil
+      @enabled = Set.new
       @tls_verified = false
       @connection_state = ConnectionState::NotAuthenticated.new
 
@@ -1193,9 +1204,10 @@ module Net
     # Waits for receiver thread to close before returning, except when called
     # from inside the connection mutex such as from a response handler.  Slow or
     # stuck response handlers can cause #disconnect to hang until they complete.
+    # Use +timeout+ to limit how long to wait for the receiver thread to exit.
     #
     # Related: #logout, #logout!
-    def disconnect
+    def disconnect(timeout: nil)
       in_logout_state = try_state_logout?
       return if disconnected?
       in_receiver_thread = Thread.current == @receiver_thread
@@ -1207,7 +1219,7 @@ module Net
         @receiver_thread.raise(e) unless in_receiver_thread
       end
       @sock.close
-      @receiver_thread.join unless mon_owned? || in_receiver_thread
+      @receiver_thread.join(timeout) unless mon_owned? || in_receiver_thread
       raise e if e
     ensure
       # Try again after shutting down the receiver thread.  With no reciever
@@ -1469,7 +1481,7 @@ module Net
       end
       if error
         disconnect
-        raise error
+        reraise error
       end
       unless handled
         disconnect
@@ -3160,12 +3172,48 @@ module Net
       synchronize do
         send_command("ENABLE", *capabilities)
         result = clear_responses("ENABLED").last || []
-        @utf8_strings ||= result.include? "UTF8=ACCEPT"
-        @utf8_strings ||= result.include? "IMAP4REV2"
+        @enabled.merge(result.map(&:upcase))
         result
       end
     end
 
+    # Returns whether UTF-8 string encoding has been enabled for the connection.
+    #
+    # This is currently identical to calling #enabled? with +:utf8+.
+    #
+    # See #enable and #enabled?.
+    def utf8_enabled?; enabled?(:utf8) end
+
+    # Returns whether +capability+ is in the set of #enabled capabilities,
+    # matched case-insensitively.
+    #
+    # When +capability+ is +:utf8+, it matches if _either_
+    # <tt>"UTF8=ACCEPT"</tt> or <tt>"IMAP4REV2"</tt> is enabled.
+    #
+    # See #enable and #utf8_enabled?.
+    def enabled?(capability)
+      case capability
+      in String
+        capability = capability.upcase
+        synchronize { @enabled.include?(capability) }
+      in Symbol
+        capabilities = ENABLED_ALIASES[capability] or
+          raise ArgumentError, "unknown capability alias: #{capability}"
+        synchronize { @enabled.intersect?(capabilities) }
+      else
+        raise TypeError, "expected capability to be String or Symbol, " \
+                         "got %s" % [capability.class]
+      end
+    end
+
+    # Returns a set of enabled capabilities for the connection, as upper-cased
+    # strings.
+    #
+    # See #enable and #enabled?.
+    def enabled
+      synchronize { @enabled.dup }
+    end
+
     # Sends an {IDLE command [RFC2177 §3]}[https://www.rfc-editor.org/rfc/rfc6851#section-3]
     # {[IMAP4rev2 §6.3.13]}[https://www.rfc-editor.org/rfc/rfc9051#section-6.3.13]
     # that waits for notifications of new or expunged messages.  Yields
@@ -3202,8 +3250,9 @@ module Net
 
       synchronize do
         tag = Thread.current[:net_imap_tag] = generate_tag
-        guard_against_tagged_response_skipping_handler!(tag, "IDLE")
+        command = Command[tag:, name: "IDLE"]
         put_string("#{tag} IDLE#{CRLF}")
+        finish_sending_command(command)
 
         begin
           add_response_handler(&response_handler)
@@ -3211,7 +3260,7 @@ module Net
           @idle_done_cond.wait(timeout)
           @idle_done_cond = nil
           if @receiver_thread_terminating
-            raise @exception || Net::IMAP::Error.new("connection closed")
+            reraise @exception || Net::IMAP::Error.new("connection closed")
           end
         ensure
           remove_response_handler(response_handler)
@@ -3220,6 +3269,9 @@ module Net
             response = get_tagged_response(tag, "IDLE", idle_response_timeout)
           end
         end
+      rescue InvalidResponseError
+        disconnect
+        raise
       end
 
       return response
@@ -3511,67 +3563,28 @@ module Net
     end
 
     def receive_responses
-      connection_closed = false
-      until connection_closed
-        synchronize do
-          @exception = nil
-        end
-        begin
-          resp = get_response
-        rescue Exception => e
-          synchronize do
-            state_logout!
-            @sock.close
-            @exception = e
-          end
-          break
-        end
-        unless resp
-          synchronize do
-            @exception = EOFError.new("end of file reached")
-          end
-          break
-        end
-        begin
-          synchronize do
-            case resp
-            when TaggedResponse
-              @tagged_responses[resp.tag] = resp
-              @tagged_response_arrival.broadcast
-              case resp.tag
-              when @logout_command_tag
-                state_logout!
-                return
-              when @continued_command_tag
-                @continuation_request_exception =
-                  RESPONSE_ERRORS[resp.name].new(resp)
-                @continuation_request_arrival.signal
-              end
-            when UntaggedResponse
-              record_untagged_response(resp)
-              if resp.name == "BYE" && @logout_command_tag.nil?
-                state_logout!
-                @sock.close
-                @exception = ByeResponseError.new(resp)
-                connection_closed = true
-              end
-            when ContinuationRequest
-              @continuation_request_arrival.signal
-            end
-            state_unselected! if resp in {data: {code: {name: "CLOSED"}}}
-            @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
+      exception = nil
+      loop do
+        resp = get_response or raise EOFError, "end of file reached"
+        handle_response(resp) or return
       end
+    rescue Exception => exception
+      # NOTE: this rescue clause is only capturing the exception for the ensure
+      # clause.  Using `$!` in the ensure clause seems to trigger a weird
+      # TruffleRuby bug: https://github.com/truffleruby/truffleruby/issues/4308
+      #
+      # We don't assign @exception directly here, because we want that to be
+      # atomically synchronized with all of the other changes in `ensure`.
+      raise
+    ensure
       synchronize do
+        if exception
+          # Handling exceptions here, not in a rescue clause, so the lock isn't
+          # released and reacquired between rescue and ensure clauses.
+          @exception ||= exception
+          @sock.close
+        end
+        state_logout!
         @receiver_thread_terminating = true
         @tagged_response_arrival.broadcast
         @continuation_request_arrival.broadcast
@@ -3579,36 +3592,6 @@ module Net
           @idle_done_cond.signal
         end
       end
-    ensure
-      state_logout!
-    end
-
-    def get_tagged_response(tag, cmd, timeout = nil)
-      if timeout
-        deadline = Time.now + timeout
-      end
-      until @tagged_responses.key?(tag)
-        raise @exception if @exception
-        if timeout
-          timeout = deadline - Time.now
-          if timeout <= 0
-            return nil
-          end
-        end
-        @tagged_response_arrival.wait(timeout)
-      end
-      resp = @tagged_responses.delete(tag)
-      case resp.name
-      when /\A(?:OK)\z/ni
-        return resp
-      when /\A(?:NO)\z/ni
-        raise NoResponseError, resp
-      when /\A(?:BAD)\z/ni
-        raise BadResponseError, resp
-      else
-        disconnect
-        raise InvalidResponseError, "invalid tagged resp: %p" % [resp.raw_data.chomp]
-      end
     end
 
     def get_response
@@ -3621,6 +3604,47 @@ module Net
     #############################
     # built-in response handlers
 
+    def handle_response(resp)
+      connection_closed = false
+      synchronize do
+        case resp
+        when TaggedResponse
+          @tagged_responses[resp.tag] = resp
+          @tagged_response_arrival.broadcast
+          case resp.tag
+          when @logout_command_tag
+            state_logout!
+            return
+          when @continued_command_tag
+            @continuation_request_exception =
+              RESPONSE_ERRORS[resp.name].new(resp)
+            @continuation_request_arrival.signal
+          end
+        when UntaggedResponse
+          record_untagged_response(resp)
+          if resp.name == "BYE" && @logout_command_tag.nil?
+            state_logout!
+            @sock.close
+            @exception = ByeResponseError.new(resp)
+            connection_closed = true
+          end
+        when ContinuationRequest
+          @continuation_request_arrival.signal
+        end
+        state_unselected! if resp in {data: {code: {name: "CLOSED"}}}
+        @response_handlers.each do |handler|
+          handler.call(resp)
+        end
+      rescue Exception => e
+        @exception = e
+        @tagged_response_arrival.broadcast
+        @continuation_request_arrival.broadcast
+      ensure
+        @exception = nil unless connection_closed
+      end
+      !connection_closed
+    end
+
     # store name => [..., data]
     def record_untagged_response(resp)
       @responses[resp.name] << resp.data
@@ -3657,18 +3681,17 @@ module Net
     end
 
     def send_command(cmd, *args, &block)
+      args.each do validate_data _1 end
       synchronize do
-        args.each do |i|
-          validate_data(i)
-        end
         tag = generate_tag
+        command = Command[tag:, name: cmd]
         put_string(tag + " " + cmd)
         args.each do |i|
           put_string(" ")
           send_data(i, tag)
         end
         @logout_command_tag = tag if cmd == "LOGOUT"
-        guard_against_tagged_response_skipping_handler!(tag, cmd)
+        finish_sending_command(command)
         add_response_handler(&block) if block
         begin
           put_string(CRLF)
@@ -3676,20 +3699,78 @@ module Net
         ensure
           remove_response_handler(block) if block
         end
+      rescue InvalidResponseError
+        disconnect
+        raise
+      end
+    end
+
+    # NOTE: This must be synchronized with sending the command's final CRLF and
+    # adding any command-related response handlers.
+    def finish_sending_command(command)
+      if (response = @tagged_responses[command.tag])&.name&.casecmp?("OK")
+        raise InvalidTaggedResponseError.new(:incomplete, command:, response:)
+      end
+    end
+
+    def get_tagged_response(tag, cmd, timeout = nil)
+      if timeout
+        deadline = Time.now + timeout
+      end
+      until @tagged_responses.key?(tag)
+        reraise @exception
+        if timeout
+          timeout = deadline - Time.now
+          if timeout <= 0
+            return nil
+          end
+        end
+        @tagged_response_arrival.wait(timeout)
+      end
+      resp = @tagged_responses.delete(tag)
+      case resp.name
+      when /\A(?:OK)\z/ni
+        return resp
+      when /\A(?:NO)\z/ni
+        raise NoResponseError, resp
+      when /\A(?:BAD)\z/ni
+        raise BadResponseError, resp
+      else
+        disconnect
+        raise InvalidResponseError, "invalid tagged resp: %p" % [resp.raw_data.chomp]
       end
-    rescue InvalidResponseError
-      disconnect
-      raise
     end
 
-    def guard_against_tagged_response_skipping_handler!(tag, cmd)
-      return unless (resp = @tagged_responses[tag])&.name&.upcase == "OK"
-      raise InvalidResponseError, format(
-        "Received tagged 'OK' to incomplete %s command (tag=%s).  " \
-        "This could indicate a malicious server, a man-in-the-middle, or " \
-        "client-side command injection.  Disconnecting.",
-        cmd, tag
-      )
+    # Raises a copy of +exception+ with an updated +backtrace+ and +cause+, or
+    # returns +nil+ when +exception+ is falsey.
+    #
+    # +backtrace+ is set to reflect the current caller.
+    #
+    # +cause+ is set to the original exception, _if_ the original has its own
+    # backtrace or cause.  Otherwise, the original was never raised and the
+    # default cause is used.
+    #
+    # This is meant for exceptions that may have been created by another thread.
+    # Raising them directly gives a misleading backtrace, making it hard to
+    # discover where the errors originate.  Although it is sometimes more
+    # appropriate to raise a wrapping exception, that changes the API and forces
+    # updates to users' `rescue` pattern matching.
+    def reraise(exception)
+      return unless exception
+      copy = exception.dup
+      # NOTE: set_backtrace(caller_locations) doesn't work for CRuby <= 3.3.
+      #   and set_backtrace(nil) doesn't work for TruffleRuby 34.0.0:
+      #   https://github.com/truffleruby/truffleruby/issues/4296
+      if RUBY_ENGINE == "truffleruby"
+        copy.set_backtrace caller_locations
+      else
+        copy.set_backtrace nil
+      end
+      if exception.cause || exception.backtrace
+        raise copy, cause: exception
+      else
+        raise copy
+      end
     end
 
     def generate_tag

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: net-imap
 version: !ruby/object:Gem::Version
-  version: 0.6.4.1
+  version: 0.6.5
 platform: ruby
 authors:
 - Shugo Maeda
@@ -48,6 +48,7 @@ extra_rdoc_files: []
 files:
 - ".document"
 - ".rdoc_options"
+- ".simplecov"
 - BSDL
 - COPYING
 - Gemfile
@@ -131,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.13
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Ruby client api for Internet Message Access Protocol
 test_files: []