net-imap 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4e6a6afb6888a5be474a97195f41e06a2e1706d9f65a0700f17bce7f6dd82af
-  data.tar.gz: 3dd62a4e251d29e9e72e5538f548623662ed2ff16da46deadf8843585f8db658
+  metadata.gz: e9a3148dcf057ea22dbb67a976576ca59060038a8352fc1a71f3ec4cd928289b
+  data.tar.gz: 38e9bbc72d9d90bad28b24f47305d6376c6b17e41233af747bfd3cae27cdfc2e
 SHA512:
-  metadata.gz: bc73faf474cb22965f3ec95bdae48d13514505d4072f0fe3ca47f1dbccc8b04aad404e90ecd2b04afa7dc401dc2f66d087fea316b26e46edf1403945e7e3c305
-  data.tar.gz: 9c10a3b062c88f6145deb1adbbe3e8a2574e9f4dac39c2b7706fbc84643ee031891dae270197f910ceda3e5d0513f0929d574889e506c53a6f5048cb9be36dfa
+  metadata.gz: f5f9f4ade6c25741a402ea78c81928ab455c9b8c6bff5998ae884d567257cb823a16195aa148abc7d9215aa9d0bdce3632904e0f921f061174b04ccdfd4abf9c
+  data.tar.gz: 683fe61b95035387e6f651565174f6499a0f68e712287e904318f05e23fc24f195035a4c29eaeedbeb42a24401e7f2884f8e75af359d623daf098da402f8aaea

data/lib/net/imap/response_parser.rb

@@ -198,6 +198,7 @@ module Net
         #                     ; revisions of this specification.
         # flag-keyword    = "$MDNSent" / "$Forwarded" / "$Junk" /
         #                   "$NotJunk" / "$Phishing" / atom
+        #
         # flag-perm       = flag / "\*"
         #
         # Not checking for max one mbx-list-sflag in the parser.
@@ -220,19 +221,15 @@ module Net
         MBX_FLAG          = FLAG_EXTENSION
 
         # flag-list       = "(" [flag *(SP flag)] ")"
-        #
-        # part of resp-text-code:
-        # >>>
-        #   "PERMANENTFLAGS" SP "(" [flag-perm *(SP flag-perm)] ")"
-        #
-        # parens from mailbox-list are included in the regexp:
-        # >>>
-        #   mbx-list-flags  = *(mbx-list-oflag SP) mbx-list-sflag
-        #                     *(SP mbx-list-oflag) /
-        #                     mbx-list-oflag *(SP mbx-list-oflag)
-        FLAG_LIST      = /\G\((#{FLAG     }(?:#{SP}#{FLAG     })*|)\)/ni
-        FLAG_PERM_LIST = /\G\((#{FLAG_PERM}(?:#{SP}#{FLAG_PERM})*|)\)/ni
-        MBX_LIST_FLAGS = /\G\((#{MBX_FLAG }(?:#{SP}#{MBX_FLAG })*|)\)/ni
+        # resp-text-code =/ "PERMANENTFLAGS" SP
+        #                   "(" [flag-perm *(SP flag-perm)] ")"
+        # mbx-list-flags  = *(mbx-list-oflag SP) mbx-list-sflag
+        #                   *(SP mbx-list-oflag) /
+        #                   mbx-list-oflag *(SP mbx-list-oflag)
+        # (Not checking for max one mbx-list-sflag in the parser.)
+        FLAG_LIST         = /\G\((#{FLAG     }(?:#{SP}#{FLAG     })*|)\)/ni
+        FLAG_PERM_LIST    = /\G\((#{FLAG_PERM}(?:#{SP}#{FLAG_PERM})*|)\)/ni
+        MBX_LIST_FLAGS    = /\G  (#{MBX_FLAG }(?:#{SP}#{MBX_FLAG })*)   /nix
 
         # RFC3501:
         #   QUOTED-CHAR   = <any TEXT-CHAR except quoted-specials> /
@@ -777,34 +774,47 @@ module Net
 
       # RFC3501 & RFC9051:
       #   response-tagged = tag SP resp-cond-state CRLF
-      #
-      #   resp-cond-state = ("OK" / "NO" / "BAD") SP resp-text
-      #                       ; Status condition
-      #
-      #   tag             = 1*<any ASTRING-CHAR except "+">
       def response_tagged
-        tag  = tag();                 SP!
-        name = resp_cond_state__name; SP!
-        TaggedResponse.new(tag, name, resp_text, @str)
+        TaggedResponse.new(tag, *(SP!; resp_cond_state), @str)
       end
 
       # RFC3501 & RFC9051:
       #   resp-cond-state  = ("OK" / "NO" / "BAD") SP resp-text
+      #
+      # NOTE: In the spirit of RFC9051 Appx E 23 (and to workaround existing
+      # servers), we don't require a final SP and instead parse this as:
+      #
+      #   resp-cond-state = ("OK" / "NO" / "BAD") [SP resp-text]
+      def resp_cond_state
+        [resp_cond_state__name, SP? ? resp_text : ResponseText::EMPTY]
+      end
+
       def resp_cond_state__untagged
-        name = resp_cond_state__name; SP!
-        UntaggedResponse.new(name, resp_text, @str)
+        UntaggedResponse.new(*resp_cond_state, @str)
       end
 
       #   resp-cond-auth   = ("OK" / "PREAUTH") SP resp-text
+      #
+      # NOTE: In the spirit of RFC9051 Appx E 23 (and to workaround existing
+      # servers), we don't require a final SP and instead parse this as:
+      #
+      #   resp-cond-auth   = ("OK" / "PREAUTH") [SP resp-text]
       def resp_cond_auth
-        name = resp_cond_auth__name; SP!
-        UntaggedResponse.new(name, resp_text, @str)
+        UntaggedResponse.new(resp_cond_auth__name,
+                             SP? ? resp_text : ResponseText::EMPTY,
+                             @str)
       end
 
       #   resp-cond-bye    = "BYE" SP resp-text
+      #
+      # NOTE: In the spirit of RFC9051 Appx E 23 (and to workaround existing
+      # servers), we don't require a final SP and instead parse this as:
+      #
+      #   resp-cond-bye    = "BYE" [SP resp-text]
       def resp_cond_bye
-        name = label(BYE); SP!
-        UntaggedResponse.new(name, resp_text, @str)
+        UntaggedResponse.new(label(BYE),
+                             SP? ? resp_text : ResponseText::EMPTY,
+                             @str)
       end
 
       #   message-data    = nz-number SP ("EXPUNGE" / ("FETCH" SP msg-att))
@@ -928,41 +938,57 @@ module Net
       # this represents the partial size for BODY or BINARY
       alias gt__number__lt atom
 
+      # RFC3501 & RFC9051:
+      #   envelope        = "(" env-date SP env-subject SP env-from SP
+      #                     env-sender SP env-reply-to SP env-to SP env-cc SP
+      #                     env-bcc SP env-in-reply-to SP env-message-id ")"
       def envelope
         @lex_state = EXPR_DATA
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          result = nil
-        else
-          match(T_LPAR)
-          date = nstring
-          match(T_SPACE)
-          subject = nstring
-          match(T_SPACE)
-          from = address_list
-          match(T_SPACE)
-          sender = address_list
-          match(T_SPACE)
-          reply_to = address_list
-          match(T_SPACE)
-          to = address_list
-          match(T_SPACE)
-          cc = address_list
-          match(T_SPACE)
-          bcc = address_list
-          match(T_SPACE)
-          in_reply_to = nstring
-          match(T_SPACE)
-          message_id = nstring
-          match(T_RPAR)
-          result = Envelope.new(date, subject, from, sender, reply_to,
-                                to, cc, bcc, in_reply_to, message_id)
-        end
+        lpar; date        = env_date
+        SP!;  subject     = env_subject
+        SP!;  from        = env_from
+        SP!;  sender      = env_sender
+        SP!;  reply_to    = env_reply_to
+        SP!;  to          = env_to
+        SP!;  cc          = env_cc
+        SP!;  bcc         = env_bcc
+        SP!;  in_reply_to = env_in_reply_to
+        SP!;  message_id  = env_message_id
+        rpar
+        Envelope.new(date, subject, from, sender, reply_to,
+                     to, cc, bcc, in_reply_to, message_id)
+      ensure
         @lex_state = EXPR_BEG
-        return result
       end
 
+      #   env-date        = nstring
+      #   env-subject     = nstring
+      #   env-in-reply-to = nstring
+      #   env-message-id  = nstring
+      alias env_date        nstring
+      alias env_subject     nstring
+      alias env_in_reply_to nstring
+      alias env_message_id  nstring
+
+      #   env-from        = "(" 1*address ")" / nil
+      #   env-sender      = "(" 1*address ")" / nil
+      #   env-reply-to    = "(" 1*address ")" / nil
+      #   env-to          = "(" 1*address ")" / nil
+      #   env-cc          = "(" 1*address ")" / nil
+      #   env-bcc         = "(" 1*address ")" / nil
+      def nlist__address
+        return if NIL?
+        lpar; list = [address]; list << address until rpar?
+        list
+      end
+
+      alias env_from     nlist__address
+      alias env_sender   nlist__address
+      alias env_reply_to nlist__address
+      alias env_to       nlist__address
+      alias env_cc       nlist__address
+      alias env_bcc      nlist__address
+
       #   date-time       = DQUOTE date-day-fixed "-" date-month "-" date-year
       #                     SP time SP zone DQUOTE
       alias date_time quoted
@@ -1321,18 +1347,17 @@ module Net
       alias mailbox_data__lsub  mailbox_data__list
       alias mailbox_data__xlist mailbox_data__list
 
+      # mailbox-list    = "(" [mbx-list-flags] ")" SP
+      #                    (DQUOTE QUOTED-CHAR DQUOTE / nil) SP mailbox
+      #                    [SP mbox-list-extended]
+      #             ; This is the list information pointed to by the ABNF
+      #             ; item "mailbox-data", which is defined above
       def mailbox_list
-        attr = flag_list
-        match(T_SPACE)
-        token = match(T_QUOTED, T_NIL)
-        if token.symbol == T_NIL
-          delim = nil
-        else
-          delim = token.value
-        end
-        match(T_SPACE)
-        name = astring
-        return MailboxList.new(attr, delim, name)
+        lpar; attr  = peek_rpar? ? [] : mbx_list_flags; rpar
+        SP!;  delim = nquoted
+        SP!;  name  = mailbox
+        # TODO: mbox-list-extended
+        MailboxList.new(attr, delim, name)
       end
 
       def getquota_response
@@ -1458,66 +1483,55 @@ module Net
       end
       alias sort_data mailbox_data__search
 
+      # RFC5256: THREAD
+      #   thread-data     = "THREAD" [SP 1*thread-list]
       def thread_data
-        token = match(T_ATOM)
-        name = token.value.upcase
-        token = lookahead
-
-        if token.symbol == T_SPACE
-          threads = []
-
-          while true
-            shift_token
-            token = lookahead
-
-            case token.symbol
-            when T_LPAR
-              threads << thread_branch(token)
-            when T_CRLF
-              break
-            end
-          end
-        else
-          # no member
-          threads = []
+        name    = label("THREAD")
+        threads = []
+        if SP?
+          threads << thread_list while lookahead_thread_list?
         end
-
-        return UntaggedResponse.new(name, threads, @str)
+        UntaggedResponse.new(name, threads, @str)
       end
 
-      def thread_branch(token)
-        rootmember = nil
-        lastmember = nil
-
-        while true
-          shift_token    # ignore first T_LPAR
-          token = lookahead
+      alias lookahead_thread_list?   lookahead_lpar?
+      alias lookahead_thread_nested? lookahead_thread_list?
 
-          case token.symbol
-          when T_NUMBER
-            # new member
-            newmember = ThreadMember.new(number, [])
-            if rootmember.nil?
-              rootmember = newmember
-            else
-              lastmember.children << newmember
-            end
-            lastmember = newmember
-          when T_SPACE
-            # do nothing
-          when T_LPAR
-            if rootmember.nil?
-              # dummy member
-              lastmember = rootmember = ThreadMember.new(nil, [])
-            end
+      # RFC5256: THREAD
+      #   thread-list     = "(" (thread-members / thread-nested) ")"
+      def thread_list
+        lpar
+        thread = if lookahead_thread_nested?
+                   ThreadMember.new(nil, thread_nested)
+                 else
+                   thread_members
+                 end
+        rpar
+        thread
+      end
 
-            lastmember.children << thread_branch(token)
-          when T_RPAR
-            break
+      # RFC5256: THREAD
+      #   thread-members  = nz-number *(SP nz-number) [SP thread-nested]
+      def thread_members
+        members = []
+        members << nz_number # thread root
+        while SP?
+          case lookahead!(T_NUMBER, T_LPAR).symbol
+          when T_NUMBER then members << nz_number
+          else               nested = thread_nested; break
           end
         end
+        members.reverse.inject(nested || []) {|subthreads, number|
+          [ThreadMember.new(number, subthreads)]
+        }.first
+      end
 
-        return rootmember
+      # RFC5256: THREAD
+      #   thread-nested   = 2*thread-list
+      def thread_nested
+        nested = [thread_list, thread_list]
+        while lookahead_thread_list? do nested << thread_list end
+        nested
       end
 
       #   mailbox-data    =/ "STATUS" SP mailbox SP "(" [status-att-list] ")"
@@ -1864,61 +1878,40 @@ module Net
         UIDPlusData.new(validity, src_uids, dst_uids)
       end
 
-      def address_list
-        token = lookahead
-        if token.symbol == T_NIL
-          shift_token
-          return nil
-        else
-          result = []
-          match(T_LPAR)
-          while true
-            token = lookahead
-            case token.symbol
-            when T_RPAR
-              shift_token
-              break
-            when T_SPACE
-              shift_token
-            end
-            result.push(address)
-          end
-          return result
-        end
-      end
-
-      ADDRESS_REGEXP = /\G\
-(?# 1: NAME     )(?:NIL|"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)") \
-(?# 2: ROUTE    )(?:NIL|"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)") \
-(?# 3: MAILBOX  )(?:NIL|"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)") \
-(?# 4: HOST     )(?:NIL|"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)")\
-\)/ni
-
+      ADDRESS_REGEXP = /\G
+        \( (?: NIL | #{Patterns::QUOTED_rev2} )  # 1: NAME
+        \s (?: NIL | #{Patterns::QUOTED_rev2} )  # 2: ROUTE
+        \s (?: NIL | #{Patterns::QUOTED_rev2} )  # 3: MAILBOX
+        \s (?: NIL | #{Patterns::QUOTED_rev2} )  # 4: HOST
+        \)
+      /nix
+
+      #   address         = "(" addr-name SP addr-adl SP addr-mailbox SP
+      #                     addr-host ")"
+      #   addr-adl        = nstring
+      #   addr-host       = nstring
+      #   addr-mailbox    = nstring
+      #   addr-name       = nstring
       def address
-        match(T_LPAR)
-        if @str.index(ADDRESS_REGEXP, @pos)
-          # address does not include literal.
-          @pos = $~.end(0)
-          name = $1
-          route = $2
-          mailbox = $3
-          host = $4
-          for s in [name, route, mailbox, host]
-            Patterns.unescape_quoted! s
-          end
-        else
-          name = nstring
-          match(T_SPACE)
-          route = nstring
-          match(T_SPACE)
-          mailbox = nstring
-          match(T_SPACE)
-          host = nstring
-          match(T_RPAR)
+        if (match = accept_re(ADDRESS_REGEXP))
+          # note that "NIL" isn't captured by the regexp
+          name, route, mailbox, host = match.captures
+            .map { Patterns.unescape_quoted _1 }
+        else # address may include literals
+          lpar; name    = addr_name
+          SP!;  route   = addr_adl
+          SP!;  mailbox = addr_mailbox
+          SP!;  host    = addr_host
+          rpar
         end
-        return Address.new(name, route, mailbox, host)
+        Address.new(name, route, mailbox, host)
       end
 
+      alias addr_adl     nstring
+      alias addr_host    nstring
+      alias addr_mailbox nstring
+      alias addr_name    nstring
+
       # flag-list       = "(" [flag *(SP flag)] ")"
       def flag_list
         match_re(Patterns::FLAG_LIST, "flag-list")[1]
@@ -1933,22 +1926,10 @@ module Net
           .map! { _1.start_with?("\\") ? _1[1..].capitalize.to_sym : _1 }
       end
 
-      # Not checking for max one mbx-list-sflag in the parser.
-      # >>>
-      #   mbx-list-flags  = *(mbx-list-oflag SP) mbx-list-sflag
-      #                     *(SP mbx-list-oflag) /
-      #                     mbx-list-oflag *(SP mbx-list-oflag)
-      #   mbx-list-oflag  = "\Noinferiors" / child-mbox-flag /
-      #                     "\Subscribed" / "\Remote" / flag-extension
-      #                  ; Other flags; multiple from this list are
-      #                  ; possible per LIST response, but each flag
-      #                  ; can only appear once per LIST response
-      #   mbx-list-sflag  = "\NonExistent" / "\Noselect" / "\Marked" /
-      #                     "\Unmarked"
-      #                  ; Selectability flags; only one per LIST response
-      def parens__mbx_list_flags
+      # See Patterns::MBX_LIST_FLAGS
+      def mbx_list_flags
         match_re(Patterns::MBX_LIST_FLAGS, "mbx-list-flags")[1]
-          .split(nil).map! { _1.capitalize.to_sym }
+          .split(nil).map! { _1[1..].capitalize.to_sym }
       end
 
       # See https://developers.google.com/gmail/imap/imap-extensions

data/lib/net/imap.rb

@@ -690,7 +690,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.4.5"
+    VERSION = "0.4.6"
 
     # Aliases for supported capabilities, to be used with the #enable command.
     ENABLE_ALIASES = {
@@ -1692,13 +1692,14 @@ module Net
     # and returns the status of the indicated +mailbox+. +attr+ is a list of one
     # or more attributes whose statuses are to be requested.
     #
-    # The return value is a hash of attributes.
+    # The return value is a hash of attributes.  Most status attributes return
+    # integer values, but some return other value types (documented below).
     #
     # A Net::IMAP::NoResponseError is raised if status values
     # for +mailbox+ cannot be returned; for instance, because it
     # does not exist.
     #
-    # ===== Supported attributes:
+    # ===== Supported attributes
     #
     # +MESSAGES+::    The number of messages in the mailbox.
     #
@@ -1715,7 +1716,7 @@ module Net
     #     the sum of all messages' +RFC822.SIZE+ fetch item values.
     #
     # +MAILBOXID+::
-    #     A server-allocated unique identifier for the mailbox.
+    #     A server-allocated unique _string_ identifier for the mailbox.
     #     See +OBJECTID+
     #     {[RFC8474]}[https://www.rfc-editor.org/rfc/rfc8474.html#section-4].
     #
@@ -1723,6 +1724,9 @@ module Net
     #     The number of messages with the <tt>\Recent</tt> flag.
     #     _NOTE:_ +RECENT+ was removed from IMAP4rev2.
     #
+    # Unsupported attributes may be requested.  The attribute value will be
+    # either an Integer or an ExtensionData object.
+    #
     # ===== For example:
     #
     #   p imap.status("inbox", ["MESSAGES", "RECENT"])
@@ -1734,6 +1738,8 @@ module Net
     # <tt>STATUS=SIZE</tt>
     # {[RFC8483]}[https://www.rfc-editor.org/rfc/rfc8483.html].
     #
+    # +DELETED+ requires the server's capabilities to include +IMAP4rev2+.
+    #
     # +MAILBOXID+ requires the server's capabilities to include +OBJECTID+
     # {[RFC8474]}[https://www.rfc-editor.org/rfc/rfc8474.html].
     def status(mailbox, attr)

data/rakelib/benchmarks.rake

@@ -42,7 +42,7 @@ file "benchmarks/parser.yml" => PARSER_TEST_FIXTURES do |t|
 
   benchmarks = tests.map {|fixture_name, response|
     {"name"    => fixture_name.delete_prefix("test_"),
-     "prelude" => "response = %s" % [response.dump],
+     "prelude" => "response = -%s.b" % [response.dump],
      "script"  => "parser.parse(response)"}
   }
     .sort_by { _1["name"] }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: net-imap
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors:
 - Shugo Maeda
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-13 00:00:00.000000000 Z
+date: 2023-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-protocol
@@ -148,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Ruby client api for Internet Message Access Protocol