tdiary 5.5.0 → 5.6.0

data/vendor/bundle/ruby/3.4.0/gems/{net-imap-0.5.15 → net-imap-0.6.6}/lib/net/imap/response_parser.rb

@@ -38,6 +38,11 @@ module Net
         @lex_state = EXPR_BEG
         @token = nil
         return response
+      rescue ResponseParseError => error
+        if config.debug?
+          warn error.detailed_message(parser_state: true, parser_backtrace: true)
+        end
+        raise
       end
 
       private
@@ -686,6 +691,8 @@ module Net
         CRLF!
         EOF!
         resp
+      rescue SystemStackError
+        parse_error("response recursion too deep")
       end
 
       # RFC3501 & RFC9051:
@@ -1883,12 +1890,17 @@ module Net
       # We leniently re-interpret this as
       #   resp-text       = ["[" resp-text-code "]" [SP [text]] / [text]
       def resp_text
-        if lbra?
-          code = resp_text_code; rbra
-          ResponseText.new(code, SP? && text? || "")
-        else
-          ResponseText.new(nil, text? || "")
+        begin
+          state = current_state
+          if lbra?
+            code = resp_text_code; rbra
+            return ResponseText.new(code, SP? && text? || "")
+          end
+        rescue ResponseParseError => error
+          raise if /\buid-set\b/i.match? error.message
+          restore_state state
         end
+        ResponseText.new(nil, text? || "")
       end
 
       # RFC3501 (See https://www.rfc-editor.org/errata/rfc3501):
@@ -1951,6 +1963,7 @@ module Net
       #   resp-text-code   =/ "UIDREQUIRED"
       def resp_text_code
         name = resp_text_code__name
+        state = current_state
         data =
           case name
           when "CAPABILITY"         then resp_code__capability
@@ -1973,8 +1986,18 @@ module Net
           when "MAILBOXID"          then SP!; parens__objectid     # RFC8474: OBJECTID
           when "UIDREQUIRED"        then                           # RFC9586: UIDONLY
           else
+            state = nil # don't backtrack
             SP? and text_chars_except_rbra
           end
+        peek_rbra? or
+          parse_error("expected resp-text-code %p to be complete", name)
+        ResponseCode.new(name, data)
+      rescue Net::IMAP::ResponseParseError => parse_error
+        raise unless state
+        raise if parse_error.message.include?("uid-set")
+        restore_state state
+        unparsed_data = SP? && text_chars_except_rbra
+        data = InvalidParseData[parse_error:, unparsed_data:, parsed_data: data]
         ResponseCode.new(name, data)
       end
 
@@ -2017,24 +2040,24 @@ module Net
         CopyUID(validity, src_uids, dst_uids)
       end
 
-      def AppendUID(...) DeprecatedUIDPlus(...) || AppendUIDData.new(...) end
-      def CopyUID(...)   DeprecatedUIDPlus(...) || CopyUIDData.new(...)   end
+      PARSER_PATH = File.expand_path(__FILE__).delete_suffix(".rb")
 
       # 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
+        uplevel = caller_locations
+          .find_index { !_1.path.start_with?(PARSER_PATH) }
+          &.succ
+        warn("#{Config}#parser_use_deprecated_uidplus_data is ignored " \
+             "since v0.6.0.  Disable this warning by setting " \
+             "config.parser_use_deprecated_uidplus_data = false.",
+             category: :deprecated, uplevel:)
+        nil
       end
 
+      def AppendUID(...) DeprecatedUIDPlus(...) || AppendUIDData.new(...) end
+      def CopyUID(...)   DeprecatedUIDPlus(...) || CopyUIDData.new(...)   end
+
       ADDRESS_REGEXP = /\G
         \( (?: NIL | #{Patterns::QUOTED_rev2} )  # 1: NAME
         \s (?: NIL | #{Patterns::QUOTED_rev2} )  # 2: ROUTE
@@ -2263,20 +2286,12 @@ module Net
       end
 
       def literal_token(len, type = T_LITERAL)
-        len = coerce_number64 len.to_i
+        len = NumValidator.coerce_number64 len
         val = @str[@pos, len]
         @pos += len
         Token.new(type, val)
       end
 
-      # copied/adapted from NumValidator in v0.6
-      def coerce_number64(num)
-        int = num.to_i
-        return int if 0 <= int && int <= 0x7fff_ffff_ffff_ffff
-        raise DataFormatError,
-          "number64 must be unsigned 63-bit integer: #{num}"
-      end
-
     end
   end
 end

data/vendor/bundle/ruby/3.4.0/gems/{net-imap-0.5.15 → net-imap-0.6.6}/lib/net/imap/response_reader.rb

@@ -10,14 +10,21 @@ module Net
 
       def initialize(client, sock)
         @client, @sock = client, sock
+        # cached config
+        @max_response_size = nil
+        # response buffer state
         @buff = @literal_size = nil
       end
 
       def read_response_buffer
+        @max_response_size = client.max_response_size
         @buff = String.new
         catch :eof do
           while true
+            guard_response_too_large!
             read_line
+            # check before allocating memory for literal
+            guard_response_too_large!
             break unless literal_size
             read_literal
           end
@@ -29,6 +36,10 @@ module Net
 
       private
 
+      # cached config
+      attr_reader :max_response_size
+
+      # response buffer state
       attr_reader :buff, :literal_size
 
       def bytes_read          = buff.bytesize
@@ -44,26 +55,18 @@ module Net
       end
 
       def read_line
-        line = (@sock.gets(CRLF, read_limit) or throw :eof)
-        buff << line
-        max_response_remaining! unless line_done?
+        line = (@sock.gets(CRLF, max_response_remaining) or throw :eof)
         @literal_size = get_literal_size(line)
+        buff << line
       end
 
       def read_literal
-        # check before allocating memory for literal
-        max_response_remaining!
         literal = String.new(capacity: literal_size)
-        buff << (@sock.read(read_limit(literal_size), literal) or throw :eof)
+        buff << (@sock.read(literal_size, literal) or throw :eof)
       ensure
         @literal_size = nil
       end
 
-      def read_limit(limit = nil)
-        [limit, max_response_remaining!].compact.min
-      end
-
-      def max_response_size      = client.max_response_size
       def max_response_remaining = max_response_size &.- bytes_read
       def response_too_large?    = max_response_size &.< min_response_size
       def min_response_size      = bytes_read + min_response_remaining
@@ -72,21 +75,13 @@ module Net
         empty? ? 3 : done? ? 0 : (literal_size || 0) + 2
       end
 
-      def max_response_remaining!
-        return max_response_remaining unless response_too_large?
+      def guard_response_too_large!
+        return unless response_too_large?
         raise ResponseTooLargeError.new(
           max_response_size:, bytes_read:, literal_size:,
         )
       end
 
-      # copied/adapted from NumValidator in v0.6
-      def coerce_number64(num)
-        int = num.to_i
-        return int if 0 <= int && int <= 0x7fff_ffff_ffff_ffff
-        raise DataFormatError,
-          "number64 must be unsigned 63-bit integer: #{num}"
-      end
-
     end
   end
 end

data/vendor/bundle/ruby/3.4.0/gems/{net-imap-0.5.15 → net-imap-0.6.6}/lib/net/imap/sasl/scram_authenticator.rb

@@ -204,13 +204,13 @@ module Net
         attr_reader :server_error
 
         # Memoized ScramAlgorithm#salted_password (needs #salt and #iterations)
-        def salted_password; @salted_password ||= compute_salted { super } end
+        def salted_password = @salted_password ||= compute_salted { super }
 
         # Memoized ScramAlgorithm#client_key (needs #salt and #iterations)
-        def client_key; @client_key ||= compute_salted { super } end
+        def client_key = @client_key ||= compute_salted { super }
 
         # Memoized ScramAlgorithm#server_key (needs #salt and #iterations)
-        def server_key; @server_key ||= compute_salted { super } end
+        def server_key = @server_key ||= compute_salted { super }
 
         # Returns a new OpenSSL::Digest object, set to the appropriate hash
         # function for the chosen mechanism.

data/vendor/bundle/ruby/3.4.0/gems/{net-imap-0.5.15 → net-imap-0.6.6}/lib/net/imap/search_result.rb

@@ -7,6 +7,12 @@ module Net
     # identifiers returned by Net::IMAP#uid_search.
     #
     # For backward compatibility, SearchResult inherits from Array.
+    #
+    # ==== Compatibility with ESearchResult
+    #
+    # Note that both SearchResult and ESearchResult implement +each+, +to_a+,
+    # and +to_sequence_set+.  These methods can be used regardless of whether
+    # the server returns +SEARCH+ or +ESEARCH+ data (or no data).
     class SearchResult < Array
 
       # Returns a SearchResult populated with the given +seq_nums+.
@@ -117,7 +123,11 @@ module Net
       #     Net::IMAP::SearchResult[9, 1, 2, 4, 10, 12, 3, modseq: 123_456]
       #       .to_sequence_set
       #     # => Net::IMAP::SequenceSet["1:4,9:10,12"]
-      def to_sequence_set; SequenceSet[*self] end
+      #
+      # >>>
+      #   *NOTE:* +SORT+ order is not preserved.  The result will be sorted.
+      #
+      def to_sequence_set; empty? ? SequenceSet.empty : SequenceSet[to_a] end
 
       def pretty_print(pp)
         return super if modseq.nil?