whois 5.0.1 → 5.1.0

data/lib/whois/server/adapters/standard.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 #--
 # Ruby Whois
 #
 # An intelligent pure Ruby WHOIS client and parser.
 #
-# Copyright (c) 2009-2020 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
 #++
 
 
@@ -56,4 +58,4 @@ module Whois
 
     end
   end
-end
+end

data/lib/whois/server/adapters/verisign.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 #--
 # Ruby Whois
 #
 # An intelligent pure Ruby WHOIS client and parser.
 #
-# Copyright (c) 2009-2020 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
 #++
 
 
@@ -40,6 +42,7 @@ module Whois
 
         def extract_referral(response)
           return unless (match = response.match(/Registrar WHOIS Server:(.+?)$/))
+
           server = match[match.size - 1].strip
           server.empty? ? nil : server
         end

data/lib/whois/server/adapters/web.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 #--
 # Ruby Whois
 #
 # An intelligent pure Ruby WHOIS client and parser.
 #
-# Copyright (c) 2009-2020 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
 #++
 
 

data/lib/whois/server/socket_handler.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 #--
 # Ruby Whois
 #
 # An intelligent pure Ruby WHOIS client and parser.
 #
-# Copyright (c) 2009-2020 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
 #++
 
 
@@ -22,9 +24,9 @@ module Whois
       # Array of connection errors to rescue
       # and wrap into a {Whois::ConnectionError}
       RESCUABLE_CONNECTION_ERRORS = [
-          SystemCallError,
-          SocketError,
-      ]
+        SystemCallError,
+        SocketError,
+      ].freeze
 
       # Performs the Socket request.
       #
@@ -36,8 +38,8 @@ module Whois
       #
       def call(query, *args)
         execute(query, *args)
-      rescue *RESCUABLE_CONNECTION_ERRORS => error
-        raise ConnectionError, "#{error.class}: #{error.message}"
+      rescue *RESCUABLE_CONNECTION_ERRORS => e
+        raise ConnectionError, "#{e.class}: #{e.message}"
       end
 
       # Executes the low-level Socket connection.

data/lib/whois/server.rb

@@ -1,16 +1,26 @@
 # frozen_string_literal: true
+
 #--
 # Ruby Whois
 #
 # An intelligent pure Ruby WHOIS client and parser.
 #
-# Copyright (c) 2009-2020 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
 #++
 
 
 require 'ipaddr'
 require 'json'
-require 'whois/server/adapters/base'
+require "whois/server/adapters/base"
+require "whois/server/adapters/arin"
+require "whois/server/adapters/arpa"
+require "whois/server/adapters/afilias"
+require "whois/server/adapters/formatted"
+require "whois/server/adapters/none"
+require "whois/server/adapters/not_implemented"
+require "whois/server/adapters/standard"
+require "whois/server/adapters/verisign"
+require "whois/server/adapters/web"
 
 
 module Whois
@@ -26,25 +36,15 @@ module Whois
     # WHOIS server adapters. Each adapter is a subclass of {Whois::Server::Adapters::Base},
     # customized to handle WHOIS queries for a type or a group of servers.
     module Adapters
-      autoload :Base,             "whois/server/adapters/base"
-      autoload :Arin,             "whois/server/adapters/arin"
-      autoload :Arpa,             "whois/server/adapters/arpa"
-      autoload :Afilias,          "whois/server/adapters/afilias"
-      autoload :Formatted,        "whois/server/adapters/formatted"
-      autoload :None,             "whois/server/adapters/none"
-      autoload :NotImplemented,   "whois/server/adapters/not_implemented"
-      autoload :Standard,         "whois/server/adapters/standard"
-      autoload :Verisign,         "whois/server/adapters/verisign"
-      autoload :Web,              "whois/server/adapters/web"
     end
 
     # @return [Array<Symbol>] the definition types
     TYPES = [
-        TYPE_TLD   = :tld,
-        TYPE_IPV4  = :ipv4,
-        TYPE_IPV6  = :ipv6,
-        TYPE_ASN16 = :asn16,
-        TYPE_ASN32 = :asn32,
+      TYPE_TLD = :tld,
+      TYPE_IPV4  = :ipv4,
+      TYPE_IPV6  = :ipv6,
+      TYPE_ASN16 = :asn16,
+      TYPE_ASN32 = :asn32,
     ].freeze
 
     # Empty hash constant used to save allocation for definitions with empty settings.
@@ -67,7 +67,7 @@ module Whois
       # @return [void]
       def load_definitions
         clear_definitions
-        Dir[File.expand_path("../../../data/*.json", __FILE__)].each { |f| load_json(f) }
+        Dir[File.expand_path('../../data/*.json', __dir__)].each { |f| load_json(f) }
       end
 
       # Loads the definitions from a JSON file.
@@ -77,16 +77,17 @@ module Whois
       # @return [void]
       def load_json(file)
         type = File.basename(file, File.extname(file)).to_sym
-        JSON.load(File.read(file)).each do |allocation, settings|
+        JSON.parse(File.read(file)).each do |allocation, settings|
           next if allocation == "_"
+
           settings.reject! { |k, _| k.start_with?("_") }
           host = settings.delete("host")
           host = intern_string(host) if host
           options = if settings.empty?
-            EMPTY_HASH
-          else
-            Hash[settings.map { |k,v| [k.to_sym, v.is_a?(String) ? intern_string(v) : v] }].freeze
-          end
+                      EMPTY_HASH
+                    else
+                      settings.map { |k, v| [k.to_sym, v.is_a?(String) ? intern_string(v) : v] }.to_h.freeze
+                    end
           define(type, allocation, host, options)
         end
       end
@@ -112,7 +113,7 @@ module Whois
       #
       def definitions(type)
         TYPES.include?(type) or
-            raise(ArgumentError, "`#{type}` is not a valid definition type")
+          raise(ArgumentError, "`#{type}` is not a valid definition type")
 
         _definitions(type).values
       end
@@ -156,7 +157,7 @@ module Whois
       #
       def define(type, allocation, host, options = EMPTY_HASH)
         TYPES.include?(type) or
-            raise(ArgumentError, "`#{type}` is not a valid definition type")
+          raise(ArgumentError, "`#{type}` is not a valid definition type")
 
         _definitions(type)[allocation] = [allocation, host, options.freeze]
       end
@@ -234,19 +235,13 @@ module Whois
       #         but the object type doesn't have any supported WHOIS adapter associated.
       def guess(string)
         # Top Level Domain match
-        if matches_tld?(string)
-          return factory(:tld, ".", "whois.iana.org")
-        end
+        return factory(:tld, ".", "whois.iana.org") if matches_tld?(string)
 
         # IP address (secure match)
-        if matches_ip?(string)
-          return find_for_ip(string)
-        end
+        return find_for_ip(string) if matches_ip?(string)
 
         # Email Address (secure match)
-        if matches_email?(string)
-          return find_for_email(string)
-        end
+        return find_for_email(string) if matches_email?(string)
 
         # Domain Name match
         if (server = find_for_domain(string))
@@ -254,9 +249,7 @@ module Whois
         end
 
         # ASN match
-        if matches_asn?(string)
-          return find_for_asn(string)
-        end
+        return find_for_asn(string) if matches_asn?(string)
 
         # Game Over
         raise ServerNotFound, "Unable to find a WHOIS server for `#{string}'"
@@ -276,12 +269,11 @@ module Whois
           ip = IPAddr.new(string)
           type = ip.ipv4? ? TYPE_IPV4 : TYPE_IPV6
           _definitions(type).each do |_, definition|
-            if IPAddr.new(definition.first).include?(ip)
-              return factory(type, *definition)
-            end
+            return factory(type, *definition) if IPAddr.new(definition.first).include?(ip)
           end
         rescue ArgumentError
           # continue
+          nil
         end
         raise AllocationUnknown, "IP Allocation for `#{string}' unknown"
       end
@@ -304,7 +296,7 @@ module Whois
         token = string
         defs  = _definitions(TYPE_TLD)
 
-        while token != "" do
+        while token != ""
           if (found = defs[token])
             return factory(:tld, *found)
           else
@@ -328,7 +320,7 @@ module Whois
       #         that matches one of the existing server definitions.
       def find_for_asn(string)
         asn = string[/\d+/].to_i
-        asn_type = asn <= 65535 ? TYPE_ASN16 : TYPE_ASN32
+        asn_type = asn <= 65_535 ? TYPE_ASN16 : TYPE_ASN32
         _definitions(asn_type).each do |_, definition|
           if (range = definition.first.split.map(&:to_i)) && asn >= range.first && asn <= range.last
             return factory(asn_type, *definition)
@@ -379,9 +371,10 @@ module Whois
       end
 
       def valid_ipv4?(addr)
-        if /\A(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\Z/ =~ addr
-          return $~.captures.all? {|i| i.to_i < 256}
+        if (m = /\A(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\Z/.match(addr))
+          return m.captures.all? { |i| i.to_i < 256 }
         end
+
         false
       end
 
@@ -391,9 +384,10 @@ module Whois
         return true if addr.match?(/\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*)?\Z/)
         return true if addr.match?(/\A::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*)?\Z/)
         # IPv6 (IPv4 compat)
-        return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:/ =~ addr && valid_ipv4?($')
-        return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:)?/ =~ addr && valid_ipv4?($')
-        return true if /\A::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:)?/ =~ addr && valid_ipv4?($')
+        return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:/ =~ addr && valid_ipv4?(Regexp.last_match.post_match)
+        return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:)?/ =~ addr && valid_ipv4?(Regexp.last_match.post_match)
+        return true if /\A::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:)?/ =~ addr && valid_ipv4?(Regexp.last_match.post_match)
+
         false
       end
 

data/lib/whois/version.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 #--
 # Ruby Whois
 #
 # An intelligent pure Ruby WHOIS client and parser.
 #
-# Copyright (c) 2009-2020 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
 #++
 
 
 module Whois
   # The current library version.
-  VERSION = "5.0.1".freeze
+  VERSION = "5.1.0"
 end

data/lib/whois.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 #--
 # Ruby Whois
 #
 # An intelligent pure Ruby WHOIS client and parser.
 #
-# Copyright (c) 2009-2020 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
 #++
 
 
@@ -35,7 +37,7 @@ module Whois
       Client.new.lookup(object)
     end
 
-    alias_method :whois, :lookup
+    alias whois lookup
 
 
     # @deprecated
@@ -45,11 +47,11 @@ module Whois
         return
       end
 
-      deprecate(%Q{Whois.available? is deprecated. Call Whois.whois("#{object}").available?})
+      deprecate(%{Whois.available? is deprecated. Call Whois.whois("#{object}").parser.available?})
 
       result = lookup(object).parser.available?
       if result.nil?
-        warn  "This method is not supported for this kind of object.\n" +
+        warn  "This method is not supported for this kind of object.\n" \
               "Use Whois.lookup('#{object}') instead."
       end
       result
@@ -62,11 +64,11 @@ module Whois
         return
       end
 
-      deprecate(%Q{Whois.registered? is deprecated. Call Whois.whois("#{object}").available?})
+      deprecate(%{Whois.registered? is deprecated. Call Whois.whois("#{object}").parser.registered?})
 
       result = lookup(object).parser.registered?
       if result.nil?
-        warn  "This method is not supported for this kind of object.\n" +
+        warn  "This method is not supported for this kind of object.\n" \
               "Use Whois.lookup('#{object}') instead."
       end
       result
@@ -87,9 +89,9 @@ module Whois
     # @api private
     # @private
     def bug!(error, message)
-      raise error, message.dup        <<
-        " Please report the issue at" <<
-        " http://github.com/weppos/whois/issues"
+      raise error, message.dup <<
+                   " Please report the issue at" \
+                   " http://github.com/weppos/whois/issues"
     end
 
 
@@ -107,10 +109,10 @@ module Whois
     end
 
     def extract_callstack(callstack)
-      gem_root = File.expand_path("../../../", __FILE__) + "/"
+      gem_root = "#{File.expand_path('../..', __dir__)}/"
       offending_line = callstack.find { |line| !line.start_with?(gem_root) } || callstack.first
       if offending_line
-        if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
+        if (md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/))
           md.captures
         else
           offending_line

data/spec/integration/whois_spec.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois do
-
-  let(:response)    { "Domain:             example.it\nStatus:             AVAILABLE\n" }
+  let(:response) { "Domain:             example.it\nStatus:             AVAILABLE\n" }
 
   describe "Basic WHOIS querying and parsing" do
     it "works" do
@@ -32,7 +33,7 @@ describe Whois do
           .with("example.it", "whois.nic.it", 43, "192.168.1.1", 3000)
           .and_return(response)
 
-        client = Whois::Client.new(:bind_host => "192.168.1.1", :bind_port => 3000)
+        client = Whois::Client.new(bind_host: "192.168.1.1", bind_port: 3000)
         client.lookup("example.it")
       end
     end
@@ -46,7 +47,7 @@ describe Whois do
           .with("example.it", "whois.nic.it", 43, Whois::Server::Adapters::Base::DEFAULT_BIND_HOST, 3000)
           .and_return(response)
 
-        client = Whois::Client.new(:bind_port => 3000)
+        client = Whois::Client.new(bind_port: 3000)
         client.lookup("example.it")
       end
     end
@@ -60,7 +61,7 @@ describe Whois do
           .with("example.it", "whois.example.com", 43)
           .and_return(response)
 
-        client = Whois::Client.new(:host => "whois.example.com")
+        client = Whois::Client.new(host: "whois.example.com")
         record = client.lookup("example.it")
 
         expect(record.parts.size).to eq(1)
@@ -69,5 +70,4 @@ describe Whois do
       end
     end
   end
-
 end

data/spec/spec_helper.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 require 'rspec'
 require 'whois'
 
-unless defined?(SPEC_ROOT)
-  SPEC_ROOT = File.expand_path("../", __FILE__)
-end
+SPEC_ROOT = File.expand_path(__dir__) unless defined?(SPEC_ROOT)
 
 # The fixtures are UTF-8 encoded.
 # Make sure Ruby uses the proper encoding.
@@ -12,7 +12,7 @@ Encoding.default_internal = Encoding::UTF_8
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
-Dir[File.join(SPEC_ROOT, "support/**/*.rb")].each { |f| require f }
+Dir[File.join(SPEC_ROOT, "support/**/*.rb")].sort.each { |f| require f }
 
 RSpec.configure do |config|
   config.mock_with :rspec

data/spec/support/helpers/connectivity_helper.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 module RSpecSupportConnectivityHelpers
   def need_connectivity
-    if connectivity_available?
-      yield
-    end
+    yield if connectivity_available?
   end
 
   def connectivity_available?

data/spec/support/helpers/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpecSupportSpecHelpers
 
   def fixture(*names)

data/spec/whois/client_spec.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Client do
-
   describe "#initialize" do
     it "accepts a zero parameters" do
-      expect { described_class.new }.to_not raise_error
+      expect { described_class.new }.not_to raise_error
     end
 
     it "accepts a settings parameter" do
-      expect { described_class.new({ foo: "bar" }) }.to_not raise_error
+      expect { described_class.new({ foo: "bar" }) }.not_to raise_error
     end
 
 
@@ -111,7 +112,7 @@ describe Whois::Client do
       client = described_class.new(timeout: 5)
       expect {
         client.lookup("example.test")
-      }.to_not raise_error
+      }.not_to raise_error
     end
 
     it "supports unlimited timeout" do
@@ -125,9 +126,8 @@ describe Whois::Client do
       client = described_class.new.tap { |c| c.timeout = nil }
       expect {
         client.lookup("example.test")
-      }.to_not raise_error
+      }.not_to raise_error
     end
-
   end
 
   # FIXME: use RSpec metadata
@@ -140,5 +140,4 @@ describe Whois::Client do
       end
     end
   end
-
 end

data/spec/whois/record/part_spec.rb

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Record::Part do
-
   describe "#initialize" do
     it "accepts an empty value" do
       expect {
         instance = described_class.new
         expect(instance.body).to be_nil
-      }.to_not raise_error
+      }.not_to raise_error
     end
 
     it "accepts an empty hash" do
       expect {
         instance = described_class.new({})
         expect(instance.body).to be_nil
-      }.to_not raise_error
+      }.not_to raise_error
     end
 
     it "initializes a new instance from given hash" do
@@ -34,5 +35,4 @@ describe Whois::Record::Part do
       expect(instance.host).to eq("whois.example.test")
     end
   end
-
 end

data/spec/whois/record_spec.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Record do
-
   subject { described_class.new(server, parts) }
 
   let(:server) {
     Whois::Server.factory(:tld, ".foo", "whois.example.test")
   }
-  let(:parts) {[
-    Whois::Record::Part.new(body: "This is a record from foo.", host: "foo.example.test"),
-    Whois::Record::Part.new(body: "This is a record from bar.", host: "bar.example.test")
-  ]}
+  let(:parts) {
+    [
+      Whois::Record::Part.new(body: "This is a record from foo.", host: "foo.example.test"),
+      Whois::Record::Part.new(body: "This is a record from bar.", host: "bar.example.test"),
+    ]
+  }
   let(:content) {
     parts.map(&:body).join("\n")
   }
@@ -20,7 +23,7 @@ describe Whois::Record do
     it "requires a server and parts" do
       expect { described_class.new }.to raise_error(ArgumentError)
       expect { described_class.new(server) }.to raise_error(ArgumentError)
-      expect { described_class.new(server, parts) }.to_not raise_error
+      expect { described_class.new(server, parts) }.not_to raise_error
     end
 
     it "sets server and parts from arguments" do
@@ -154,5 +157,4 @@ describe Whois::Record do
       expect(described_class.new(nil, []).content).to eq("")
     end
   end
-
 end

data/spec/whois/server/adapters/afilias_spec.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Afilias do
-
   let(:definition) { [:tld, ".test", "whois.afilias-grs.info", {}] }
   let(:server) { described_class.new(*definition) }
 
@@ -24,7 +25,7 @@ describe Whois::Server::Adapters::Afilias do
       it "follows all referrals" do
         referral = File.read(fixture("referrals/afilias.bz.txt"))
         response = "Match for example.test."
-        expected = referral + "\n" + response
+        expected = "#{referral}\n#{response}"
         expect(server.query_handler).to receive(:call).with("example.test", "whois.afilias-grs.info", 43).and_return(referral)
         expect(server.query_handler).to receive(:call).with("example.test", "whois.belizenic.bz", 43).and_return(response)
 
@@ -38,12 +39,11 @@ describe Whois::Server::Adapters::Afilias do
         referral = File.read(fixture("referrals/afilias.bz.txt"))
         server.options[:referral] = false
         expect(server.query_handler).to receive(:call).with("example.test", "whois.afilias-grs.info", 43).and_return(referral)
-        expect(server.query_handler).to receive(:call).with("example.test", "whois.belizenic.bz", 43).never
+        expect(server.query_handler).not_to receive(:call).with("example.test", "whois.belizenic.bz", 43)
 
         record = server.lookup("example.test")
         expect(record.parts.size).to eq(1)
       end
     end
   end
-
 end