♻️ Add default_proc to Config.version_defaults

This enables more flexible lookups.  So we can now use something like
`Config["0.4.11"]` (I do _not_ intend to store version defaults for
`x.y.z` releases).  I had to add a special-case for zero, to avoid
`Config["missing"] == Config[0r]`

Author: nevans

lib/net/imap/config.rb

@@ -131,8 +131,26 @@ def self.default; @default end
       def self.global; @global if defined?(@global) end
 
       # A hash of hard-coded configurations, indexed by version number or name.
+      # Keys are symbol names or +major.minor+ numbers, and lookups can be
+      # accessed with anything responds to +to_sym+ or +to_r+/+to_f+ (with a
+      # non-zero number).
+      #
+      # Config::[] uses this hash lookup named or numbered versions.
+      #
+      # For example:
+      #     Net::IMAP::Config.version_defaults[0.5] == Net::IMAP::Config[0.5]
+      #     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 = {}
+      @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_sym, nil) if k.respond_to?(:to_sym)) ||
+          (h.fetch(k.to_r, nil) || h.fetch(k.to_f, nil) if k.is_a?(Numeric)) ||
+          (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)
+      }
 
       # :call-seq:
       #  Net::IMAP::Config[number] -> versioned config
@@ -155,18 +173,17 @@ def self.[](config)
         elsif config.nil? && global.nil?   then nil
         elsif config.respond_to?(:to_hash) then new(global, **config).freeze
         else
-          version_defaults.fetch(config) do
+          version_defaults[config] or
             case config
             when Numeric
               raise RangeError, "unknown config version: %p" % [config]
-            when Symbol
+            when String, Symbol
               raise KeyError, "unknown config name: %p" % [config]
             else
               raise TypeError, "no implicit conversion of %s to %s" % [
                 config.class, Config
               ]
             end
-          end
         end
       end
 
@@ -478,8 +495,6 @@ def defaults_hash
       version_defaults.to_a.each do |k, v|
         next unless k in Rational
         version_defaults[k.to_f] = v
-        next unless k.to_i.to_r == k
-        version_defaults[k.to_i] = v
       end
 
       current = VERSION.to_r

test/net/imap/test_config.rb

@@ -186,6 +186,8 @@ class ConfigTest < Test::Unit::TestCase
 
   test ".[] key errors" do
     assert_raise(KeyError) do Config[:nonexistent] end
+    assert_raise(KeyError) do Config["nonexistent"] end
+    assert_raise(KeyError) do Config["0.01"] end
   end
 
   test ".[] with symbol names" do
@@ -195,6 +197,52 @@ class ConfigTest < Test::Unit::TestCase
     assert_same    Config[FUTURE_VERSION],    Config[:future]
   end
 
+  test ".[] with string names" do
+    assert_same Config[:original], Config["original"]
+    assert_same Config[:current],  Config["current"]
+    assert_same Config[0.4r],      Config["0.4.11"]
+    assert_same Config[0.5r],      Config["0.5.6"]
+    assert_same Config[:current],  Config[Net::IMAP::VERSION]
+  end
+
+  test ".[] with object responding to to_sym, to_r, or to_f" do
+    # responds to none of the methods
+    duck = Object.new
+    assert_raise TypeError do Config[duck] end
+
+    # to_sym
+    duck = Object.new
+    def duck.to_sym = :current
+    assert_same Config[:current], Config[duck]
+
+    # to_r
+    duck = Object.new
+    def duck.to_r = 0.6r
+    assert_same Config[0.6r], Config[duck]
+
+    # to_f
+    duck = Object.new
+    def duck.to_f = 0.4
+    assert_same Config[0.4], Config[duck]
+
+    # prefer to_r over to_f
+    def duck.to_r   = 0.5r
+    assert_same Config[0.5r], Config[duck]
+    #
+    # prefer to_sym over to_r
+    def duck.to_sym = :original
+    assert_same Config[:original], Config[duck]
+
+    # keeps trying if to_sym finds nothing
+    duck = Object.new
+    def duck.to_sym = :nope
+    def duck.to_f   = 0.5
+    assert_same Config[0.5],  Config[duck]
+    # keeps trying if to_sym and to_r both find nothing
+    def duck.to_r   = 1/11111
+    assert_same Config[0.5],  Config[duck]
+  end
+
   test ".[] with a hash" do
     config = Config[{responses_without_block: :raise, sasl_ir: false}]
     assert config.frozen?