whois 5.0.0 → 5.1.0

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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Arin do
-
   let(:definition) { [:ipv4, "0.0.0.0/1", "whois.arin.net"] }
   let(:server) { described_class.new(*definition) }
 
@@ -22,7 +23,7 @@ describe Whois::Server::Adapters::Arin do
       it "follows whois:// referrals" do
         referral = File.read(fixture("referrals/arin_referral_whois.txt"))
         response = "Whois Response"
-        expected = referral + "\n" + response
+        expected = "#{referral}\n#{response}"
         expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
         expect(server.query_handler).to receive(:call).with("0.0.0.0", "whois.ripe.net", 43).and_return(response)
 
@@ -30,13 +31,13 @@ describe Whois::Server::Adapters::Arin do
         expect(record.to_s).to eq(expected)
         expect(record.parts.size).to eq(2)
         expect(record.parts).to eq([Whois::Record::Part.new(body: referral, host: "whois.arin.net"),
-                                    Whois::Record::Part.new(body: response, host: "whois.ripe.net")])
+                                    Whois::Record::Part.new(body: response, host: "whois.ripe.net"),])
       end
 
       it "follows rwhois:// referrals" do
         referral = File.read(fixture("referrals/arin_referral_rwhois.txt"))
         response = "Whois Response"
-        expected = referral + "\n" + response
+        expected = "#{referral}\n#{response}"
         expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
         expect(server.query_handler).to receive(:call).with("0.0.0.0", "rwhois.servernap.net", 4321).and_return(response)
 
@@ -44,14 +45,14 @@ describe Whois::Server::Adapters::Arin do
         expect(record.to_s).to eq(expected)
         expect(record.parts.size).to eq(2)
         expect(record.parts).to eq([Whois::Record::Part.new(body: referral, host: "whois.arin.net"),
-                                    Whois::Record::Part.new(body: response, host: "rwhois.servernap.net")])
+                                    Whois::Record::Part.new(body: response, host: "rwhois.servernap.net"),])
       end
 
       it "ignores referral if options[:referral] is false" do
         referral = File.read(fixture("referrals/arin_referral_whois.txt"))
         server.options[:referral] = false
         expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
-        expect(server.query_handler).to receive(:call).with("0.0.0.0", "whois.ripe.net", 43).never
+        expect(server.query_handler).not_to receive(:call).with("0.0.0.0", "whois.ripe.net", 43)
 
         record = server.lookup("0.0.0.0")
         expect(record.parts.size).to eq(1)
@@ -60,7 +61,7 @@ describe Whois::Server::Adapters::Arin do
       it "ignores referral (gracefully) if missing" do
         referral = File.read(fixture("referrals/arin_referral_missing.txt"))
         expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
-        expect(server.query_handler).to receive(:call).never
+        expect(server.query_handler).not_to receive(:call)
 
         record = server.lookup("0.0.0.0")
         expect(record.parts.size).to eq(1)
@@ -75,10 +76,8 @@ describe Whois::Server::Adapters::Arin do
         record = server.lookup("0.0.0.0")
         expect(record.parts.size).to eq(2)
         expect(record.parts).to eq([Whois::Record::Part.new(body: referral, host: "whois.arin.net"),
-                                    Whois::Record::Part.new(body: response, host: "whois.apnic.net")])
+                                    Whois::Record::Part.new(body: response, host: "whois.apnic.net"),])
       end
     end
-
   end
-
 end

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'whois/server/adapters/arin'
 
 describe Whois::Server::Adapters::Arpa do
-
   let(:definition) { [:tld, ".in-addr.arpa", nil, {}] }
 
   describe "#lookup" do
@@ -16,5 +17,4 @@ describe Whois::Server::Adapters::Arpa do
       expect(record.parts).to eq([Whois::Record::Part.new(body: response, host: "whois.arin.net")])
     end
   end
-
 end

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

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Base do
-
-  let(:definition)  { [:tld, ".test", "whois.test", { foo: "bar" }] }
+  let(:definition) { [:tld, ".test", "whois.test", { foo: "bar" }] }
 
 
   describe "#initialize" do
     it "requires type, allocation, and host parameters" do
       expect { described_class.new(:tld) }.to raise_error(ArgumentError)
       expect { described_class.new(:tld, ".test") }.to raise_error(ArgumentError)
-      expect { described_class.new(:tld, ".test", "whois.test") }.to_not raise_error
+      expect { described_class.new(:tld, ".test", "whois.test") }.not_to raise_error
     end
 
     it "accepts an options parameter" do
-      expect { described_class.new(:tld, ".test", "whois.test", { foo: "bar" }) }.to_not raise_error
+      expect { described_class.new(:tld, ".test", "whois.test", { foo: "bar" }) }.not_to raise_error
     end
 
     it "sets instance variables from arguments" do
@@ -78,22 +79,22 @@ describe Whois::Server::Adapters::Base do
 
   describe "#configure" do
     it "merges settings with current options" do
-      a = described_class.new(:tld, ".test", "whois.test", { :hello => "world" })
+      a = described_class.new(:tld, ".test", "whois.test", { hello: "world" })
       a.configure(foo: "bar")
-      expect(a.options).to eq({ :hello => "world", foo: "bar" })
+      expect(a.options).to eq({ hello: "world", foo: "bar" })
     end
 
     it "gives higher priority to settings argument" do
       a = described_class.new(:tld, ".test", "whois.test", { foo: "bar" })
       expect(a.options).to eq({ foo: "bar" })
-      a.configure(:foo => "baz")
-      expect(a.options).to eq({ :foo => "baz" })
+      a.configure(foo: "baz")
+      expect(a.options).to eq({ foo: "baz" })
     end
 
     it "overrides @host if :host option exists" do
-      a = described_class.new(:tld, ".test", "whois.test", { :hello => "world" })
+      a = described_class.new(:tld, ".test", "whois.test", { hello: "world" })
       a.configure(foo: "bar", host: "whois.example.com")
-      expect(a.options).to eq({ :hello => "world", foo: "bar", host: "whois.example.com" })
+      expect(a.options).to eq({ hello: "world", foo: "bar", host: "whois.example.com" })
       expect(a.host).to eq("whois.example.com")
     end
   end
@@ -127,7 +128,7 @@ describe Whois::Server::Adapters::Base do
     end
 
     context "with :bind_host and :bind_port options" do
-      let(:server) { described_class.new(:tld, ".test", "whois.test", { :bind_host => "192.168.1.1", :bind_port => 3000 }) }
+      let(:server) { described_class.new(:tld, ".test", "whois.test", { bind_host: "192.168.1.1", bind_port: 3000 }) }
 
       it "binds the WHOIS query to given host and port" do
         expect(described_class.query_handler).to receive(:call).with("example.test", "whois.test", 43, "192.168.1.1", 3000)
@@ -137,7 +138,7 @@ describe Whois::Server::Adapters::Base do
     end
 
     context "with :bind_port and without :bind_host options" do
-      let(:server) { described_class.new(:tld, ".test", "whois.test", { :bind_port => 3000 }) }
+      let(:server) { described_class.new(:tld, ".test", "whois.test", { bind_port: 3000 }) }
 
       it "binds the WHOIS query to given port and defaults host" do
         expect(described_class.query_handler).to receive(:call).with("example.test", "whois.test", 43, described_class::DEFAULT_BIND_HOST, 3000)
@@ -146,5 +147,4 @@ describe Whois::Server::Adapters::Base do
       end
     end
   end
-
 end

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Formatted do
-
-  let(:definition) { [:tld, ".de", "whois.denic.de", { :format => "-T dn,ace -C US-ASCII %s" }] }
+  let(:definition) { [:tld, ".de", "whois.denic.de", { format: "-T dn,ace -C US-ASCII %s" }] }
 
 
   describe "#lookup" do
@@ -19,8 +20,8 @@ describe Whois::Server::Adapters::Formatted do
 
     context "without format option" do
       it "raises an error" do
-        server = described_class.new(*[:tld, ".de", "whois.denic.de", {}])
-        expect(server.query_handler).to receive(:call).never
+        server = described_class.new(:tld, ".de", "whois.denic.de", {})
+        expect(server.query_handler).not_to receive(:call)
 
         expect {
           server.lookup("domain.de")
@@ -31,7 +32,7 @@ describe Whois::Server::Adapters::Formatted do
     context "with port option" do
       it "sends the request to given port" do
         response = "Whois Response"
-        server = described_class.new(:tld, ".de", "whois.denic.de", { :format => "-T dn,ace -C US-ASCII %s", :port => 20 })
+        server = described_class.new(:tld, ".de", "whois.denic.de", { format: "-T dn,ace -C US-ASCII %s", port: 20 })
         expect(server.query_handler).to receive(:call).with("-T dn,ace -C US-ASCII domain.de", "whois.denic.de", 20).and_return(response)
 
         server.lookup("domain.de")
@@ -41,13 +42,12 @@ describe Whois::Server::Adapters::Formatted do
     context "with bind option" do
       it "binds the request to given host and port" do
         response = "Whois Response"
-        server = described_class.new(:tld, ".de", "whois.denic.de", { :format => "-T dn,ace -C US-ASCII %s" })
-        server.configure(:bind_host => "192.168.1.1", :bind_port => 3000)
+        server = described_class.new(:tld, ".de", "whois.denic.de", { format: "-T dn,ace -C US-ASCII %s" })
+        server.configure(bind_host: "192.168.1.1", bind_port: 3000)
         expect(server.query_handler).to receive(:call).with("-T dn,ace -C US-ASCII domain.de", "whois.denic.de", 43, "192.168.1.1", 3000).and_return(response)
 
         server.lookup("domain.de")
       end
     end
   end
-
 end

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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::None do
-
   describe "#lookup" do
     it "raises Whois::NoInterfaceError" do
       expect {
@@ -19,5 +20,4 @@ describe Whois::Server::Adapters::None do
       }.to raise_error(Whois::NoInterfaceError, /ipv4/)
     end
   end
-
 end

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

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::NotImplemented do
-
-  before(:each) do
-    @definition = [:ipv6, "2001:0000::/32", "teredo", { :adapter => Whois::Server::Adapters::NotImplemented }]
+  before do
+    @definition = [:ipv6, "2001:0000::/32", "teredo", { adapter: Whois::Server::Adapters::NotImplemented }]
   end
 
 
@@ -20,5 +21,4 @@ describe Whois::Server::Adapters::NotImplemented do
       }.to raise_error(Whois::ServerNotImplemented, /teredo/)
     end
   end
-
 end

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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Standard do
-
   let(:definition) { [:tld, ".test", "whois.test", {}] }
 
 
@@ -20,7 +21,7 @@ describe Whois::Server::Adapters::Standard do
     context "with port option" do
       it "sends the request to given port" do
         response = "Whois Response"
-        server = described_class.new(:tld, ".test", "whois.test", { :port => 20 })
+        server = described_class.new(:tld, ".test", "whois.test", { port: 20 })
         expect(server.query_handler).to receive(:call).with("domain.test", "whois.test", 20).and_return(response)
 
         server.lookup("domain.test")
@@ -30,13 +31,12 @@ describe Whois::Server::Adapters::Standard do
     context "with bind option" do
       it "binds the request to given host and port" do
         response = "Whois Response"
-        server = described_class.new(:tld, ".test", "whois.test", { :port => 20 })
-        server.configure(:bind_host => "192.168.1.100", :bind_port => 3000)
+        server = described_class.new(:tld, ".test", "whois.test", { port: 20 })
+        server.configure(bind_host: "192.168.1.100", bind_port: 3000)
         expect(server.query_handler).to receive(:call).with("domain.test", "whois.test", 20, "192.168.1.100", 3000).and_return(response)
 
         server.lookup("domain.test")
       end
     end
   end
-
 end

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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Verisign do
-
   let(:definition) { [:tld, ".test", "whois.test", {}] }
   let(:server) { described_class.new(*definition) }
 
@@ -24,7 +25,7 @@ describe Whois::Server::Adapters::Verisign do
       it "follows all referrals" do
         referral = File.read(fixture("referrals/crsnic.com.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.test", 43).and_return(referral)
         expect(server.query_handler).to receive(:call).with("example.test", "whois.markmonitor.com", 43).and_return(response)
 
@@ -38,7 +39,7 @@ describe Whois::Server::Adapters::Verisign do
         referral = File.read(fixture("referrals/crsnic.com.txt"))
         server.options[:referral] = false
         expect(server.query_handler).to receive(:call).with("=example.test", "whois.test", 43).and_return(referral)
-        expect(server.query_handler).to receive(:call).never
+        expect(server.query_handler).not_to receive(:call)
 
         record = server.lookup("example.test")
         expect(record.parts.size).to eq(1)
@@ -49,12 +50,11 @@ describe Whois::Server::Adapters::Verisign do
       it "ignores referral (gracefully) if missing" do
         referral = File.read(fixture("referrals/crsnic.com_referral_missing.txt"))
         expect(server.query_handler).to receive(:call).with("=example.test", "whois.test", 43).and_return(referral)
-        expect(server.query_handler).to receive(:call).never
+        expect(server.query_handler).not_to receive(:call)
 
         record = server.lookup("example.test")
         expect(record.parts.size).to eq(1)
       end
     end
   end
-
 end

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

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Web do
-
-  before(:each) do
-    @definition = [:tld, ".test", nil, { :url => "http://whois.test" }]
+  before do
+    @definition = [:tld, ".test", nil, { url: "http://whois.test" }]
   end
 
 
@@ -20,5 +21,4 @@ describe Whois::Server::Adapters::Web do
       }.to raise_error(Whois::WebInterfaceError, /whois\.test/)
     end
   end
-
 end

data/spec/whois/server/socket_handler_spec.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'whois/server/socket_handler'
 
 describe Whois::Server::SocketHandler do
-
   describe "#call" do
-    [ Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EPIPE, SocketError ].each do |error|
+    [Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EPIPE, SocketError].each do |error|
       it "re-raises #{error} as Whois::ConnectionError" do
         expect(subject).to receive(:execute).and_raise(error)
         expect {
@@ -13,15 +14,16 @@ describe Whois::Server::SocketHandler do
       end
 
       it "executes a socket connection for given args" do
-        socket = double("Handler")
+        socket = instance_double(TCPSocket)
         expect(socket).to receive(:write).with("example.test\r\n")
         expect(socket).to receive(:read)
         expect(socket).to receive(:close)
 
-        expect(TCPSocket).to receive(:new).with("whois.test", 43).and_return(socket)
+        expect(TCPSocket).to receive(:new)
+          .with("whois.test", 43)
+          .and_return(socket)
         subject.call("example.test", "whois.test", 43)
       end
     end
   end
-
 end

data/spec/whois/server_spec.rb

@@ -1,41 +1,43 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server do
   describe ".load_json" do
     it "loads a definition from a JSON file" do
-      expect(File).to receive(:read).with("tld.json").and_return(<<-JSON)
-{
-  "ae.org": {
-    "host": "whois.centralnic.com"
-  },
-  "ar.com": {
-    "host": "whois.centralnic.com"
-  }
-}
+      expect(File).to receive(:read).with("tld.json").and_return(<<~JSON)
+        {
+          "ae.org": {
+            "host": "whois.centralnic.com"
+          },
+          "ar.com": {
+            "host": "whois.centralnic.com"
+          }
+        }
       JSON
       with_definitions do
         described_class.load_json("tld.json")
         expect(described_class.definitions(:tld)).to eq([
-          ["ae.org", "whois.centralnic.com", {}],
-          ["ar.com", "whois.centralnic.com", {}],
-        ])
+                                                          ["ae.org", "whois.centralnic.com", {}],
+                                                          ["ar.com", "whois.centralnic.com", {}],
+                                                        ])
       end
     end
 
     it "convert option keys to Symbol" do
-      expect(File).to receive(:read).with("tld.json").and_return(<<-JSON)
-{
-  "com": {
-    "host": "whois.crsnic.net",
-    "adapter": "verisign"
-  }
-}
+      expect(File).to receive(:read).with("tld.json").and_return(<<~JSON)
+        {
+          "com": {
+            "host": "whois.crsnic.net",
+            "adapter": "verisign"
+          }
+        }
       JSON
       with_definitions do
         described_class.load_json("tld.json")
         expect(described_class.definitions(:tld)).to eq([
-          ["com", "whois.crsnic.net", adapter: "verisign"],
-        ])
+                                                          ["com", "whois.crsnic.net", { adapter: "verisign" }],
+                                                        ])
       end
     end
   end
@@ -70,7 +72,7 @@ describe Whois::Server do
     it "accepts a hash of options" do
       with_definitions do
         Whois::Server.define(Whois::Server::TYPE_TLD, "foo", "whois.foo", foo: "bar")
-        expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", { :foo => "bar" }]])
+        expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", { foo: "bar" }]])
       end
     end
   end
@@ -81,7 +83,7 @@ describe Whois::Server do
       expect(server.type).to eq(:tld)
       expect(server.allocation).to eq("test")
       expect(server.host).to eq("whois.test")
-      expect(server.options).to eq(Hash.new)
+      expect(server.options).to eq({})
     end
 
     it "returns a standard adapter by default" do
@@ -92,25 +94,26 @@ describe Whois::Server do
     it "accepts an :adapter option as Class and returns an instance of given adapter" do
       a = Class.new do
         attr_reader :args
+
         def initialize(*args)
           @args = args
         end
       end
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => a)
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: a)
       expect(server).to be_a(a)
       expect(server.args).to eq([:tld, "test", "whois.test", {}])
     end
 
     it "accepts an :adapter option as Symbol or String, load Class and returns an instance of given adapter" do
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => :none)
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: :none)
       expect(server).to be_a(Whois::Server::Adapters::None)
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => "none")
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: "none")
       expect(server).to be_a(Whois::Server::Adapters::None)
     end
 
     it "deletes the adapter option" do
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => Whois::Server::Adapters::None, :foo => "bar")
-      expect(server.options).to eq({ :foo => "bar" })
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: Whois::Server::Adapters::None, foo: "bar")
+      expect(server.options).to eq({ foo: "bar" })
     end
   end
 
@@ -296,5 +299,4 @@ describe Whois::Server do
       end
     end
   end
-
 end

data/spec/whois/{errors_spec.rb → web_interface_error_spec.rb}

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::WebInterfaceError do
-
   describe "#initialize" do
     it "sets the URL" do
       expect(described_class.new("http://example.com").url).to eq("http://example.com")
     end
 
     it "requires the URL argument" do
-      expect {
+      expect do
         described_class.new
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -19,5 +20,4 @@ describe Whois::WebInterfaceError do
       expect(described_class.new("http://example.com").message).to match(%r{http://example.com})
     end
   end
-
 end

data/spec/whois/whois_spec.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois do
-
   describe ".lookup" do
     it "delegates the lookup to a new client" do
-      client = double()
+      client = double
       expect(client).to receive(:lookup).with("example.com").and_return(:result)
       expect(Whois::Client).to receive(:new).and_return(client)
 
       expect(described_class.lookup("example.com")).to eq(:result)
     end
   end
-
 end

data/utils/compare-whois.rb

@@ -13,7 +13,7 @@ end
 
 Dir.glob("#{File.expand_path(IANAWHOIS_DIR)}/*").each do |entry|
   basename = File.basename(entry)
-  next unless basename =~ /^[A-Z]+$/
+  next unless basename.match?(/^[A-Z]+$/)
   content = File.read(entry)
   server  = content =~ /^whois:\s+(.+)\n$/ && $1
   servers[".#{basename.downcase}"] = server

data/utils/matrix.rb

@@ -41,7 +41,7 @@ P = Whois::Record::Parser
 PROPERTIES = [:disclaimer, :domain, :domain_id, :status, :available?, :registered?, :created_on, :updated_on, :expires_on, :registrar, :registrant_contacts, :admin_contacts, :technical_contacts, :nameservers]
 
 hosts = Dir.glob(File.join(LIB, "whois/record/parser/*.rb"))
-           .reject { |f| f =~ /\/(base|blank|example)/ }
+           .reject { |f| f.match?(/\/(base|blank|example)/) }
            .map { |f| File.basename(f, ".rb") }
 
 pthin = %w(