net-imap 0.4.24 → 0.5.14

data/lib/net/imap/config.rb

@@ -3,6 +3,7 @@
 require_relative "config/attr_accessors"
 require_relative "config/attr_inheritance"
 require_relative "config/attr_type_coercion"
+require_relative "config/attr_version_defaults"
 
 module Net
   class IMAP
@@ -75,7 +76,7 @@ module Net
     #
     #   client = Net::IMAP.new(hostname, config: :future)
     #   client.config.sasl_ir                  # => true
-    #   client.config.responses_without_block  # => :raise
+    #   client.config.responses_without_block  # => :frozen_dup
     #
     # The versioned default configs inherit certain specific config options from
     # Config.global, for example #debug:
@@ -109,9 +110,11 @@ module Net
     # [+:future+]
     #   The _planned_ eventual config for some future +x.y+ version.
     #
-    # For example, to raise exceptions for all current deprecations:
+    # For example, to disable all currently deprecated behavior:
     #   client = Net::IMAP.new(hostname, config: :future)
-    #   client.responses  # raises an ArgumentError
+    #   client.config.response_without_args     # => :frozen_dup
+    #   client.responses.frozen?                # => true
+    #   client.responses.values.all?(&:frozen?) # => true
     #
     # == Thread Safety
     #
@@ -139,15 +142,7 @@ module Net
       #     Net::IMAP::Config[0.5]       == Net::IMAP::Config[0.5r]     # => true
       #     Net::IMAP::Config["current"] == Net::IMAP::Config[:current] # => true
       #     Net::IMAP::Config["0.5.6"]   == Net::IMAP::Config[0.5r]     # => true
-      def self.version_defaults; @version_defaults end
-      @version_defaults = Hash.new {|h, k|
-        # NOTE: String responds to both so the order is significant.
-        # And ignore non-numeric conversion to zero, because: "wat!?".to_r == 0
-        (h.fetch(k.to_r, nil) || h.fetch(k.to_f, nil) if k.is_a?(Numeric)) ||
-          (h.fetch(k.to_sym, nil) if k.respond_to?(:to_sym)) ||
-          (h.fetch(k.to_r,   nil) if k.respond_to?(:to_r) && k.to_r != 0r) ||
-          (h.fetch(k.to_f,   nil) if k.respond_to?(:to_f) && k.to_f != 0.0)
-      }
+      def self.version_defaults; AttrVersionDefaults.version_defaults end
 
       # :call-seq:
       #  Net::IMAP::Config[number] -> versioned config
@@ -187,6 +182,7 @@ module Net
       include AttrAccessors
       include AttrInheritance
       include AttrTypeCoercion
+      extend  AttrVersionDefaults
 
       # The debug mode (boolean).  The default value is +false+.
       #
@@ -198,7 +194,7 @@ module Net
       #
       # *NOTE:* Versioned default configs inherit #debug from Config.global, and
       # #load_defaults will not override #debug.
-      attr_accessor :debug, type: :boolean
+      attr_accessor :debug, type: :boolean, default: false
 
       # method: debug?
       # :call-seq: debug? -> boolean
@@ -216,7 +212,7 @@ module Net
       # See Net::IMAP.new and Net::IMAP#starttls.
       #
       # The default value is +30+ seconds.
-      attr_accessor :open_timeout, type: Integer
+      attr_accessor :open_timeout, type: Integer, default: 30
 
       # Seconds to wait until an IDLE response is received, after
       # the client asks to leave the IDLE state.
@@ -224,7 +220,7 @@ module Net
       # See Net::IMAP#idle and Net::IMAP#idle_done.
       #
       # The default value is +5+ seconds.
-      attr_accessor :idle_response_timeout, type: Integer
+      attr_accessor :idle_response_timeout, type: Integer, default: 5
 
       # Whether to use the +SASL-IR+ extension when the server and \SASL
       # mechanism both support it.  Can be overridden by the +sasl_ir+ keyword
@@ -240,16 +236,46 @@ module Net
       #
       # [+true+ <em>(default since +v0.4+)</em>]
       #   Use +SASL-IR+ when it is supported by the server and the mechanism.
-      attr_accessor :sasl_ir, type: :boolean
+      attr_accessor :sasl_ir, type: :boolean, defaults: {
+        0.0r => false,
+        0.4r => true,
+      }
+
+      # Controls the behavior of Net::IMAP#login when the +LOGINDISABLED+
+      # capability is present.  When enforced, Net::IMAP will raise a
+      # LoginDisabledError when that capability is present.
+      #
+      # <em>(Support for +LOGINDISABLED+ was added in +v0.5.0+.)</em>
+      #
+      # ==== Valid options
+      #
+      # [+false+ <em>(original behavior, before support was added)</em>]
+      #   Send the +LOGIN+ command without checking for +LOGINDISABLED+.
+      #
+      # [+:when_capabilities_cached+]
+      #   Enforce the requirement when Net::IMAP#capabilities_cached? is true,
+      #   but do not send a +CAPABILITY+ command to discover the capabilities.
+      #
+      # [+true+ <em>(default since +v0.5+)</em>]
+      #   Only send the +LOGIN+ command if the +LOGINDISABLED+ capability is not
+      #   present.  When capabilities are unknown, Net::IMAP will automatically
+      #   send a +CAPABILITY+ command first before sending +LOGIN+.
+      #
+      attr_accessor :enforce_logindisabled, type: Enum[
+        false, :when_capabilities_cached, true
+      ], defaults: {
+        0.0r => false,
+        0.5r => true,
+      }
 
       # The maximum allowed server response size.  When +nil+, there is no limit
       # on response size.
       #
       # The default value (512 MiB, since +v0.5.7+) is <em>very high</em> and
-      # unlikely to be reached.  To use a lower limit, fetch message bodies in
-      # chunks rather than all at once.  A _much_ lower value should be used
-      # with untrusted servers (for example, when connecting to a user-provided
-      # hostname).
+      # unlikely to be reached.  A _much_ lower value should be used with
+      # untrusted servers (for example, when connecting to a user-provided
+      # hostname).  When using a lower limit, message bodies should be fetched
+      # in chunks rather than all at once.
       #
       # <em>Please Note:</em> this only limits the size per response.  It does
       # not prevent a flood of individual responses and it does not limit how
@@ -260,7 +286,6 @@ module Net
       # response: max_response_size minus the bytes that have already been read.
       # When the limit is reached, or reading a +literal+ _would_ go over the
       # limit, ResponseTooLargeError is raised and the connection is closed.
-      # See also #socket_read_limit.
       #
       # Note that changes will not take effect immediately, because the receiver
       # thread may already be waiting for the next response using the previous
@@ -275,7 +300,10 @@ module Net
       #
       # * original: +nil+ <em>(no limit)</em>
       # * +0.5+: 512 MiB
-      attr_accessor :max_response_size, type: Integer?
+      attr_accessor :max_response_size, type: Integer?, defaults: {
+        0.0r => nil,
+        0.5r => 512 << 20, # 512 MiB
+      }
 
       # Controls the behavior of Net::IMAP#responses when called without any
       # arguments (+type+ or +block+).
@@ -305,7 +333,11 @@ module Net
       # Note: #responses_without_args is an alias for #responses_without_block.
       attr_accessor :responses_without_block, type: Enum[
         :silence_deprecation_warning, :warn, :frozen_dup, :raise,
-      ]
+      ], defaults: {
+        0.0r => :silence_deprecation_warning,
+        0.5r => :warn,
+        0.6r => :frozen_dup,
+      }
 
       alias responses_without_args  responses_without_block  # :nodoc:
       alias responses_without_args= responses_without_block= # :nodoc:
@@ -350,7 +382,11 @@ module Net
       #    ResponseParser _only_ uses AppendUIDData and CopyUIDData.
       attr_accessor :parser_use_deprecated_uidplus_data, type: Enum[
         true, :up_to_max_size, false
-      ]
+      ], defaults: {
+        0.0r => true,
+        0.5r => :up_to_max_size,
+        0.6r => false,
+      }
 
       # The maximum +uid-set+ size that ResponseParser will parse into
       # deprecated UIDPlusData.  This limit only applies when
@@ -374,7 +410,13 @@ module Net
       # * +0.5+: <tt>100</tt>
       # * +0.6+: <tt>0</tt>
       #
-      attr_accessor :parser_max_deprecated_uidplus_data_size, type: Integer
+      attr_accessor :parser_max_deprecated_uidplus_data_size, type: Integer,
+        defaults: {
+          0.0r => 10_000,
+          0.4r =>  1_000,
+          0.5r =>    100,
+          0.6r =>      0,
+        }
 
       # Creates a new config object and initialize its attribute with +attrs+.
       #
@@ -449,76 +491,10 @@ module Net
         to_h.reject {|k,v| DEFAULT_TO_INHERIT.include?(k) }
       end
 
-      @default = new(
-        debug: false,
-        open_timeout: 30,
-        idle_response_timeout: 5,
-        sasl_ir: true,
-        max_response_size: nil,
-        responses_without_block: :silence_deprecation_warning,
-        parser_use_deprecated_uidplus_data: true,
-        parser_max_deprecated_uidplus_data_size: 1000,
-      ).freeze
-
-      @global = default.new
-
-      version_defaults[:default] = Config[default.send(:defaults_hash)]
-
-      version_defaults[0r] = Config[:default].dup.update(
-        sasl_ir: false,
-        max_response_size: nil,
-        parser_use_deprecated_uidplus_data: true,
-        parser_max_deprecated_uidplus_data_size: 10_000,
-      ).freeze
-      version_defaults[0.0r] = Config[0r]
-      version_defaults[0.1r] = Config[0r]
-      version_defaults[0.2r] = Config[0r]
-      version_defaults[0.3r] = Config[0r]
-
-      version_defaults[0.4r] = Config[0.3r].dup.update(
-        sasl_ir: true,
-        parser_max_deprecated_uidplus_data_size: 1000,
-      ).freeze
-
-      version_defaults[0.5r] = Config[0.4r].dup.update(
-        max_response_size: 512 << 20, # 512 MiB
-        responses_without_block: :warn,
-        parser_use_deprecated_uidplus_data: :up_to_max_size,
-        parser_max_deprecated_uidplus_data_size: 100,
-      ).freeze
-
-      version_defaults[0.6r] = Config[0.5r].dup.update(
-        responses_without_block: :frozen_dup,
-        parser_use_deprecated_uidplus_data: false,
-        parser_max_deprecated_uidplus_data_size: 0,
-      ).freeze
-
-      version_defaults[0.7r] = Config[0.6r].dup.update(
-      ).freeze
-
-      # Safe conversions one way only:
-      #   0.6r.to_f == 0.6  # => true
-      #   0.6 .to_r == 0.6r # => false
-      version_defaults.to_a.each do |k, v|
-        next unless k.is_a? Rational
-        version_defaults[k.to_f] = v
-      end
-
-      current = VERSION.to_r
-      version_defaults[:original] = Config[0]
-      version_defaults[:current]  = Config[current]
-      version_defaults[:next]     = Config[current + 0.1r]
-
-      version_defaults[:future]   = Config[0.7r]
+      @default = AttrVersionDefaults.compile_default!
+      @global  = default.new
+      AttrVersionDefaults.compile_version_defaults!
 
-      version_defaults.freeze
-
-      if ($VERBOSE || $DEBUG) && self[:current].to_h != self[:default].to_h
-        warn "Misconfigured Net::IMAP::Config[:current] => %p,\n" \
-             " not equal to Net::IMAP::Config[:default] => %p" % [
-                self[:current].to_h, self[:default].to_h
-              ]
-      end
     end
   end
 end

data/lib/net/imap/connection_state.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Net
+  class IMAP
+    class ConnectionState < Net::IMAP::Data # :nodoc:
+      def self.define(symbol, *attrs)
+        symbol => Symbol
+        state = super(*attrs)
+        state.const_set :NAME, symbol
+        state
+      end
+
+      def symbol; self.class::NAME      end
+      def name;   self.class::NAME.name end
+      alias to_sym symbol
+
+      def deconstruct; [symbol, *super] end
+
+      def deconstruct_keys(names)
+        hash = super
+        hash[:symbol] = symbol if names.nil? || names.include?(:symbol)
+        hash[:name]   = name   if names.nil? || names.include?(:name)
+        hash
+      end
+
+      def to_h(&block)
+        hash = deconstruct_keys(nil)
+        block ? hash.to_h(&block) : hash
+      end
+
+      def not_authenticated?; to_sym == :not_authenticated end
+      def authenticated?;     to_sym == :authenticated     end
+      def selected?;          to_sym == :selected          end
+      def logout?;            to_sym == :logout            end
+
+      NotAuthenticated = define(:not_authenticated)
+      Authenticated    = define(:authenticated)
+      Selected         = define(:selected)
+      Logout           = define(:logout)
+
+      class << self
+        undef :define
+      end
+      freeze
+    end
+
+  end
+end

data/lib/net/imap/data_encoding.rb

@@ -186,7 +186,7 @@ module Net
 
       # Ensure argument is 'number' or raise DataFormatError
       def ensure_number(num)
-        return if valid_number?(num)
+        return num if valid_number?(num)
 
         msg = "number must be unsigned 32-bit integer: #{num}"
         raise DataFormatError, msg
@@ -194,7 +194,7 @@ module Net
 
       # Ensure argument is 'nz_number' or raise DataFormatError
       def ensure_nz_number(num)
-        return if valid_nz_number?(num)
+        return num if valid_nz_number?(num)
 
         msg = "nz_number must be non-zero unsigned 32-bit integer: #{num}"
         raise DataFormatError, msg
@@ -202,7 +202,7 @@ module Net
 
       # Ensure argument is 'mod_sequence_value' or raise DataFormatError
       def ensure_mod_sequence_value(num)
-        return if valid_mod_sequence_value?(num)
+        return num if valid_mod_sequence_value?(num)
 
         msg = "mod_sequence_value must be unsigned 64-bit integer: #{num}"
         raise DataFormatError, msg

data/lib/net/imap/data_lite.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+# Some of the code in this file was copied from the polyfill-data gem.
+#
+# MIT License
+#
+# Copyright (c) 2023 Jim Gay, Joel Drapper, Nicholas Evans
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+module Net
+  class IMAP
+    data_or_object = RUBY_VERSION >= "3.2.0" ? ::Data : Object
+    class DataLite < data_or_object
+      def encode_with(coder) coder.map = to_h.transform_keys(&:to_s)        end
+      def init_with(coder) initialize(**coder.map.transform_keys(&:to_sym)) end
+    end
+
+    Data = DataLite
+  end
+end
+
+# :nocov:
+# Need to skip test coverage for the rest, because it isn't loaded by ruby 3.2+.
+return if RUBY_VERSION >= "3.2.0"
+
+module Net
+  class IMAP
+    # DataLite is a temporary substitute for ruby 3.2's +Data+ class.  DataLite
+    # is aliased as Net::IMAP::Data, so that code using it won't need to be
+    # updated when it is removed.
+    #
+    # See {ruby 3.2's documentation for Data}[https://docs.ruby-lang.org/en/3.2/Data.html].
+    #
+    # [When running ruby 3.1]
+    #    This class reimplements the API for ruby 3.2's +Data+, and should be
+    #    compatible for nearly all use-cases.  This reimplementation <em>will be
+    #    removed</em> in +net-imap+ 0.6, when support for ruby 3.1 is dropped.
+    #
+    #    _NOTE:_ +net-imap+ no longer supports ruby versions prior to 3.1.
+    # [When running ruby >= 3.2]
+    #    This class inherits from +Data+ and _only_ defines the methods needed
+    #    for YAML serialization.  This will be dropped when +psych+ adds support
+    #    for +Data+.
+    #
+    # Some of the code in this class was copied or adapted from the
+    # {polyfill-data gem}[https://rubygems.org/gems/polyfill-data], by Jim Gay
+    # and Joel Drapper, under the MIT license terms.
+    class DataLite
+      singleton_class.undef_method :new
+
+      TYPE_ERROR    = "%p is not a symbol nor a string"
+      ATTRSET_ERROR = "invalid data member: %p"
+      DUP_ERROR     = "duplicate member: %p"
+      ARITY_ERROR   = "wrong number of arguments (given %d, expected %s)"
+      private_constant :TYPE_ERROR, :ATTRSET_ERROR, :DUP_ERROR, :ARITY_ERROR
+
+      # Defines a new Data class.
+      #
+      # _NOTE:_ Unlike ruby 3.2's +Data.define+, DataLite.define only supports
+      # member names which are valid local variable names.  Member names can't
+      # be keywords (e.g: +next+ or +class+) or start with capital letters, "@",
+      # etc.
+      def self.define(*args, &block)
+        members = args.each_with_object({}) do |arg, members|
+          arg = arg.to_str unless arg in Symbol | String if arg.respond_to?(:to_str)
+          arg = arg.to_sym if     arg in String
+          arg in Symbol     or  raise TypeError,     TYPE_ERROR    % [arg]
+          arg in %r{=}      and raise ArgumentError, ATTRSET_ERROR % [arg]
+          members.key?(arg) and raise ArgumentError, DUP_ERROR     % [arg]
+          members[arg] = true
+        end
+        members = members.keys.freeze
+
+        klass = ::Class.new(self)
+
+        klass.singleton_class.undef_method :define
+        klass.define_singleton_method(:members) { members }
+
+        def klass.new(*args, **kwargs, &block)
+          if kwargs.size.positive?
+            if args.size.positive?
+              raise ArgumentError, ARITY_ERROR % [args.size, 0]
+            end
+          elsif members.size < args.size
+            expected = members.size.zero? ? 0 : 0..members.size
+            raise ArgumentError, ARITY_ERROR % [args.size, expected]
+          else
+            kwargs = Hash[members.take(args.size).zip(args)]
+          end
+          allocate.tap do |instance|
+            instance.__send__(:initialize, **kwargs, &block)
+          end.freeze
+        end
+
+        klass.singleton_class.alias_method :[], :new
+        klass.attr_reader(*members)
+
+        # Dynamically defined initializer methods are in an included module,
+        # rather than directly on DataLite (like in ruby 3.2+):
+        # * simpler to handle required kwarg ArgumentErrors
+        # * easier to ensure consistent ivar assignment order (object shape)
+        # * faster than instance_variable_set
+        klass.include(Module.new do
+          if members.any?
+            kwargs = members.map{"#{_1.name}:"}.join(", ")
+            params = members.map(&:name).join(", ")
+            ivars  = members.map{"@#{_1.name}"}.join(", ")
+            attrs  = members.map{"attrs[:#{_1.name}]"}.join(", ")
+            module_eval <<~RUBY, __FILE__, __LINE__ + 1
+              protected
+              def initialize(#{kwargs}) #{ivars} = #{params}; freeze end
+              def marshal_load(attrs)   #{ivars} = #{attrs};  freeze end
+            RUBY
+          end
+        end)
+
+        klass.module_eval do _1.module_eval(&block) end if block_given?
+
+        klass
+      end
+
+      ##
+      # singleton-method: new
+      # call-seq:
+      #   new(*args) -> instance
+      #   new(**kwargs) -> instance
+      #
+      # Constuctor for classes defined with ::define.
+      #
+      # Aliased as ::[].
+
+      ##
+      # singleton-method: []
+      # call-seq:
+      #   ::[](*args) -> instance
+      #   ::[](**kwargs) -> instance
+      #
+      # Constuctor for classes defined with ::define.
+      #
+      # Alias for ::new
+
+      ##
+      def members;     self.class.members                              end
+      def to_h(&block) block ? __to_h__.to_h(&block) : __to_h__        end
+      def hash;        [self.class, __to_h__].hash                     end
+      def ==(other)    self.class == other.class && to_h == other.to_h end
+      def eql?(other)  self.class == other.class && hash == other.hash end
+      def deconstruct; __to_h__.values                                 end
+
+      def deconstruct_keys(keys)
+        raise TypeError unless keys.is_a?(Array) || keys.nil?
+        return __to_h__ if keys&.first.nil?
+        __to_h__.slice(*keys)
+      end
+
+      def with(**kwargs)
+        return self if kwargs.empty?
+        self.class.new(**__to_h__.merge(kwargs))
+      end
+
+      def inspect
+        __inspect_guard__(self) do |seen|
+          return "#<data #{self.class}:...>" if seen
+          attrs = __to_h__.map {|kv| "%s=%p" % kv }.join(", ")
+          display = ["data", self.class.name, attrs].compact.join(" ")
+          "#<#{display}>"
+        end
+      end
+      alias_method :to_s, :inspect
+
+      private
+
+      def initialize_copy(source) super.freeze end
+      def marshal_dump; __to_h__ end
+
+      def __to_h__; Hash[members.map {|m| [m, send(m)] }] end
+
+      # Yields +true+ if +obj+ has been seen already, +false+ if it hasn't.
+      # Marks +obj+ as seen inside the block, so circuler references don't
+      # recursively trigger a SystemStackError (stack level too deep).
+      #
+      # Making circular references inside a Data object _should_ be very
+      # uncommon, but we'll support them for the sake of completeness.
+      def __inspect_guard__(obj)
+        preexisting = Thread.current[:__net_imap_data__inspect__]
+        Thread.current[:__net_imap_data__inspect__] ||= {}.compare_by_identity
+        inspect_guard = Thread.current[:__net_imap_data__inspect__]
+        if inspect_guard.include?(obj)
+          yield true
+        else
+          begin
+            inspect_guard[obj] = true
+            yield false
+          ensure
+            inspect_guard.delete(obj)
+          end
+        end
+      ensure
+        unless preexisting.equal?(inspect_guard)
+          Thread.current[:__net_imap_data__inspect__] = preexisting
+        end
+      end
+
+    end
+
+  end
+end
+# :nocov:

data/lib/net/imap/deprecated_client_options.rb

@@ -83,10 +83,12 @@ module Net
         elsif deprecated.empty?
           super host, port: port_or_options
         elsif deprecated.shift
-          warn "DEPRECATED: Call Net::IMAP.new with keyword options", uplevel: 1
+          warn("DEPRECATED: Call Net::IMAP.new with keyword options",
+               uplevel: 1, category: :deprecated)
           super host, port: port_or_options, ssl: create_ssl_params(*deprecated)
         else
-          warn "DEPRECATED: Call Net::IMAP.new with keyword options", uplevel: 1
+          warn("DEPRECATED: Call Net::IMAP.new with keyword options",
+               uplevel: 1, category: :deprecated)
           super host, port: port_or_options, ssl: false
         end
       end
@@ -113,7 +115,8 @@ module Net
         elsif deprecated.first.respond_to?(:to_hash)
           super(**Hash.try_convert(deprecated.first))
         else
-          warn "DEPRECATED: Call Net::IMAP#starttls with keyword options", uplevel: 1
+          warn("DEPRECATED: Call Net::IMAP#starttls with keyword options",
+               uplevel: 1, category: :deprecated)
           super(**create_ssl_params(*deprecated))
         end
       end

data/lib/net/imap/errors.rb

@@ -7,6 +7,12 @@ module Net
     class Error < StandardError
     end
 
+    class LoginDisabledError < Error
+      def initialize(msg = "Remote server has disabled the LOGIN command", ...)
+        super
+      end
+    end
+
     # Error raised when data is in the incorrect format.
     class DataFormatError < Error
     end