whois 5.0.1 → 5.1.1

data/lib/whois/server/adapters/base.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,7 @@ module Whois
             @query_handler ||= SocketHandler.new
           end
 
-          def query_handler=(handler)
-            @query_handler = handler
-          end
+          attr_writer :query_handler
         end
 
         # Default WHOIS request port.
@@ -48,15 +48,10 @@ module Whois
         attr_reader :buffer
 
 
-        # @param  [Symbol] type
-        #         The type of WHOIS adapter to define.
-        #         Known values are :tld, :ipv4, :ipv6.
-        # @param  [String] allocation
-        #         The allocation, range or hostname, this server is responsible for.
-        # @param  [String, nil] host
-        #         The server hostname. Use nil if unknown or not available.
-        # @param  [Hash] options Optional adapter properties.
-        #
+        # @param  type [Symbol] the type of WHOIS adapter to define. Known values are :tld, :ipv4, :ipv6,
+        # @param  allocation [String] the allocation, range or hostname, this server is responsible for.
+        # @param  host [String, nil] the server hostname. Use nil if unknown or not available.
+        # @param  options [Hash] optional adapter properties
         def initialize(type, allocation, host, options = {})
           @type       = type
           @allocation = allocation
@@ -66,53 +61,44 @@ module Whois
 
         # Checks self and other for equality.
         #
-        # @param  [The Whois::Server::Adapters::Base] other
-        # @return [Boolean] Returns true if the other is the same object,
+        # @param  other [The Whois::Server::Adapters::Base]
+        # @return [Boolean] true if the other is the same object,
         #         or <tt>other</tt> attributes matches this object attributes.
-        #
         def ==(other)
-          (
-            self.equal?(other)
-          ) || (
+          equal?(other) || (
             other.is_a?(self.class) &&
-            self.type == other.type &&
-            self.allocation == other.allocation &&
-            self.host == other.host &&
-            self.options == other.options
+            type == other.type &&
+            allocation == other.allocation &&
+            host == other.host &&
+            options == other.options
           )
         end
 
-        alias_method :eql?, :==
+        alias eql? ==
 
 
         # Merges given +settings+ into current {#options}.
         #
-        # @param  [Hash] settings
-        # @return [Hash] The updated options for this object.
-        #
+        # @param  settings [Hash]
+        # @return [Hash] the updated options for this object
         def configure(settings)
           @host = settings[:host] if settings[:host]
           options.merge!(settings)
         end
 
 
-        # Performs a Whois lookup for <tt>string</tt>
-        # using the current server adapter.
+        # Performs a Whois lookup for <tt>string</tt> using the current server adapter.
         #
-        # Internally, this method calls {#request}
-        # using the Template Method design pattern.
+        # Internally, this method calls {#request} using the Template Method design pattern.
         #
         #   server.lookup("google.com")
         #   # => Whois::Record
         #
-        # @param  [String] string The string to be sent as query parameter.
+        # @param  string [String] the string to query
         # @return [Whois::Record]
-        #
         def lookup(string)
-          buffer_start do |buffer|
-            request(string)
-            Whois::Record.new(self, buffer.dup)
-          end
+          parts = buffer_start { request(string) }
+          Whois::Record.new(self, parts)
         end
 
         # Performs the real WHOIS request.
@@ -121,11 +107,10 @@ module Whois
         # it is intended to be overwritten in the concrete subclasses.
         # This is the heart of the Template Method design pattern.
         #
-        # @param  [String] string The string to be sent as query parameter.
+        # @param  string [String] the string to query
         # @return [void]
         # @raise  [NotImplementedError]
         # @abstract
-        #
         def request(string)
           raise NotImplementedError
         end
@@ -149,6 +134,7 @@ module Whois
         def buffer_start
           @buffer ||= []
           yield(@buffer)
+          @buffer.dup
         ensure
           @buffer.clear
         end
@@ -183,7 +169,7 @@ module Whois
           self.class.query_handler.call(query, *args)
         end
 
-        alias :query_the_socket :query
+        alias query_the_socket query
 
       end
 

data/lib/whois/server/adapters/formatted.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>
 #++
 
 
@@ -47,7 +49,7 @@ module Whois
         #
         def request(string)
           options[:format] || raise(ServerError, "Missing mandatory :format option for adapter `Formatted'")
-          response = query_the_socket(sprintf(options[:format], string), host)
+          response = query_the_socket(format(options[:format], string), host)
           buffer_append response, host
         end
 

data/lib/whois/server/adapters/none.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/adapters/not_implemented.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/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.1"
 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,21 +37,21 @@ module Whois
       Client.new.lookup(object)
     end
 
-    alias_method :whois, :lookup
+    alias whois lookup
 
 
     # @deprecated
     def available?(object)
       unless defined? Whois::Parser
         warn("Whois.available? requires the gem `whois-parser`")
-        return
+        return false
       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
@@ -59,14 +61,14 @@ module Whois
     def registered?(object)
       unless defined? Whois::Parser
         warn("Whois.registered? requires the gem `whois-parser`")
-        return
+        return false
       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,11 +1,12 @@
+# 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
+    it "queries and returns a record" do
       with_definitions do
         Whois::Server.define(:tld, "it", "whois.nic.it")
         expect(Whois::Server::Adapters::Standard.query_handler).to receive(:call)
@@ -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)