net-imap 0.4.25 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf05b4f7aec9127531e83134b740620da216f847851f8ca464ef54e71e3431ad
-  data.tar.gz: 18361d6ee25983da0e4814d42a0ec851e10ce88789559e30778a945a7024a297
+  metadata.gz: 2c89d97e842bce303df112c3fbc0f048f20a2ff1dbf3b85bb2314ea0d2e207c5
+  data.tar.gz: 11d6ec196e1e768f61a17b0ce7f385a11eb03e3e92af8ab327ba9a90699ee940
 SHA512:
-  metadata.gz: 697214c436f129746ad8986dde31e4b819854cf131472158c4aacf5a35ef665b8529528bd0a843ba17d9be105711b4163ecccfa525989d9fe0b3f807f4ae9d58
-  data.tar.gz: ef657a1dbfd5bc73fa317248ae19589a842f87eabfe966b43b026e9dceff68d510621d3e17136b266d22f68b85d20fc22b4ea67a482fdca193d8a5290c643abf
+  metadata.gz: ca70e20c3c70f4ca57822f70936546adb3129dd7c0771ef2d054b0356ed4f6a994b7453803cc06bd25ebb37dc0ed10f60b5541bc56749dee38a6126264344599
+  data.tar.gz: 2921a79dbdab7bd0476d883c18db50150388d587c711270faac99ad4505574a23e6532fe61a4fb48f51c8bddea6641d96f81d9dcbe245b4d4f4542fcc7418566

data/Gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gemspec
 
-# gem "digest"  # not included as a workaround for #576
+gem "digest"
 gem "strscan"
 gem "base64"
 
@@ -13,4 +13,10 @@ gem "rdoc"
 gem "test-unit"
 gem "test-unit-ruby-core", git: "https://github.com/ruby/test-unit-ruby-core"
 
-gem "benchmark-driver"
+gem "benchmark-driver", require: false
+
+group :test do
+  gem "simplecov",        require: false
+  gem "simplecov-html",   require: false
+  gem "simplecov-json",   require: false
+end

data/lib/net/imap/authenticators.rb

@@ -9,7 +9,7 @@ module Net::IMAP::Authenticators
       "%s.%s is deprecated.  Use %s.%s instead." % [
         Net::IMAP, __method__, Net::IMAP::SASL, __method__
       ],
-      uplevel: 1
+      uplevel: 1, category: :deprecated
     )
     Net::IMAP::SASL.add_authenticator(...)
   end
@@ -20,7 +20,7 @@ module Net::IMAP::Authenticators
       "%s.%s is deprecated.  Use %s.%s instead." % [
         Net::IMAP, __method__, Net::IMAP::SASL, __method__
       ],
-      uplevel: 1
+      uplevel: 1, category: :deprecated
     )
     Net::IMAP::SASL.authenticator(...)
   end

data/lib/net/imap/command_data.rb

@@ -14,19 +14,17 @@ module Net
       when nil
       when String
       when Integer
-        # Covers modseq-valzer, which is the largest valid IMAP integer
-        if data.negative?
-          raise DataFormatError, "Integer argument must be unsigned: #{data}"
-        elsif 0xffff_ffff_ffff_ffff < data
-          raise DataFormatError, "Integer argument must fit in 64 bits: #{data}"
-        end
+        NumValidator.ensure_number(data)
       when Array
-        data.each do |i|
-          validate_data(i)
+        if data[0] == 'CHANGEDSINCE'
+          NumValidator.ensure_mod_sequence_value(data[1])
+        else
+          data.each do |i|
+            validate_data(i)
+          end
         end
       when Time, Date, DateTime
       when Symbol
-        Flag.validate(data)
       else
         data.validate
       end
@@ -47,7 +45,7 @@ module Net
       when Date
         send_date_data(data)
       when Symbol
-        Flag[data].send_data(self, tag)
+        send_symbol_data(data)
       else
         data.send_data(self, tag)
       end
@@ -79,31 +77,9 @@ module Net
       put_string('"' + str.gsub(/["\\]/, "\\\\\\&") + '"')
     end
 
-    def send_binary_literal(*a, **kw) send_literal(*a, **kw, binary: true) end
-
-    # `non_sync` is an optional tri-state flag:
-    # * `true`  -> Force non-synchronizing `LITERAL+`/`LITERAL-` behavior.
-    #   NOTE: raises DataFormatError when server doesn't support
-    #   non-synchronizing literal, or literal is too large for LITERAL-.
-    # * `false` -> Force normal synchronizing literal behavior.
-    # * `nil`   -> (default) Currently behaves like `false` (will be dynamic).
-    #   TODO: Dynamic, based on capabilities and bytesize.
-    def send_literal(str, tag = nil, binary: false, non_sync: nil)
-      bytesize = str.bytesize
+    def send_literal(str, tag = nil)
       synchronize do
-        if non_sync && !non_sync_literal_allowed?(bytesize)
-          # TODO: check in Printer, so we don't need to close the connection.
-          @sock.close
-          raise DataFormatError, "Connection closed: " \
-            "Cannot send non-synchronizing literal without known server support"
-        end
-        prefix = "~" if binary
-        plus = "+" if non_sync
-        put_string("#{prefix}{#{bytesize}#{plus}}\r\n")
-        if non_sync
-          put_string(str)
-          return
-        end
+        put_string("{" + str.bytesize.to_s + "}" + CRLF)
         @continued_command_tag = tag
         @continuation_request_exception = nil
         begin
@@ -118,18 +94,8 @@ module Net
       end
     end
 
-    def non_sync_literal_allowed?(bytesize)
-      return unless capabilities_cached?
-      return "+" if capable?("LITERAL+")
-      return "-" if capable_literal_minus? && bytesize <= 4096
-      false
-    end
-
-    def capable_literal_minus?; capable?("LITERAL-") || capable?("IMAP4rev2") end
-
-    # NOTE: +num+ should already be an Integer
     def send_number_data(num)
-      put_string(Integer(num).to_s)
+      put_string(num.to_s)
     end
 
     def send_list_data(list, tag = nil)
@@ -149,236 +115,71 @@ 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
 
-    # simplistic emulation of CommandData = Data.define(:data)
-    class CommandData # :nodoc:
-      class << self
-        def new(arg = nil, data: arg) super(data: data) end
-        alias :[] :new
-      end
-
-      def initialize(data:)
-        @data = data
-        freeze
-      end
-
-      attr_reader :data
-
-      def to_h(&block) block ? to_h.to_h(&block) : { data: data } end
-      def ==(other)   self.class === other && to_h  ==  other.to_h  end
-      def eql?(other) self.class === other && to_h.eql?(other.to_h) end
-
-      # following class definition goes beyond the basic Data.define(:data)
-      ##
-
-      def self.validate(...)
-        data = new(...)
-        data.validate
-        data
-      end
+    def send_symbol_data(symbol)
+      put_string("\\" + symbol.to_s)
+    end
 
+    class RawData # :nodoc:
       def send_data(imap, tag)
-        raise NoMethodError, "#{self.class} must implement #{__method__}"
+        imap.__send__(:put_string, @data)
       end
 
       def validate
       end
-    end
 
-    # Represents IMAP +text+ or +quoted+ data, which share the same
-    # validations of decoded #data, and differ only in how they are formatted.
-    #
-    # +data+ may contain any 7-bit ASCII character except +NULL+, +CR+, or +LF+.
-    # Any multibyte +UTF-8+ character is also allowed when the connection
-    # supports UTF8: either +UTF8=ACCEPT+ or +IMAP4rev2+ have been enabled, or
-    # the server supports only +IMAP4rev2+ and not earlier IMAP revisions, or
-    # the server advertises +UTF8=ONLY+.
-    #
-    # NOTE: This does not verify whether the connection supports UTF-8, but that
-    # may change in future versions.
-    #
-    # The string's bytes must be valid ASCII or valid UTF-8.  The string's
-    # reported encoding is ignored, but the string is _not_ transcoded.
-    class ValidNonLiteralData < CommandData
-      def initialize(data:)
-        data = String(data.to_str)
-        unless [Encoding::ASCII, Encoding::UTF_8].include?(data.encoding)
-          data = data.dup.force_encoding(data.ascii_only? ? "ASCII" : "UTF-8")
-        end
-        data = -data
-        super
-        validate
-      end
+      private
 
-      def validate
-        if ![Encoding::ASCII, Encoding::UTF_8].include?(data.encoding)
-          raise DataFormatError, "must use ASCII or UTF-8 encoding"
-        elsif !data.valid_encoding?
-          raise DataFormatError, "invalid UTF-8 must be literal encoded"
-        elsif data.include?("\0")
-          raise DataFormatError, "NULL byte must be binary literal encoded"
-        elsif /[\r\n]/.match?(data)
-          raise DataFormatError, "CR and LF bytes must be literal encoded"
-        end
+      def initialize(data)
+        @data = data
       end
-
-      def ascii_only?; data.ascii_only? end
-
-      def send_data(imap, tag = nil) imap.__send__(:put_string, formatted) end
-    end
-
-    # Represents IMAP +text+ data, which covers everything in the IMAP grammar,
-    # except for +literal+, +literal8+, and the concluding +CRLF+.
-    #
-    # NOTE: The current implementation does not verify that the connection
-    # supports UTF-8.  Future versions may validate this.
-    class RawText < ValidNonLiteralData # :nodoc:
-      # raw: no formatting necessary
-      alias formatted data
     end
 
-    class RawData < CommandData # :nodoc:
-      def initialize(data:)
-        case data
-        when String
-          data = self.class.split(data)
-        when Array
-          unless data.all? { |part| RawText === part || Literal === part }
-            raise TypeError, "expected String or Array[#{RawText} | #{Literal}]"
-          end
-        else
-          raise TypeError, "expected String or Array[#{RawText} | #{Literal}]"
-        end
-        super
-        validate
+    class Atom # :nodoc:
+      def send_data(imap, tag)
+        imap.__send__(:put_string, @data)
       end
 
-      def send_data(imap, tag) data.each do _1.send_data(imap, tag) end end
-
       def validate
-        return unless RawText === data.last
-        text = data.last.data
-        if text.rindex(/\{\d+\+?\}\z/n)
-          raise DataFormatError, "RawData cannot end with literal continuation"
-        end
       end
 
-      # Splits an input +string+ into an array of RawText and Literal/Literal8.
-      #
-      # NOTE: unlike RawData#validate, this does not prevent the final RawText
-      # from ending with a literal prefix.
-      def self.split(data)
-        data = data.b # dups and ensures BINARY encoding
-        parts = []
-        while data.match(/(~)?\{(0|[1-9]\d*)(\+)?\}\r\n/n)
-          text, binary, bytesize, non_sync, data = $`, !!$1, $2, !!$3, $'
-          bytesize = Integer bytesize, 10
-          parts << RawText[text] unless text.empty?
-          parts << extract_literal(data,
-                                   binary: binary,
-                                   bytesize: bytesize,
-                                   non_sync: non_sync)
-          data[0, bytesize] = ""
-        end
-        parts << RawText[data] unless data.empty?
-        parts
-      end
+      private
 
-      def self.extract_literal(data, binary:, bytesize:, non_sync:)
-        if data.bytesize < bytesize
-          raise DataFormatError, "Too few bytes in string for literal, " \
-            "expected: %s, remaining: %s" % [bytesize, data.bytesize]
-        end
-        literal = data.byteslice(0, bytesize)
-        (binary ? Literal8 : Literal).new(data: literal, non_sync: non_sync)
+      def initialize(data)
+        @data = data
       end
-      private_class_method :extract_literal
     end
 
-    class Atom < CommandData # :nodoc:
-      def initialize(**)
-        super
-        validate
+    class QuotedString # :nodoc:
+      def send_data(imap, tag)
+        imap.__send__(:send_quoted_string, @data)
       end
 
       def validate
-        data.to_s.ascii_only? \
-          or raise DataFormatError, "#{self.class} must be ASCII only"
-        data.match?(ResponseParser::Patterns::ATOM_SPECIALS) \
-          and raise DataFormatError, "#{self.class} must not contain atom-specials"
-        data.empty? \
-          and raise DataFormatError, "#{self.class} must not be empty"
       end
 
-      def send_data(imap, tag)
-        imap.__send__(:put_string, data.to_s)
-      end
-    end
+      private
 
-    class Flag < Atom # :nodoc:
-      def send_data(imap, tag)
-        imap.__send__(:put_string, "\\#{data}")
+      def initialize(data)
+        @data = data
       end
     end
 
-    # Represents a IMAP +quoted+ string, which can encode any valid ASCII or
-    # UTF-8 string, unless it contains any +CR+, +LF+, or +NULL+ bytes.
-    #
-    # NOTE: The current implementation does not verify that the connection
-    # supports UTF-8.  Future versions may validate this.
-    class QuotedString < ValidNonLiteralData # :nodoc:
-      def formatted; %("#{data.gsub(/["\\]/, "\\\\\\&")}") end
-    end
-
     class Literal # :nodoc:
-      class << self
-        def new(_data = nil, _non_sync = nil, data: _data, non_sync: _non_sync)
-          super(data: data, non_sync: non_sync)
-        end
-        alias :[] :new
-      end
-
-      attr_reader :data, :non_sync
-
-      def to_h(&block) block ? to_h.to_h(&block) : { data: data, non_sync: non_sync } end
-      def ==(other)   self.class === other && to_h  ==  other.to_h  end
-      def eql?(other) self.class === other && to_h.eql?(other.to_h) end
-
-      def initialize(data:, non_sync: nil)
-        data = -String(data.to_str).b or
-          raise DataFormatError, "#{self.class} expects string input"
-        @data, @non_sync = data, non_sync
-        validate
-        freeze
-      end
-
-      def self.validate(...)
-        data = new(...)
-        data.validate
-        data
+      def send_data(imap, tag)
+        imap.__send__(:send_literal, @data, tag)
       end
 
-      def bytesize; data.bytesize end
-
       def validate
-        if data.include?("\0")
-          raise DataFormatError, "NULL byte not allowed in #{self.class}.  " \
-            "Use #{Literal8} or a null-safe encoding."
-        end
       end
 
-      def send_data(imap, tag)
-        imap.__send__(:send_literal, data, tag, non_sync: non_sync)
-      end
-    end
-
-    class Literal8 < Literal # :nodoc:
-      def validate; nil end # all bytes are okay
+      private
 
-      def send_data(imap, tag)
-        imap.__send__(:send_binary_literal, data, tag, non_sync: non_sync)
+      def initialize(data)
+        @data = data
       end
     end
 
+    # *DEPRECATED*.  Replaced by SequenceSet.
     class MessageSet # :nodoc:
       def send_data(imap, tag)
         imap.__send__(:put_string, format_internal(@data))
@@ -392,6 +193,16 @@ module Net
 
       def initialize(data)
         @data = data
+        warn("DEPRECATED: #{MessageSet} should be replaced with #{SequenceSet}.",
+             uplevel: 1, category: :deprecated)
+        begin
+          # to ensure the input works with SequenceSet, too
+          SequenceSet.new(data)
+        rescue
+          warn "MessageSet input is incompatible with SequenceSet: [%s] %s" % [
+            $!.class, $!.message
+          ]
+        end
       end
 
       def format_internal(data)

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

@@ -18,8 +18,6 @@ module Net
             super(attr)
             AttrTypeCoercion.attr_accessor(attr, type: type)
           end
-
-          module_function def Integer?; NilOrInteger end
         end
         private_constant :Macros
 
@@ -28,33 +26,34 @@ module Net
         end
         private_class_method :included
 
-        # Used in v0.5.8+ for Ractor sharability.
-        def self.safe(...) nil.instance_eval(...).freeze end
-        private_class_method :safe
-
-        Types = Hash.new do |h, type|
-          type.nil? || Proc === type or raise TypeError, "type not nil or Proc"
-          safe{type}
+        def self.attr_accessor(attr, type: nil)
+          return unless type
+          if    :boolean == type then boolean attr
+          elsif Integer  == type then integer attr
+          elsif Array   === type then enum    attr, type
+          else raise ArgumentError, "unknown type coercion %p" % [type]
+          end
         end
-        Types[:boolean] = Boolean = safe{-> {!!_1}}
-        Types[Integer]  = safe{->{Integer(_1)}}
 
-        def self.attr_accessor(attr, type: nil)
-          type = Types[type] or return
-          define_method :"#{attr}=" do |val| super type[val] end
-          define_method :"#{attr}?" do send attr end if type == Boolean
+        def self.boolean(attr)
+          define_method :"#{attr}=" do |val| super !!val end
+          define_method :"#{attr}?" do send attr end
         end
 
-        NilOrInteger = safe{->val { Integer val unless val.nil? }}
+        def self.integer(attr)
+          define_method :"#{attr}=" do |val| super Integer val end
+        end
 
-        Enum = ->(*enum) {
-          enum     = safe{enum}
+        def self.enum(attr, enum)
+          enum = enum.dup.freeze
           expected = -"one of #{enum.map(&:inspect).join(", ")}"
-          safe{->val {
-            return val if enum.include?(val)
-            raise ArgumentError, "expected %s, got %p" % [expected, val]
-          }}
-        }
+          define_method :"#{attr}=" do |val|
+            unless enum.include?(val)
+              raise ArgumentError, "expected %s, got %p" % [expected, val]
+            end
+            super val
+          end
+        end
 
       end
     end