net-imap 0.5.15 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0917528437aff2a931fa3b40d476ffbad713cf46655163dc21a6a7a2333f7a49'
-  data.tar.gz: 90b3bf050a4f403408e30eecfaf449069e55bc293297b482e627201821997e0c
+  metadata.gz: 561e6151a9540c8eaa6c12fd16d625061843a053fb0b0c8a2f215eb1a518ef70
+  data.tar.gz: 5be61c15097d2e0007822fc6c4825f59795d6078d6cf9b5cbe6ed4dd2bd1d22e
 SHA512:
-  metadata.gz: c2aaf64941ac0537b7ba6da23ea501dacf438d9eb99581a2ca9906ad150bf5f55a7702141cb573e38306e3eb16000388acb4eb0dbc478727488bc21fa1c61288
-  data.tar.gz: 9d6b93b6c963e4e9c226044e1d8f9c4c5e09365ab57beaf1157128f85cc511402927d50033b0ad154b75914cf7191f2ec111dd240c566907203e4263a24f5e49
+  metadata.gz: f84a8adf89f177e953fe57e390b027232bc4c7325ecb0049221a88db87fccc76a09281aea87c4f48de05bc547db1248b628b9c271134a466aedba953305001cc
+  data.tar.gz: 0b82898fb8581bab9a30c5b3edb96c89d81c4bddf197ade29a25ef166db827983a6c2c25d1eda9989a9f985cfcbec52f4bf484dbc1b57cfde32f432dcd0dfbc3

data/Gemfile

@@ -7,6 +7,7 @@ gemspec
 # gem "digest"  # not included as a workaround for #576
 gem "strscan"
 gem "base64"
+gem "psych", ">= 5.3.0" # 5.2.5 for Data serialization, 5.3.0 for TruffleRuby
 
 gem "irb"
 gem "rake"

data/lib/net/imap/command_data.rb

@@ -3,9 +3,6 @@
 require "date"
 
 require_relative "errors"
-require_relative "data_lite"
-
-# :enddoc:
 
 module Net
   class IMAP < Protocol
@@ -17,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
@@ -50,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
@@ -82,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
@@ -121,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")
-
-    # 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)
@@ -152,13 +115,11 @@ 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
 
-    CommandData = Data.define(:data) do # :nodoc:
-      def self.validate(...)
-        data = new(...)
-        data.validate
-        data
-      end
+    def send_symbol_data(symbol)
+      put_string("\\" + symbol.to_s)
+    end
 
+    CommandData = Data.define(:data) do # :nodoc:
       def send_data(imap, tag)
         raise NoMethodError, "#{self.class} must implement #{__method__}"
       end
@@ -167,176 +128,27 @@ module Net
       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 data.encoding in Encoding::ASCII | Encoding::UTF_8
-          data = data.dup.force_encoding(data.ascii_only? ? "ASCII" : "UTF-8")
-        end
-        data = -data
-        super
-        validate
-      end
-
-      def validate
-        if !(data.encoding in Encoding::ASCII | Encoding::UTF_8)
-          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
-      end
-
-      def ascii_only? = data.ascii_only?
-
-      def send_data(imap, tag = nil) = imap.__send__(:put_string, formatted)
-    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
-        in String then data = self.class.split(data)
-        in Array  if   data.all? { _1 in RawText | Literal }
-        else
-          raise TypeError, "expected String or Array[#{RawText} | #{Literal}]"
-        end
-        super
-        validate
-      end
-
-      def send_data(imap, tag) = data.each do _1.send_data(imap, tag) end
-
-      def validate
-        return unless data.last in RawText(data: text)
-        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:, bytesize:, non_sync:)
-          data[0, bytesize] = ""
-        end
-        parts << RawText[data] unless data.empty?
-        parts
-      end
-
-      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:)
-      end
-      private_class_method :extract_literal
-    end
-
-    class Atom < CommandData # :nodoc:
-      def initialize(**)
-        super
-        validate
-      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)
+        imap.__send__(:put_string, data)
       end
     end
 
-    class Flag < Atom # :nodoc:
+    class Atom < CommandData # :nodoc:
       def send_data(imap, tag)
-        imap.__send__(:put_string, "\\#{data}")
+        imap.__send__(:put_string, 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
-
-    class Literal < Data.define(:data, :non_sync) # :nodoc:
-      def self.validate(...)
-        data = new(...)
-        data.validate
-        data
-      end
-
-      def initialize(data:, non_sync: nil)
-        data = -String(data.to_str).b or
-          raise DataFormatError, "#{self.class} expects string input"
-        super
-        validate
-      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
-
+    class QuotedString < CommandData # :nodoc:
       def send_data(imap, tag)
-        imap.__send__(:send_literal, data, tag, non_sync:)
+        imap.__send__(:send_quoted_string, data)
       end
     end
 
-    class Literal8 < Literal # :nodoc:
-      def validate; nil end # all bytes are okay
-
+    class Literal < CommandData # :nodoc:
       def send_data(imap, tag)
-        imap.__send__(:send_binary_literal, data, tag, non_sync:)
+        imap.__send__(:send_literal, data, tag)
       end
     end
 
@@ -372,73 +184,6 @@ module Net
       end
     end
 
-    # *DEPRECATED*.  Replaced by SequenceSet.
-    class MessageSet < CommandData # :nodoc:
-      def send_data(imap, tag)
-        imap.__send__(:put_string, format_internal(data))
-      end
-
-      def validate
-        validate_internal(data)
-      end
-
-      private
-
-      def initialize(data:)
-        super
-        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)
-        case data
-        when "*"
-          return data
-        when Integer
-          if data == -1
-            return "*"
-          else
-            return data.to_s
-          end
-        when Range
-          return format_internal(data.first) +
-            ":" + format_internal(data.last)
-        when Array
-          return data.collect {|i| format_internal(i)}.join(",")
-        when ThreadMember
-          return data.seqno.to_s +
-            ":" + data.children.collect {|i| format_internal(i).join(",")}
-        end
-      end
-
-      def validate_internal(data)
-        case data
-        when "*"
-        when Integer
-          NumValidator.ensure_nz_number(data)
-        when Range
-        when Array
-          data.each do |i|
-            validate_internal(i)
-          end
-        when ThreadMember
-          data.children.each do |i|
-            validate_internal(i)
-          end
-        else
-          raise DataFormatError, data.inspect
-        end
-      end
-    end
-
     class ClientID < CommandData # :nodoc:
 
       def send_data(imap, tag)

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

@@ -54,9 +54,22 @@ module Net
         # Creates a new config, which inherits from +self+.
         def new(**attrs) self.class.new(self, **attrs) end
 
+        # :call-seq:
+        #   inherited?(attr)   -> true or false
+        #   inherited?(*attrs) -> true or false
+        #   inherited?         -> true or false
+        #
         # Returns +true+ if +attr+ is inherited from #parent and not overridden
         # by this config.
-        def inherited?(attr) data[attr] == INHERITED end
+        #
+        # When multiple +attrs+ are given, returns +true+ if *all* of them are
+        # inherited, or +false+ if any of them are overriden.  When no +attrs+
+        # are given, returns +true+ if *all* attributes are inherited, or
+        # +false+ if any attribute is overriden.
+        def inherited?(*attrs)
+          attrs = data.members if attrs.empty?
+          attrs.all? { data[_1] == INHERITED }
+        end
 
         # :call-seq:
         #   reset -> self

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

@@ -24,7 +24,7 @@ module Net
         VERSIONS = ((0.0r..FUTURE_VERSION) % 0.1r).to_a.freeze
 
         # See Config.version_defaults.
-        singleton_class.attr_reader :version_defaults
+        singleton_class.attr_accessor :version_defaults
 
         @version_defaults = Hash.new {|h, k|
           # NOTE: String responds to both so the order is significant.