whois 6.0.0 → 6.0.2

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,13 @@
 --- !ruby/object:Gem::Specification
 name: whois
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.0.2
 platform: ruby
 authors:
 - Simone Carletti
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -61,12 +60,11 @@ executables:
 - whoisrb
 extensions: []
 extra_rdoc_files:
-- LICENSE.txt
 - ".yardopts"
+- LICENSE.txt
 files:
 - ".github/FUNDING.yml"
 - ".github/dependabot.yml"
-- ".github/workflows/codeql-analysis.yml"
 - ".github/workflows/release.yml"
 - ".github/workflows/tests.yml"
 - ".gitignore"
@@ -77,7 +75,6 @@ files:
 - ".simplecov"
 - ".tool-versions"
 - ".yardopts"
-- 4.0-Upgrade.md
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -152,7 +149,6 @@ homepage: https://whoisrb.org/
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -167,8 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: An intelligent pure Ruby WHOIS client and parser.
 test_files: []

data/.github/workflows/codeql-analysis.yml

@@ -1,64 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ main ]
-  schedule:
-    - cron: '39 4 * * 0'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'ruby' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Learn more about CodeQL language support at https://git.io/codeql-language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v3
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3

data/4.0-Upgrade.md

@@ -1,143 +0,0 @@
-# Welcome to Whois 4.0!
-
-Whois 4 is a major upgrade compared to Whois 3. This library is now 7 years old, enough mature to offer pretty much all the features you need to perform WHOIS queries.
-
-In these last 7 years the adoption of this library has grown beyond any expectation. Most of the time was spent updating the definitions to stay up to date with the various registrar changes (thanks ICANN for thew newGLTDs...), updating the registry parsers and polishing up the public interface.
-
-For Whois 4 I decided to take a step back, and rewrite some of the internal components of this library to improve performance and readability. As a result of these changes, there are several compatibility breaks with Whois 4 that I'm going to document here.
-
--- Simone
-
-## What's New
-
-- The Whois client and the Whois parser are now two separate repositories, and they are also distributed as two separate gems:
-
-    - https://github.com/weppos/whois - https://rubygems.org/gems/whois
-    - https://github.com/weppos/whois-parser https://rubygems.org/gems/whois-parser
-
-  There are several reasons behind this change (see [weppos/whois#503](https://github.com/weppos/whois/pull/503)).
-
-  First of all, the maintenance of the whois-parser component is the most time consuming task. Updating a parser may require from a few minutes to several hours, depending on how big are the changes. It also requires to generate the appropriate fixtures, and write the necessary tests. In the last years I noticed that more than once client updates were delayed because of pending parser changes. Separating the repositories and the release cycles will likely speedup future released of the client gem.
-
-  Moreover, the parser component takes a lot of space (due to all the files and fixtures). If you just need a Ruby whois client, loading the entire parser component is inefficient and a waste of time/CPU/resources.
-
-  Last but not least, in the last years the Whois client inspired several ports in different languages. Most of these ports were not interested in porting the parser as well. However, the parser was so tightly coupled with the client that it made the client code harder to read.
-
-- The definition files have been largely redesigned, in particular the TLD file. The definitions are now maintained using a set of CLI tools. The goal is to eventually extract the definition files into a separate, standalone repository that other WHOIS libraries can easily fetch.
-
-## Upgrade
-
-When upgrading, here's the most relevant changes to keep an eye on:
-
-- If you are using the Whois parser, install and require the `whois-parser` gem. The parser will automatically download the appropriate `whois` dependency.
-
-    ```ruby
-    require 'whois-parser'
-    ```
-
-  If you only need the client and you don't care about the parser, simply continue to require the `whois` gem directly.
-
-    ```ruby
-    require 'whois'
-    ```
-  
-- `Whois::Server.definitions` no longer return the internal definitions. Definitions are no longer accessible directly, because their internal representation may change at any time. If you need to modify the definitions, use the public API.
-
-    ```ruby
-    Whois::Server.define(Whois::Server::TYPE_TLD, ...)
-    ```
-
-  You can still use `Whois::Server.definitions`, but it will return a copy of the internal definitions, and you have to specify which type of definitions you want to access.
-
-    ```ruby
-    Whois::Server.definitions(Whois::Server::TYPE_TLD)
-    ```
-
-- **The parser methods are no longer accessible directly within the response object.**
-
-  This is probably one of the most important changes, and it is explained in details at [weppos/whois-parser#5](https://github.com/weppos/whois-parser/pull/5).
-
-  In Whois 3, you can invoke a property method on a record object and the record will automatically route the method call to the underlying parser. If the property is not supported or defined in any of the parsers, then the method will return nil.
-
-  However, this behavior is often the cause of confusion and misunderstandings, especially for partially implemented parsers. Without to mention that the code required for this feature to work added an extra layer of complexity to the `Whois::Record` implementation.
-
-  Starting from Whois 4, the `Whois::Record` doesn't expose any parsing methods anymore. If you want to parse a record, you have to istantiate a parser manually. Of course, you also need to use the `whois-parser` library instead of `whois`.
-
-  Whois 3:
-
-    ```ruby
-    require 'whois-parser'
-
-    record = Whois.whois("example.it")
-    record.expires_on
-    ```
-
-  Whois 4:
-
-    ```ruby
-    require 'whois-parser'
-
-    record = Whois.whois("example.it")
-    parser = Whois::Parser.new(record)
-    parser.expires_on
-    ```
-
-  You can still use the convenient helper `record.parser` to initialize a parser:
-
-    ```ruby
-    require 'whois-parser'
-
-    record = Whois.whois("example.it")
-    record.parser.expires_on
-    ```
-
-  Also note that any parser method, such as `parser.expires_on`, will raise an error if the property is not implemented, as opposite to silently returning `nil` as it was in Whois 3.
-
-- **Parser extensions**
-
-  The Parser features available in Whois 3 has been packaged into several extensions. Some of them are loaded by default in Whois 4 when you require `whois-parser`, others not anymore. The reason is because although some of them may appear convenient (because it makes you write more code), it turned out that they made some assumptions that were often source of confusion.
-
-  Check the header of the [`whois/parser.rb`](https://github.com/weppos/whois-parser/blob/master/lib/whois/parser.rb) file to learn more about the purpose of each extension.
-
-  Requiring **all** the extensions will essentially force Whois 4 to work pretty much like Whois 3. This is not recommended, and you should not rely on those extensions to be there forever. Instead, you should write the code depending on what you actually need.
-
-  There is also an ENV variable you can set to rollback compatibility to Whois 3.
-
-    ```ruby
-    ENV["WHOISRB_4EXTENSIONS"] = 1
-    ```
-
-  Again, this flag exists only as temporary helper, and it should not become a permanent upgrade workaround.
-
-- **SafeRecord**
-
-  In the previous point I mentioned that you should write the code you need to customize the `Whois::Record` and extract information with the `Whois::Parser`. However, I omitted an important additional recommendation: avoid monkey patching the Whois::Record object, and instead prefer composition via delegation.
-
-  The SafeRecord is an example of a wrapper around a Record object, that expose a Whois 3 alike interface, without injecting the parser methods directly into the `Whois::Record` itself.
-
-  The advantages are:
-
-  - the code is more maintainable, as it is not tighlty coupled to the Whois::Record
-  - you don't monkey patch `Whois::Record` in your code, which is an object you don't have control of because it is packaged in a third party library (and can change)
-  - the library can easily be tested separately
-
-  In these 10 years of writing Ruby code, I've noticed an increasing attitude to monkey patch Ruby classes you don't control, instead of writing your own code and delegate to them. It looks like in several cases Ruby programmers are afraid of writing Ruby code. This results in very fragile code, where methods can easily conflict each other (especially between dependencies).
-
-  The `Whois::SafeRecord` is an alternative example of how you can restore Whois 3 behavior by using a custom object.
-
-    ```ruby
-    require 'whois/parser'
-    require 'whois/safe_record'
-
-    record = Whois.whois('example.com')
-    record.disclaimer
-    # => Whois::AttributeNotSupported
-
-    safe_record = Whois::SafeRecord.new(record)
-    safe_record.disclaimer
-    # => nil
-    ```
-
-  This is preferred over requiring the `whois/parser_extensions` or enabling v3 compatibility mode.
-
-  Please note that the parser extension is provided as example. It may be removed from future versions therefore, once again, you should write the code you need to access the parsed data.