whois 6.0.0 → 6.0.1

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,
     }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: whois
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.0.1
 platform: ruby
 authors:
 - Simone Carletti
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-05 00:00:00.000000000 Z
+date: 2024-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -167,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: An intelligent pure Ruby WHOIS client and parser.