whois 5.1.1 → 6.0.1

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::Server::Adapters::Base do
   let(:definition) { [:tld, ".test", "whois.test", { foo: "bar" }] }
@@ -36,43 +36,48 @@ describe Whois::Server::Adapters::Base do
       one = two = described_class.new(*definition)
 
       expect(one == two).to be_truthy
-      expect(one.eql?(two)).to be_truthy
+      expect(one).to eql(two)
     end
 
     it "returns true when other has same class and has the same attributes" do
-      one, two = described_class.new(*definition), described_class.new(*definition)
+      one = described_class.new(*definition)
+      two = described_class.new(*definition)
 
       expect(one == two).to be_truthy
-      expect(one.eql?(two)).to be_truthy
+      expect(one).to eql(two)
     end
 
     it "returns true when other has descendant class and has the same attributes" do
       subklass = Class.new(described_class)
-      one, two = described_class.new(*definition), subklass.new(*definition)
+      one = described_class.new(*definition)
+      two = subklass.new(*definition)
 
       expect(one == two).to be_truthy
-      expect(one.eql?(two)).to be_truthy
+      expect(one).to eql(two)
     end
 
     it "returns false when other has different class and has the same attributes" do
-      one, two = described_class.new(*definition), Struct.new(:type, :allocation, :host, :options).new(*definition)
+      one = described_class.new(*definition)
+      two = Struct.new(:type, :allocation, :host, :options).new(*definition)
 
       expect(one == two).to be_falsey
-      expect(one.eql?(two)).to be_falsey
+      expect(one).not_to eql(two)
     end
 
     it "returns false when other has different attributes" do
-      one, two = described_class.new(:tld, ".test", "whois.test"), described_class.new(:tld, ".cool", "whois.test")
+      one = described_class.new(:tld, ".test", "whois.test")
+      two = described_class.new(:tld, ".cool", "whois.test")
 
       expect(one == two).to be_falsey
-      expect(one.eql?(two)).to be_falsey
+      expect(one).not_to eql(two)
     end
 
     it "returns false when other has different options" do
-      one, two = described_class.new(:tld, ".test", "whois.test"), described_class.new(:tld, ".test", "whois.test", { foo: "bar" })
+      one = described_class.new(:tld, ".test", "whois.test")
+      two = described_class.new(:tld, ".test", "whois.test", { foo: "bar" })
 
       expect(one == two).to be_falsey
-      expect(one.eql?(two)).to be_falsey
+      expect(one).not_to eql(two)
     end
   end
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::Server::Adapters::Formatted do
   let(:definition) { [:tld, ".de", "whois.denic.de", { format: "-T dn,ace -C US-ASCII %s" }] }

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::Server::Adapters::None do
   describe "#lookup" do

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::Server::Adapters::NotImplemented do
   before do
-    @definition = [:ipv6, "2001:0000::/32", "teredo", { adapter: Whois::Server::Adapters::NotImplemented }]
+    @definition = [:ipv6, "2001:0000::/32", "teredo", { adapter: described_class }]
   end
 
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::Server::Adapters::Standard do
   let(:definition) { [:tld, ".test", "whois.test", {}] }

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::Server::Adapters::Verisign do
   let(:definition) { [:tld, ".test", "whois.test", {}] }

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::Server::Adapters::Web do
   before do

data/spec/whois/server/socket_handler_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'whois/server/socket_handler'
+require "spec_helper"
+require "whois/server/socket_handler"
 
 describe Whois::Server::SocketHandler do
   describe "#call" do

data/spec/whois/server_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::Server do
   describe ".load_json" do
@@ -45,7 +45,7 @@ describe Whois::Server do
   describe ".definitions" do
     it "returns the definitions array for given type" do
       with_definitions do
-        Whois::Server.define(Whois::Server::TYPE_TLD, "foo", "whois.foo")
+        described_class.define(Whois::Server::TYPE_TLD, "foo", "whois.foo")
         definition = described_class.definitions(Whois::Server::TYPE_TLD)
         expect(definition).to be_a(Array)
         expect(definition).to eq([["foo", "whois.foo", {}]])
@@ -64,14 +64,14 @@ describe Whois::Server do
   describe ".define" do
     it "adds a new definition with given arguments" do
       with_definitions do
-        Whois::Server.define(Whois::Server::TYPE_TLD, "foo", "whois.foo")
+        described_class.define(Whois::Server::TYPE_TLD, "foo", "whois.foo")
         expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", {}]])
       end
     end
 
     it "accepts a hash of options" do
       with_definitions do
-        Whois::Server.define(Whois::Server::TYPE_TLD, "foo", "whois.foo", foo: "bar")
+        described_class.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" }]])
       end
     end
@@ -79,7 +79,7 @@ describe Whois::Server do
 
   describe ".factory" do
     it "returns an adapter initialized with given arguments" do
-      server = Whois::Server.factory(:tld, "test", "whois.test")
+      server = described_class.factory(:tld, "test", "whois.test")
       expect(server.type).to eq(:tld)
       expect(server.allocation).to eq("test")
       expect(server.host).to eq("whois.test")
@@ -87,7 +87,7 @@ describe Whois::Server do
     end
 
     it "returns a standard adapter by default" do
-      server = Whois::Server.factory(:tld, "test", "whois.test")
+      server = described_class.factory(:tld, "test", "whois.test")
       expect(server).to be_a(Whois::Server::Adapters::Standard)
     end
 
@@ -99,115 +99,115 @@ describe Whois::Server do
           @args = args
         end
       end
-      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: a)
+      server = described_class.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 = described_class.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 = described_class.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")
+      server = described_class.factory(:tld, "test", "whois.test", adapter: Whois::Server::Adapters::None, foo: "bar")
       expect(server.options).to eq({ foo: "bar" })
     end
   end
 
   describe ".guess" do
     it "recognizes tld" do
-      server = Whois::Server.guess(".com")
+      server = described_class.guess(".com")
       expect(server).to be_a(Whois::Server::Adapters::Base)
       expect(server.type).to eq(Whois::Server::TYPE_TLD)
     end
 
     it "recognizes domain" do
-      server = Whois::Server.guess("example.com")
+      server = described_class.guess("example.com")
       expect(server).to be_a(Whois::Server::Adapters::Base)
       expect(server.type).to eq(Whois::Server::TYPE_TLD)
     end
 
     it "recognizes ipv4" do
-      server = Whois::Server.guess("127.0.0.1")
+      server = described_class.guess("127.0.0.1")
       expect(server).to be_a(Whois::Server::Adapters::Base)
       expect(server.type).to eq(Whois::Server::TYPE_IPV4)
     end
 
     it "recognizes ipv6" do
-      server = Whois::Server.guess("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+      server = described_class.guess("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
       expect(server).to be_a(Whois::Server::Adapters::Base)
       expect(server.type).to eq(Whois::Server::TYPE_IPV6)
     end
 
     it "recognizes ipv6 when zero groups" do
-      server = Whois::Server.guess("2002::1")
+      server = described_class.guess("2002::1")
       expect(server).to be_a(Whois::Server::Adapters::Base)
       expect(server.type).to eq(Whois::Server::TYPE_IPV6)
     end
 
     it "recognizes asn16" do
-      server = Whois::Server.guess("AS23456")
+      server = described_class.guess("AS23456")
       expect(server).to be_a(Whois::Server::Adapters::Base)
       expect(server.type).to eq(Whois::Server::TYPE_ASN16)
     end
 
     it "recognizes asn32" do
-      server = Whois::Server.guess("AS131072")
+      server = described_class.guess("AS131072")
       expect(server).to be_a(Whois::Server::Adapters::Base)
       expect(server.type).to eq(Whois::Server::TYPE_ASN32)
     end
 
     it "recognizes email" do
       expect {
-        Whois::Server.guess("email@example.org")
+        described_class.guess("email@example.org")
       }.to raise_error(Whois::ServerNotSupported, /email/)
     end
 
     it "raises when unrecognized value" do
       expect {
-        Whois::Server.guess("invalid")
+        described_class.guess("invalid")
       }.to raise_error(Whois::ServerNotFound)
     end
 
 
     context "when the input is a tld" do
       it "returns a IANA adapter" do
-        expect(Whois::Server.guess(".com")).to eq(Whois::Server.factory(:tld, ".", "whois.iana.org"))
+        expect(described_class.guess(".com")).to eq(described_class.factory(:tld, ".", "whois.iana.org"))
       end
 
       it "returns a IANA adapter when the input is an idn" do
-        expect(Whois::Server.guess(".xn--fiqs8s")).to eq(Whois::Server.factory(:tld, ".", "whois.iana.org"))
+        expect(described_class.guess(".xn--fiqs8s")).to eq(described_class.factory(:tld, ".", "whois.iana.org"))
       end
     end
 
     context "when the input is a domain" do
       it "lookups definitions and returns the adapter" do
         with_definitions do
-          Whois::Server.define(:tld, "test", "whois.test")
-          expect(Whois::Server.guess("example.test")).to eq(Whois::Server.factory(:tld, "test", "whois.test"))
+          described_class.define(:tld, "test", "whois.test")
+          expect(described_class.guess("example.test")).to eq(described_class.factory(:tld, "test", "whois.test"))
         end
       end
 
       it "doesn't consider the dot as a regexp pattern" do
         with_definitions do
-          Whois::Server.define(:tld, "no.com", "whois.no.com")
-          Whois::Server.define(:tld, "com", "whois.com")
-          expect(Whois::Server.guess("antoniocangiano.com")).to eq(Whois::Server.factory(:tld, "com", "whois.com"))
+          described_class.define(:tld, "no.com", "whois.no.com")
+          described_class.define(:tld, "com", "whois.com")
+          expect(described_class.guess("antoniocangiano.com")).to eq(described_class.factory(:tld, "com", "whois.com"))
         end
       end
 
       it "returns the closer definition" do
         with_definitions do
-          Whois::Server.define(:tld, "com", com = "whois.com")
-          Whois::Server.define(:tld, "com.foo", comfoo = "whois.com.foo")
-          Whois::Server.define(:tld, "foo.com", foocom = "whois.foo.com")
+          described_class.define(:tld, "com", com = "whois.com")
+          described_class.define(:tld, "com.foo", comfoo = "whois.com.foo")
+          described_class.define(:tld, "foo.com", foocom = "whois.foo.com")
 
-          expect(Whois::Server.guess("example.com").host).to eq(com)
-          expect(Whois::Server.guess("example.com.foo").host).to eq(comfoo)
-          expect(Whois::Server.guess("example.foo.com").host).to eq(foocom)
+          expect(described_class.guess("example.com").host).to eq(com)
+          expect(described_class.guess("example.com.foo").host).to eq(comfoo)
+          expect(described_class.guess("example.foo.com").host).to eq(foocom)
         end
       end
     end
@@ -215,16 +215,16 @@ describe Whois::Server do
     context "when the input is an asn16" do
       it "lookups definitions and returns the adapter" do
         with_definitions do
-          Whois::Server.define(:asn16, "0 65535", "whois.test")
-          expect(Whois::Server.guess("AS65535")).to eq(Whois::Server.factory(:asn16, "0 65535", "whois.test"))
+          described_class.define(:asn16, "0 65535", "whois.test")
+          expect(described_class.guess("AS65535")).to eq(described_class.factory(:asn16, "0 65535", "whois.test"))
         end
       end
 
       it "raises if definition is not found" do
         with_definitions do
-          Whois::Server.define(:asn16, "0 60000", "whois.test")
+          described_class.define(:asn16, "0 60000", "whois.test")
           expect {
-            Whois::Server.guess("AS65535")
+            described_class.guess("AS65535")
           }.to raise_error(Whois::AllocationUnknown)
         end
       end
@@ -233,16 +233,16 @@ describe Whois::Server do
     context "when the input is an asn32" do
       it "lookups definitions and returns the adapter" do
         with_definitions do
-          Whois::Server.define(:asn32, "65536 394239", "whois.test")
-          expect(Whois::Server.guess("AS65536")).to eq(Whois::Server.factory(:asn32, "65536 394239", "whois.test"))
+          described_class.define(:asn32, "65536 394239", "whois.test")
+          expect(described_class.guess("AS65536")).to eq(described_class.factory(:asn32, "65536 394239", "whois.test"))
         end
       end
 
       it "raises if definition is not found" do
         with_definitions do
-          Whois::Server.define(:asn32, "65536 131071", "whois.test")
+          described_class.define(:asn32, "65536 131071", "whois.test")
           expect {
-            Whois::Server.guess("AS200000")
+            described_class.guess("AS200000")
           }.to raise_error(Whois::AllocationUnknown)
         end
       end
@@ -251,16 +251,16 @@ describe Whois::Server do
     context "when the input is a ipv4" do
       it "lookups definitions and returns the adapter" do
         with_definitions do
-          Whois::Server.define(:ipv4, "192.168.1.0/10", "whois.test")
-          expect(Whois::Server.find_for_ip("192.168.1.1")).to eq(Whois::Server.factory(:ipv4, "192.168.1.0/10", "whois.test"))
+          described_class.define(:ipv4, "192.168.1.0/10", "whois.test")
+          expect(described_class.find_for_ip("192.168.1.1")).to eq(described_class.factory(:ipv4, "192.168.1.0/10", "whois.test"))
         end
       end
 
       it "raises if definition is not found" do
         with_definitions do
-          Whois::Server.define(:ipv4, "192.168.1.0/10", "whois.test")
+          described_class.define(:ipv4, "192.168.1.0/10", "whois.test")
           expect {
-            Whois::Server.guess("192.192.0.1")
+            described_class.guess("192.192.0.1")
           }.to raise_error(Whois::AllocationUnknown)
         end
       end
@@ -269,31 +269,31 @@ describe Whois::Server do
     context "when the input is a ipv6" do
       it "lookups definitions and returns the adapter" do
         with_definitions do
-          Whois::Server.define(:ipv6, "2001:0200::/23", "whois.test")
-          expect(Whois::Server.guess("2001:0200::1")).to eq(Whois::Server.factory(:ipv6, "2001:0200::/23", "whois.test"))
+          described_class.define(:ipv6, "2001:0200::/23", "whois.test")
+          expect(described_class.guess("2001:0200::1")).to eq(described_class.factory(:ipv6, "2001:0200::/23", "whois.test"))
         end
       end
 
       it "raises if definition is not found" do
         with_definitions do
-          Whois::Server.define(:ipv6, "::1", "whois.test")
+          described_class.define(:ipv6, "::1", "whois.test")
           expect {
-            Whois::Server.guess("2002:0300::1")
+            described_class.guess("2002:0300::1")
           }.to raise_error(Whois::AllocationUnknown)
         end
       end
 
       it "recognizes ipv4 compatibility mode" do
         with_definitions do
-          Whois::Server.define(:ipv6, "::192.168.1.1", "whois.test")
-          expect(Whois::Server.guess("::192.168.1.1")).to eq(Whois::Server.factory(:ipv6, "::192.168.1.1", "whois.test"))
+          described_class.define(:ipv6, "::192.168.1.1", "whois.test")
+          expect(described_class.guess("::192.168.1.1")).to eq(described_class.factory(:ipv6, "::192.168.1.1", "whois.test"))
         end
       end
 
       it "rescues IPAddr ArgumentError", issue: "weppos/whois#174" do
         with_definitions do
           expect {
-            Whois::Server.guess("f53")
+            described_class.guess("f53")
           }.to raise_error(Whois::AllocationUnknown)
         end
       end

data/spec/whois/web_interface_error_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois::WebInterfaceError do
   describe "#initialize" do

data/spec/whois/whois_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Whois do
   describe ".lookup" do

data/utils/deftld.rb

@@ -35,7 +35,6 @@ class TldDefs
         format: :format,
         url: :url,
 
-        group: :_group,
         note: :_note,
         type: :_type,
     }

data/whois.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.description = "Whois is an intelligent WHOIS client and parser written in pure Ruby. It can query registry data for IPv4, IPv6 and top level domains, and parse the responses into easy-to-use Ruby objects via the whois-parser library."
   s.license     = "MIT"
 
-  s.required_ruby_version = ">= 2.4"
+  s.required_ruby_version = ">= 3.0"
 
   s.require_paths    = %w( lib )
   s.executables      =%w( whoisrb )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: whois
 version: !ruby/object:Gem::Version
-  version: 5.1.1
+  version: 6.0.1
 platform: ruby
 authors:
 - Simone Carletti
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-08 00:00:00.000000000 Z
+date: 2024-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -84,6 +84,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- SECURITY.md
 - bin/console
 - bin/whoisrb
 - data/asn16.json
@@ -159,46 +160,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: An intelligent pure Ruby WHOIS client and parser.
-test_files:
-- spec/fixtures/referrals/afilias.bz.txt
-- spec/fixtures/referrals/arin_referral_apnic.txt
-- spec/fixtures/referrals/arin_referral_missing.txt
-- spec/fixtures/referrals/arin_referral_ripe.txt
-- spec/fixtures/referrals/arin_referral_rwhois.txt
-- spec/fixtures/referrals/arin_referral_servernap.txt
-- spec/fixtures/referrals/arin_referral_whois.txt
-- spec/fixtures/referrals/crsnic.com.txt
-- spec/fixtures/referrals/crsnic.com_referral.txt
-- spec/fixtures/referrals/crsnic.com_referral_missing.txt
-- spec/integration/whois_spec.rb
-- spec/spec_helper.rb
-- spec/support/helpers/connectivity_helper.rb
-- spec/support/helpers/spec_helper.rb
-- spec/whois/client_spec.rb
-- spec/whois/record/part_spec.rb
-- spec/whois/record_spec.rb
-- spec/whois/server/adapters/afilias_spec.rb
-- spec/whois/server/adapters/arin_spec.rb
-- spec/whois/server/adapters/arpa_spec.rb
-- spec/whois/server/adapters/base_spec.rb
-- spec/whois/server/adapters/formatted_spec.rb
-- spec/whois/server/adapters/none_spec.rb
-- spec/whois/server/adapters/not_implemented_spec.rb
-- spec/whois/server/adapters/standard_spec.rb
-- spec/whois/server/adapters/verisign_spec.rb
-- spec/whois/server/adapters/web_spec.rb
-- spec/whois/server/socket_handler_spec.rb
-- spec/whois/server_spec.rb
-- spec/whois/web_interface_error_spec.rb
-- spec/whois/whois_spec.rb
+test_files: []