net-imap 0.6.7 → 0.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5300636497a02d1c8bc10b528bf1d3fe8aad9898ba02ba3ab40f2329f9306baf
-  data.tar.gz: 449230117bc3289dc13cb1531d95a2ae530558a21a405d8f4effb958773da88d
+  metadata.gz: 9405d034ddfa540378feffe20b4818437ca73913b1d82663cdd56d341ca71553
+  data.tar.gz: 2df46e36cdb6fc77aa6c88838ae684f7c800b5a643b985880e95d802e912a2fd
 SHA512:
-  metadata.gz: b034f4ab8fc449890b3eb29c2049c4af1ed5aac42e8943f0a5eb20d4f9eae910740e0c8d590590f3379121c30ac347ce49f5387dcd4985e2dd551292545bd2de
-  data.tar.gz: 996ab44d2c1f4bf6d5d2e3d141b1890d25a38cddf1e0032726257c63346fc7175bcdd05f3ed97cce3a3ce63d8939154c4d9c4b9e931b035a46d9c4fa1a518450
+  metadata.gz: 554739baaaaa8b0406f729d56447a13d4ced84f33feba90a350851424624483a36765c40f00e34737fe602bd0bd43555a2f480d4f7d9a0af034f791c0c9e0b8a
+  data.tar.gz: '06596b9d2da38bbd53dcc0fd990b66b1af5ffbd52af52370b8366188899043f129e63aae7090054090f8a1b29b8e89e7c96402ffc0aa48101d7f95bf09419a96'

data/.simplecov

@@ -5,9 +5,6 @@ SimpleCov.configure do
   enable_coverage  :method
   enable_coverage  :eval
 
-  # eval branch coverage varies too much between runtime environments
-  ignore_branches :eval_generated
-
   skip "/test/"
   skip "/rakelib/"
   cover "lib/**/*.rb"

data/Gemfile

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

data/Rakefile

@@ -20,52 +20,55 @@ task "test:coverage:report" do
     formatter SimpleCov::Formatter::HTMLFormatter
 
     coverage(:line) do
-      minimum           95
+      minimum  95
 
-      minimum_per_group 98, only: "Config"
-      minimum_per_group 97, only: "StringPrep"
-      minimum_per_group 97, only: "SASL"
-      minimum_per_group 95, only: "Data Types"
-      minimum_per_group 94, only: "Parser"
-      minimum_per_group 92, only: "Client"
+      minimum  98, per: group("Config")
+      minimum  97, per: group("StringPrep")
+      minimum  97, per: group("SASL")
+      minimum  95, per: group("Data Types")
+      minimum  94, per: group("Parser")
+      minimum  92, per: group("Client")
 
-      minimum_per_file  80
-      minimum_per_file  55, only: "lib/net/imap/search_result.rb"
+      minimum  80, per: :file
+      minimum  55, per: "lib/net/imap/search_result.rb"
     end
 
     # NOTE: branch coverage varies more widely between ruby versions
     coverage(:branch) do
-      minimum           80
+      # eval branch coverage varies too much between runtime environments
+      ignore :eval_generated
 
-      minimum_per_group 90, only: "Data Types"
-      minimum_per_group 85, only: "Config"
-      minimum_per_group 80, only: "Client"
-      minimum_per_group 80, only: "Parser"
-      minimum_per_group 70, only: "SASL"
-      minimum_per_group 70, only: "StringPrep"
+      minimum  80
 
-      minimum_per_file  60
-      minimum_per_file  50, only: "lib/net/imap/sasl/authenticators.rb"
-      minimum_per_file  50, only: "lib/net/imap/config/attr_accessors.rb"
+      minimum  90, per: group("Data Types")
+      minimum  85, per: group("Config")
+      minimum  80, per: group("Client")
+      minimum  80, per: group("Parser")
+      minimum  70, per: group("SASL")
+      minimum  70, per: group("StringPrep")
+
+      minimum  60, per: :file
+      minimum  50, per: "lib/net/imap/sasl/authenticators.rb"
+      minimum  50, per: "lib/net/imap/config/attr_accessors.rb"
     end
 
     coverage(:method) do
-      minimum            88
+      minimum  88
 
-      minimum_per_group 100, only: "Config"
-      minimum_per_group  90, only: "Data Types"
-      minimum_per_group  90, only: "StringPrep"
-      minimum_per_group  85, only: "Client"
-      minimum_per_group  80, only: "Parser"
-      minimum_per_group  80, only: "SASL"
+      minimum 100, per: group("Config")
+      minimum  90, per: group("Data Types")
+      minimum  90, per: group("StringPrep")
+      minimum  85, per: group("Client")
+      minimum  80, per: group("Parser")
+      minimum  80, per: group("SASL")
 
-      minimum_per_file   65
-      minimum_per_file   60, only: "lib/net/imap/response_parser/parser_utils.rb"
-      minimum_per_file   55, only: "lib/net/imap/sasl/authenticators.rb"
-      minimum_per_file   50, only: "lib/net/imap/authenticators.rb"
-      minimum_per_file   50, only: "lib/net/imap/sasl/anonymous_authenticator.rb"
-      minimum_per_file   35, only: "lib/net/imap/sasl/protocol_adapters.rb"
-      minimum_per_file   20, only: "lib/net/imap/response_data.rb"
+      minimum  65, per: :file
+      minimum  60, per: "lib/net/imap/response_parser/parser_utils.rb"
+      minimum  55, per: "lib/net/imap/sasl/authenticators.rb"
+      minimum  50, per: "lib/net/imap/authenticators.rb"
+      minimum  50, per: "lib/net/imap/sasl/anonymous_authenticator.rb"
+      minimum  35, per: "lib/net/imap/sasl/protocol_adapters.rb"
+      minimum  20, per: "lib/net/imap/response_data.rb"
     end
   end
 end

data/lib/net/imap/config/attr_type_coercion.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../utils"
+
 module Net
   class IMAP
     class Config
@@ -28,28 +30,14 @@ module Net
         end
         private_class_method :included
 
-        if defined?(Ractor.shareable_proc)
-          def self.safe(&b)
-            case obj = b.call
-            when Proc
-              Ractor.shareable_proc(&obj)
-            else
-              Ractor.make_shareable obj
-            end
-          end
-        elsif defined?(Ractor.make_shareable)
-          def self.safe(&b)
-            obj = nil.instance_eval(&b).freeze
-            Ractor.make_shareable obj
-          end
-        else
-          def self.safe(&b) nil.instance_eval(&b).freeze end
-        end
-        private_class_method :safe
+        extend Utils
 
-        Types = Hash.new do |h, type| type => Proc | nil; safe{type} end
-        Types[:boolean] = Boolean = safe{-> {!!_1}}
-        Types[Integer]  = safe{->{Integer(_1)}}
+        Types = Hash.new do |h, type|
+          type => Proc | nil
+          Utils.shareable{type}
+        end
+        Types[:boolean] = Boolean = shareable{-> {!!_1}}
+        Types[Integer]  = shareable{->{Integer(_1)}}
 
         def self.attr_accessor(attr, type: nil)
           type = Types[type] or return
@@ -57,16 +45,16 @@ module Net
           define_method :"#{attr}?" do send attr end if type == Boolean
         end
 
-        NilOrInteger = safe{->val { Integer val unless val.nil? }}
+        NilOrInteger = shareable{->val { Integer val unless val.nil? }}
 
-        Enum = ->(*enum) {
-          safe_enum = safe{enum}
+        Enum = shareable{->(*enum) {
+          safe_enum = Utils.shareable{enum}
           expected = -"one of #{safe_enum.map(&:inspect).join(", ")}"
-          safe{->val {
+          Utils.shareable{->val {
             return val if safe_enum.include?(val)
             raise ArgumentError, "expected %s, got %p" % [expected, val]
           }}
-        }
+        }}
 
       end
     end

data/lib/net/imap/response_parser/parser_utils.rb

@@ -186,7 +186,7 @@ module Net
         end
 
         def peek_re?(re)
-          assert_no_lookahead if Net::IMAP.debug
+          assert_no_lookahead if config.debug?
           re.match?(@str, @pos)
         end
 

data/lib/net/imap/sequence_set.rb

@@ -2,6 +2,8 @@
 
 require "set" unless defined?(::Set)
 
+require_relative "utils"
+
 module Net
   class IMAP
 
@@ -423,6 +425,8 @@ module Net
     #   representation and returns +self+.
     #
     class SequenceSet
+      include Utils # :nodoc:
+
       # The largest possible non-zero unsigned 32-bit integer
       UINT32_MAX = 2**32 - 1
 
@@ -1019,9 +1023,9 @@ module Net
       # is empty.  (+star+ is ignored when +count+ is given.)
       #
       # Related: #min, #minmax, #slice
-      def max(count = nil, star: :*)
-        if count
-          count = Integer(count.to_int)
+      def max(count = (unset_count = true; nil), star: :*)
+        if !unset_count
+          count = implicit_int(count)
           raise ArgumentError, 'negative count' if count < 0
           return remain_frozen_empty if count == 0
           if cardinality <= count
@@ -1046,9 +1050,9 @@ module Net
       # is empty.  (+star+ is ignored when +count+ is given.)
       #
       # Related: #max, #minmax, #slice
-      def min(count = nil, star: :*)
-        if count
-          count = Integer(count.to_int)
+      def min(count = (unset_count = true; nil), star: :*)
+        if !unset_count
+          count = implicit_int(count)
           raise ArgumentError, 'negative count' if count < 0
           slice(0...count) || remain_frozen_empty
         elsif (val = min_num)
@@ -1360,7 +1364,7 @@ module Net
       #
       # Related: #delete, #delete?, #slice!, #subtract, #difference
       def delete_at(index)
-        slice! Integer(index.to_int)
+        slice! implicit_int index
       end
 
       # :call-seq:
@@ -1376,9 +1380,10 @@ module Net
       # #string will be regenerated after deletion.
       #
       # Related: #slice, #delete_at, #delete, #delete?, #subtract, #difference
-      def slice!(index, length = nil)
+      def slice!(index, length = (length_unset = true; nil))
         modifying! # short-circuit before slice
-        deleted = slice(index, length) and subtract deleted
+        deleted = length_unset ? slice(index) : slice(index, length)
+        subtract deleted if deleted
         deleted
       end
 
@@ -1720,7 +1725,7 @@ module Net
       #
       # Related: #[], #slice, #ordered_at
       def at(index)
-        seek_number_in_minmaxes(minmaxes, index)
+        export_num sorted_set_num_at implicit_int index
       end
 
       # :call-seq: ordered_at(index) -> integer or nil
@@ -1733,22 +1738,55 @@ module Net
       #
       # Related: #[], #slice, #ordered_at
       def ordered_at(index)
-        seek_number_in_minmaxes(each_entry_minmax, index)
+        export_num ordered_list_num_at implicit_int index
       end
 
       # :call-seq:
       #    seqset[index]         -> integer or :* or nil
       #    slice(index)          -> integer or :* or nil
-      #    seqset[start, length] -> sequence set or nil
-      #    slice(start, length)  -> sequence set or nil
+      #    seqset[index, length] -> sequence set or nil
+      #    slice(index, length)  -> sequence set or nil
       #    seqset[range]         -> sequence set or nil
       #    slice(range)          -> sequence set or nil
       #
       # Returns a number or a subset from the _sorted_ set, without modifying
       # the set.
       #
+      # With a single +index+ argument, returns an integer or +:*+ or nil:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0]     #=> 10
+      #     set[-1]    #=> 26
+      #
+      # With +index+ and +length+ arguments, returns a new SequenceSet or nil:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[1, 2]  #=> Net::IMAP::SequenceSet["11:12"]
+      #     set[-2, 2] #=> Net::IMAP::SequenceSet["23,26"]
+      #
+      # With a single +range+ argument, returns a new SequenceSet or nil:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0...2] #=> Net::IMAP::SequenceSet["10:11"]
+      #     set[0..2]  #=> Net::IMAP::SequenceSet["11:12"]
+      #     set[0..-2] #=> Net::IMAP::SequenceSet["10:15,20:23"]
+      #     set[-6..6] #=> Net::IMAP::SequenceSet["15,20"]
+      #
+      # Note that the result is based on the sorted and de-duplicated set, not
+      # on the ordered #entries in #string.
+      #
+      #     set = Net::IMAP::SequenceSet["12,20:23,11:16,21"]
+      #     set[0]   #=> 11
+      #     set[-1]  #=> 23
+      #
+      # This behaves like <tt>Array#slice</tt> on a virtual array of all of the
+      # monotonically sorted #numbers in +self+:
+      #     # WARNING: For illustration only.  Do NOT do this with large sets.
+      #     sliced_array = seqset.numbers[*args] and
+      #       sliced_set = Net::IMAP::SequenceSet(sliced_array)
+      #     set.slice(*args) == sliced_set  #=> true
+      #
+      # ==== Number lookup by index
+      #
       # When an Integer argument +index+ is given, the number at offset +index+
-      # in the sorted set is returned:
+      # in the sorted set is returned.
       #
       #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
       #     set[0]   #=> 10
@@ -1759,24 +1797,86 @@ module Net
       #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
       #     set[-1]  #=> 26
       #     set[-3]  #=> 22
-      #     set[-6]  #=> 15
-      #
-      # If +index+ is out of range, +nil+ is returned.
+      #     set[-11] #=> 10
       #
+      # The range for +index+ is <tt>-cardinality...cardinality</tt>.
+      # If +index+ is out of range, returns +nil+.
       #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
       #     set[11]  #=> nil
       #     set[-12] #=> nil
       #
-      # The result is based on the sorted and de-duplicated set, not on the
-      # ordered #entries in #string.
+      # With a single Integer argument, this behaves identically to #at.
       #
-      #     set = Net::IMAP::SequenceSet["12,20:23,11:16,21"]
-      #     set[0]   #=> 11
-      #     set[-1]  #=> 23
+      # ==== Subset slice by index and length
+      #
+      # When two Integer arguments, +index+ and +length+ are given, returns a
+      # new SequenceSet containing the +length+ successive numbers beginning at
+      # offset +index+.:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0, 2]  #=> Net::IMAP::SequenceSet["10:11"]
+      #     set[1, 2]  #=> Net::IMAP::SequenceSet["11:12"]
+      #
+      # If <tt>index + length</tt> is greater than #cardinality, returns all
+      # elements from +index+ to the end:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0, 15] #=> Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[5, 10] #=> Net::IMAP::SequenceSet["15,20:23,26"]
+      #     set[10, 5] #=> Net::IMAP::SequenceSet["26"]
+      #
+      # If +index+ is equal to #cardinality, returns a new empty SequenceSet.
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[11, 5] #=> Net::IMAP::SequenceSet.empty
+      #
+      # If +length+ is negative, returns +nil+.
+      #     set = Net::IMAP::SequenceSet[1..10]
+      #     set[5, -1] #=> nil
+      #
+      # If +index+ is out of range (absolute value greater than #cardinality),
+      # returns +nil+.
+      #
+      # If +index+ is in range and +length+ is zero, returns a new empty
+      # SequenceSet.
+      #
+      # ==== Subset slice by index range
+      #
+      # When a single Range argument +range+ is given, returns a new SequenceSet
+      # containing the successive numbers at the offsets indicated by +range+.
+      #
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0...2]   #=> Net::IMAP::SequenceSet["10:11"]
+      #     set[2..4]    #=> Net::IMAP::SequenceSet["12:14"]
+      #
+      #     set[-2..-1]  #=> Net::IMAP::SequenceSet["23,26"]
+      #     set[-4...-2] #=> Net::IMAP::SequenceSet["21:22"]
+      #
+      #     set[4..-4]   #=> Net::IMAP::SequenceSet["14:15,20:21"]
+      #     set[-6...6]  #=> Net::IMAP::SequenceSet["15"]
+      #
+      # An end-less range slices until the last number, and a begin-less range
+      # slices from the first number.
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[..3]    #=> Net::IMAP::SequenceSet["10:13"]
+      #     set[..-3]   #=> Net::IMAP::SequenceSet["10:15,20:22"]
+      #     set[-2..]   #=> Net::IMAP::SequenceSet["23,26"]
+      #     set[2..]    #=> Net::IMAP::SequenceSet["12:15,20:23,26"]
       #
-      # Related: #at
-      def [](index, length = nil)
-        if    length              then slice_length(index, length)
+      # When +range.begin+ points to a smaller index than +range.end+, a new
+      # empty SequenceSet is returned.
+      #
+      #     set = Net::IMAP::SequenceSet[1..10]
+      #     set[5.. 4]  #=> SequenceSet.empty
+      #     set[-4..-5] #=> SequenceSet.empty
+      #     set[5..-6]  #=> SequenceSet.empty
+      #
+      # If +range.begin+ is out of range (absolute value greater than
+      # #cardinality), returns +nil+.
+      #
+      # This behaves similarly to a slice with +range.begin+ as +index+ and
+      # +range.size+ as +length+, when that both sides of the range are either
+      # negative or non-negative.  Note that the minimum +range.size+ is zero,
+      # so this can't return +nil+ for a negative range length.
+      def [](index, length = (length_unset = true; nil))
+        if    !length_unset       then slice_length(index, length)
         elsif index.is_a?(Range)  then slice_range(index)
         else                           at(index)
         end
@@ -2282,15 +2382,22 @@ module Net
       ######################################################################{{{2
       # Number indexing methods
 
+      def sorted_set_num_at(index)
+        seek_number_in_minmaxes(minmaxes, index)
+      end
+
+      def ordered_list_num_at(index)
+        seek_number_in_minmaxes(each_entry_minmax, index)
+      end
+
       def seek_number_in_minmaxes(minmaxes, index)
-        index = Integer(index.to_int)
         if index.negative?
           reverse_each_minmax_with_index(minmaxes) do |min, max, idx_min, idx_max|
-            idx_min <= index and return export_num(min + (index - idx_min))
+            idx_min <= index and return min + (index - idx_min)
           end
         else
           each_minmax_with_index(minmaxes) do |min, _, idx_min, idx_max|
-            index <= idx_max and return export_num(min + (index - idx_min))
+            index <= idx_max and return min + (index - idx_min)
           end
         end
         nil
@@ -2316,30 +2423,41 @@ module Net
       end
 
       def slice_length(start, length)
-        start  = Integer(start.to_int)
-        length = Integer(length.to_int)
-        raise ArgumentError, "length must be positive" unless length.positive?
-        last = start + length - 1 unless start.negative? && start.abs <= length
-        slice_range(start..last)
+        start  = implicit_int(start)
+        length = implicit_int(length)
+        return nil if length.negative?
+        stop   = start + length unless start.negative? && start.abs <= length
+        slice_range(start...stop)
       end
 
       def slice_range(range)
-        first = range.begin ||  0
-        last  = range.end   || -1
-        if range.exclude_end?
-          return remain_frozen_empty if last.zero?
-          last -= 1 if range.end && last != STAR_INT
-        end
-        if (first * last).positive? && last < first
-          remain_frozen_empty
-        elsif (min = at(first))
-          max = at(last)
-          max = :* if max.nil?
-          if    max == :*  then self & (min..)
-          elsif min <= max then self & (min..max)
+        first = implicit_int(range.begin || 0)
+        rend  = implicit_int(range.end) unless range.end.nil?
+        excl  = range.exclude_end?
+        last = !(excl && rend == 0) &&        # (i...0)
+          (excl && rend&.pred || rend || -1)  # (i...j) vs (i..j) vs (i...)
+        if !last || first.negative? == last.negative? && last < first
+          remain_frozen_empty if valid_slice_start?(first)
+        elsif (min = sorted_set_num_at(first))
+          max = sorted_set_num_at(last) || (last.negative? ? 0 : STAR_INT)
+          if    min <= max then intersection export_minmax_entry [min, max]
           else                  remain_frozen_empty
           end
+        elsif first.positive?
+          remain_frozen_empty if valid_slice_start?(first)
+        end
+      end
+
+      # By short-circuiting, this is a small performance improvement over
+      # `offset.abs <= cardinality`.  But, slice_range should get a bigger
+      # performance boost by combining this scan with the start offset scan.
+      def valid_slice_start?(offset)
+        offset = offset.abs
+        minmaxes.each do |min, max|
+          offset -= (max - min).succ
+          return true if offset.negative?
         end
+        !offset.positive?
       end
 
       ######################################################################{{{2

data/lib/net/imap/utils.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+# :enddoc:
+
+module Net
+  class IMAP < Protocol
+
+    # INTERNAL utility methods.  API is unstable and subject to change.
+    module Utils
+      module_function
+
+      # Something like this exists in ruby's C API.  Why not in ruby's ruby?
+      def implicit_int(input)
+        Integer.try_convert(input) or
+          raise TypeError, case input
+            when nil
+              "no implicit conversion from %p to Integer" % [input]
+            when true, false
+              "no implicit conversion of %p into Integer" % [input]
+            else
+              "no implicit conversion of %s into Integer" % [input.class.name]
+            end
+      end
+
+      if defined?(Ractor.shareable_proc)
+        def shareable
+          case obj = yield
+          when Proc
+            Ractor.shareable_proc(&obj)
+          else
+            Ractor.make_shareable obj
+          end
+        end
+
+      # simplecov:disable
+      elsif defined?(Ractor.make_shareable)
+        def shareable(&b)
+          obj = nil.instance_eval(&b).freeze
+          Ractor.make_shareable obj
+        end
+      else
+        def shareable(&b) nil.instance_eval(&b).freeze end
+      end
+      # simplecov:enable
+
+    end
+  end
+end

data/lib/net/imap.rb

@@ -933,7 +933,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.7"
+    VERSION = "0.6.8"
 
     # Aliases for supported capabilities, to be used with the #enable command.
     ENABLE_ALIASES = {
@@ -3702,7 +3702,7 @@ module Net
       s = Socket.tcp(host, port, :connect_timeout => open_timeout)
       s.setsockopt(:SOL_SOCKET, :SO_KEEPALIVE, true)
       s
-    rescue Errno::ETIMEDOUT
+    rescue Errno::ETIMEDOUT, IO::TimeoutError
       raise Net::OpenTimeout, "Timeout to open TCP connection to " +
         "#{host}:#{port} (exceeds #{open_timeout} seconds)"
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: net-imap
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.6.8
 platform: ruby
 authors:
 - Shugo Maeda
@@ -102,6 +102,7 @@ files:
 - lib/net/imap/stringprep/tables.rb
 - lib/net/imap/stringprep/trace.rb
 - lib/net/imap/uidplus_data.rb
+- lib/net/imap/utils.rb
 - lib/net/imap/vanished_data.rb
 - net-imap.gemspec
 - rakelib/benchmarks.rake
@@ -132,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 4.0.22
 specification_version: 4
 summary: Ruby client api for Internet Message Access Protocol
 test_files: []