net-imap 0.4.24 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9419630b908b12c7f89846682dae953e50376d89ebb3b7391b3426bb34480991
-  data.tar.gz: 4558a77d38a4def28af960c201ca9359fcc828d5a316f76f95cf3c0e575702b6
+  metadata.gz: 2c89d97e842bce303df112c3fbc0f048f20a2ff1dbf3b85bb2314ea0d2e207c5
+  data.tar.gz: 11d6ec196e1e768f61a17b0ce7f385a11eb03e3e92af8ab327ba9a90699ee940
 SHA512:
-  metadata.gz: 5f4baf570c8ed5732493ba801121ae092177fca3ab5f9162ef66f0db2a23e91c09fe740d8ddba52977e65737906a6735a8405bb94e923111970621e79b813141
-  data.tar.gz: 624e1b8a76630bffa007391b303eab5729b20665d9a5242f58749e0127340ddd1a842eb94ca46da085ccfa91cc093367348586cde705b51fe3eff25882f8f096
+  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

@@ -25,7 +25,6 @@ module Net
         end
       when Time, Date, DateTime
       when Symbol
-        Flag.validate(data)
       else
         data.validate
       end
@@ -46,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
@@ -78,23 +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.
-    #   TODO: raise or warn when capabilities don't allow non_sync.
-    # * `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)
+    def send_literal(str, tag = nil)
       synchronize do
-        prefix = "~" if binary
-        plus = "+" if non_sync
-        put_string("#{prefix}{#{str.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
@@ -130,148 +115,37 @@ 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_data(imap, tag)
-        raise NoMethodError, "#{self.class} must implement #{__method__}"
-      end
-
-      def validate
-      end
+    def send_symbol_data(symbol)
+      put_string("\\" + symbol.to_s)
     end
 
-    # Represents IMAP +text+ data, which may contain any 7-bit ASCII character,
-    # except for +NULL+, +CR+, or +LF+.  +text+ is extended to allow any
-    # multibyte +UTF-8+ character when either +UTF8=ACCEPT+ or +IMAP4rev2+ have
-    # been enabled, or when the server supports only +IMAP4rev2+ and not earlier
-    # IMAP revisions, or when the server advertises +UTF8=ONLY+.
-    #
-    # NOTE: The current implementation does not validate whether the connection
-    # currently supports UTF-8.  Future versions may change.
-    #
-    # 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 RawText < CommandData # :nodoc:
-      def initialize(data:)
-        data = String(data.to_str)
-        data = if [Encoding::ASCII, Encoding::UTF_8].include?(data.encoding)
-          -data
-        elsif data.ascii_only?
-          -(data.dup.force_encoding("ASCII"))
-        else
-          -(data.dup.force_encoding("UTF-8"))
-        end
-        super
-        validate
-      end
-
-      def validate
-        if data.include?("\0")
-          raise DataFormatError, "NULL byte must be binary literal encoded"
-        elsif !data.valid_encoding?
-          raise DataFormatError, "invalid UTF-8 must be literal encoded"
-        elsif /[\r\n]/.match?(data)
-          raise DataFormatError, "CR and LF bytes must be literal encoded"
-        end
-      end
-
-      def ascii_only?; data.ascii_only? end
-
-      def send_data(imap, tag) imap.__send__(:put_string, data) end
-    end
-
-    class RawData < CommandData # :nodoc:
-      def initialize(data:)
-        data = split_parts(data)
-        super
-        validate
+    class RawData # :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(/~?\{[1-9]\d*\+?\}\z/n)
-          raise DataFormatError, "RawData cannot end with literal continuation"
-        end
       end
 
       private
 
-      def split_parts(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
-
-      def 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
     end
 
-    class Atom < CommandData # :nodoc:
-      def initialize(**)
-        super
-        validate
+    class Atom # :nodoc:
+      def send_data(imap, tag)
+        imap.__send__(:put_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"
       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
 
@@ -291,55 +165,21 @@ module Net
     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))
@@ -353,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