net-imap 0.5.8 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6d2d79f907ce00d056ead396fafe73bbdf84fc54b01e1f2536d6490c001c723
-  data.tar.gz: 6fba3cd04144fedd7b178959451631ea14cff8f248ca963961b3945b636cec4b
+  metadata.gz: 4249dc5d175bd3ae3a3b3b79e0f368e674ec96045510a8b504e829feefb54f3d
+  data.tar.gz: 6adbee15b0303b36ec1c574991d4bdbf518bcd5621c6b668f05df0bc201ba50a
 SHA512:
-  metadata.gz: 80f15f967d4260638d423b802204360e25704cc47c59d110a85f401c1554882521097d5014ecc3e7a0a17f87e8995ae87f553d73a26f3c8abc84744ad5d236ed
-  data.tar.gz: 2790cbc5ee60b3da3648e8bd91df90ecac7c72e0febca11464400460fd5c34db3123d307f39901ea7c313942f2feb11bb3c0f7dbc06b96094b6d1738426b278a
+  metadata.gz: a20c230ac3977d9acc09bc964badc60acbedaca84246d1ce67787c78443cdea350ade6907e58b61a5c9f09bf3b12e5e57cd319ef82a096c3780f97dc7017ed31
+  data.tar.gz: 68ab8b48664998bbf05d5367fea4e5b06e3ba3b2d4e48ba8ae026069060b23f7dafaf7ecf2681fc5aa4ff0f134e55d9399ca51456ff3a7ec718ba829629866b7

data/Gemfile

@@ -4,9 +4,10 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "digest"
+# 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"
@@ -14,10 +15,12 @@ gem "rdoc"
 gem "test-unit"
 gem "test-unit-ruby-core", git: "https://github.com/ruby/test-unit-ruby-core"
 
+gem "benchmark", require: false
 gem "benchmark-driver", require: false
+gem "vernier", require: false, platform: :mri
 
 group :test do
-  gem "simplecov",        require: false
-  gem "simplecov-html",   require: false
-  gem "simplecov-json",   require: false
+  gem "simplecov",        require: false, platforms: %i[mri windows]
+  gem "simplecov-html",   require: false, platforms: %i[mri windows]
+  gem "simplecov-json",   require: false, platforms: %i[mri windows]
 end

data/lib/net/imap/command_data.rb

@@ -3,7 +3,6 @@
 require "date"
 
 require_relative "errors"
-require_relative "data_lite"
 
 module Net
   class IMAP < Protocol
@@ -185,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_accessors.rb

@@ -27,24 +27,23 @@ module Net
 
         def self.attr_accessor(name) # :nodoc: internal API
           name = name.to_sym
+          raise ArgumentError, "already defined #{name}" if attributes.include?(name)
+          attributes << name
           def_delegators :data, name, :"#{name}="
         end
 
-        def self.attributes
-          instance_methods.grep(/=\z/).map { _1.to_s.delete_suffix("=").to_sym }
-        end
-        private_class_method :attributes
+        # An array of Config attribute names
+        singleton_class.attr_reader :attributes
+        @attributes = []
 
         def self.struct # :nodoc: internal API
-          unless defined?(self::Struct)
-            const_set :Struct, Struct.new(*attributes)
-          end
-          self::Struct
+          attributes.freeze
+          Struct.new(*attributes)
         end
 
         def initialize # :notnew:
           super()
-          @data = AttrAccessors.struct.new
+          @data = Config::Struct.new
         end
 
         # Freezes the internal attributes struct, in addition to +self+.

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

@@ -54,9 +54,72 @@ 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.
+        #
+        # Related: #overrides?
+        def inherited?(*attrs)
+          attrs = data.members if attrs.empty?
+          attrs.all? { data[_1] == INHERITED }
+        end
+
+        # :call-seq:
+        #   inherits_defaults?(*attrs) -> true | Rational | nil | false
+        #
+        # Returns whether all +attrs+ are inherited from a default config.
+        # When no +attrs+ are given, returns whether *all* attributes are
+        # inherited from a default config.
+        #
+        # Returns +true+ when all attributes inherit from Config.default, the
+        # version number (as a Rational) when all attributes inherit from a
+        # versioned default (see Config@Versioned+defaults), +nil+ if any
+        # attributes inherit from Config.global overrides (but not from
+        # non-global ancestors), or +false+ when any attributes have been
+        # overridden by +self+ or an ancestor (besides global or default
+        # configs),
+        #
+        # Related: #overrides?
+        def inherits_defaults?(*attrs)
+          if equal?(Config.default)
+            true
+          elsif equal?(Config.global)
+            true if inherited?(*attrs)
+          elsif (v = AttrVersionDefaults::VERSIONS.find { equal? Config[_1] })
+            attrs  = DEFAULT_TO_INHERIT if attrs.empty?
+            attrs &= DEFAULT_TO_INHERIT
+            (attrs.empty? || parent.inherits_defaults?(*attrs)) && v
+          else
+            inherited?(*attrs) && parent.inherits_defaults?(*attrs)
+          end
+        end
+
+        # :call-seq:
+        #   overrides?(attr)   -> true or false
+        #   overrides?(*attrs) -> true or false
+        #   overrides?         -> true or false
+        #
+        # Returns +true+ if +attr+ is defined on this config and not inherited
+        # from #parent.
+        #
+        # When multiple +attrs+ are given, returns +true+ if
+        # *any* of them are defined on +self+.  When no +attrs+ are given,
+        # returns +true+ if *any* attribute is overriden.
+        #
+        # Related: #inherited?
+        def overrides?(*attrs)
+          attrs = data.members if attrs.empty?
+          attrs.any? { data[_1] != INHERITED }
+        end
 
         # :call-seq:
         #   reset -> self

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

@@ -28,10 +28,22 @@ module Net
         end
         private_class_method :included
 
-        if defined?(Ractor.make_shareable)
-          def self.safe(...) Ractor.make_shareable nil.instance_eval(...).freeze end
+        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(...) nil.instance_eval(...).freeze end
+          def self.safe(&b) nil.instance_eval(&b).freeze end
         end
         private_class_method :safe
 
@@ -48,10 +60,10 @@ module Net
         NilOrInteger = safe{->val { Integer val unless val.nil? }}
 
         Enum = ->(*enum) {
-          enum     = safe{enum}
-          expected = -"one of #{enum.map(&:inspect).join(", ")}"
+          safe_enum = safe{enum}
+          expected = -"one of #{safe_enum.map(&:inspect).join(", ")}"
           safe{->val {
-            return val if enum.include?(val)
+            return val if safe_enum.include?(val)
             raise ArgumentError, "expected %s, got %p" % [expected, val]
           }}
         }

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Net
+  class IMAP
+    class Config
+      # >>>
+      #   *NOTE:* This module is an internal implementation detail, with no
+      #   guarantee of backward compatibility.
+      #
+      # Adds a +defaults+ parameter to +attr_accessor+, which is used to compile
+      # Config.version_defaults.
+      module AttrVersionDefaults
+        # The <tt>x.y</tt> part of Net::IMAP::VERSION, as a Rational number.
+        CURRENT_VERSION = VERSION.to_r
+
+        # The config version used for <tt>Config[:next]</tt>.
+        NEXT_VERSION    = CURRENT_VERSION + 0.1r
+
+        # The config version used for <tt>Config[:future]</tt>.
+        FUTURE_VERSION  = 1.0r
+
+        VERSIONS = ((0.0r..FUTURE_VERSION) % 0.1r).to_a.freeze
+
+        # See Config.version_defaults.
+        singleton_class.attr_reader :version_defaults
+
+        @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)
+        }
+
+        # :stopdoc: internal APIs only
+
+        def attr_accessor(name, defaults: nil, default: (unset = true), **kw)
+          unless unset
+            version  = DEFAULT_TO_INHERIT.include?(name) ? nil : 0.0r
+            defaults = { version => default }
+          end
+          defaults&.each_pair do |version, default|
+            AttrVersionDefaults.version_defaults[version] ||= {}
+            AttrVersionDefaults.version_defaults[version][name] = default
+          end
+          super(name, **kw)
+        end
+
+        def self.compile_default!
+          raise "Config.default already compiled" if Config.default
+          default = VERSIONS.select { _1 <= CURRENT_VERSION }
+            .filter_map { version_defaults[_1] }
+            .prepend(version_defaults.delete(nil))
+            .inject(&:merge)
+          Config.new(**default).freeze
+        end
+
+        def self.compile_version_defaults!
+          version_defaults[0.0r]     = Config[version_defaults.fetch(0.0r)]
+
+          VERSIONS.each_cons(2) do |prior, version|
+            updates = version_defaults[version]
+            version_defaults[version] = version_defaults[prior]
+              .then { updates ? _1.dup.update(**updates).freeze : _1 }
+          end
+
+          # 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 in Rational
+            version_defaults[k.to_f] = v
+          end
+
+          version_defaults[:original] = Config[0.0r]
+          version_defaults[:current]  = Config[CURRENT_VERSION]
+          version_defaults[:default]  = Config[CURRENT_VERSION]
+          version_defaults[:next]     = Config[NEXT_VERSION]
+          version_defaults[:future]   = Config[FUTURE_VERSION]
+
+          version_defaults.freeze
+        end
+
+      end
+    end
+  end
+end