whois-parser-next 0.3.1 → 0.4.0

data/lib/whois/parsers/whois.nic.uk.rb

@@ -8,6 +8,7 @@
 
 
 require_relative 'base'
+require_relative 'registry_response_safety'
 
 
 module Whois
@@ -22,6 +23,22 @@ module Whois
     # @see http://www.nominet.org.uk/other/whois/detailedinstruct/
     #
     class WhoisNicUk < Base
+      include RegistryResponseSafety
+
+      DOMAIN_NAME_LINE = /^[ \t]*Domain name:[ \t]*(.*?)[ \t]*\r?$/i
+      NO_MATCH_LINE = /^[ \t]*No match for "([^"]+)"\.[ \t]*\r?$/i
+      NOT_REGISTERED_LINE = /^[ \t]*This domain name has not been registered\.[ \t]*\r?$/i
+      REGISTRATION_STATUS_LINE = /\A[ \t]*Registration status:[ \t]*(.*?)[ \t]*\r?\n?\z/i
+      REGISTRATION_SUPPORT_LINE = /^[ \t]*(?:Registered on|Expiry date|Last updated|Registrar):/i
+      REGISTRATION_EVIDENCE_LINE = /^[ \t]*(?:Domain name|Registration status|Registered on|Expiry date|Last updated|Registrar|Name servers):/i
+      REGISTRATION_STATUSES = {
+        'registered until expiry date.' => :registered,
+        'registration request being processed.' => :registered,
+        'renewal request being processed.' => :registered,
+        'no longer required' => :registered,
+        'renewal required.' => :registered,
+        'no registration status listed.' => :reserved,
+      }.freeze
 
       # == Values for Status
       #
@@ -29,37 +46,37 @@ module Whois
       # @see http://www.nominet.org.uk/registrants/maintain/renew/status/
       #
       property_supported :status do
-        if content_for_scanner =~ /\s+Registration status:\s+(.+?)\n/
-          case ::Regexp.last_match(1).downcase
-          when "registered until expiry date."
-            :registered
-          when "registration request being processed."
-            :registered
-          when "renewal request being processed."
-            :registered
-          when "no longer required"
-            :registered
-          when "no registration status listed."
-            :reserved
-          # NEWSTATUS redemption (https://github.com/weppos/whois/issues/5)
-          when "renewal required."
-            :registered
-          else
-            Whois::Parser.bug!(ParserError, "Unknown status `#{::Regexp.last_match(1)}'.")
-          end
-        elsif invalid?
+        body = content_for_scanner
+        absence_markers = body.lines.count do |line|
+          line.match?(NO_MATCH_LINE) || line.match?(NOT_REGISTERED_LINE)
+        end
+
+        if absence_markers.positive?
+          authoritative_absence?(body) ? :available : :unknown
+        elsif invalid? && !registration_evidence?(body)
           :invalid
         else
-          :available
+          domains = domain_name_values(body)
+          statuses = registration_status_values(body)
+          if domains.length != 1 || !domains.first.downcase.end_with?('.uk') || statuses.length != 1
+            :unknown
+          else
+            status = REGISTRATION_STATUSES[statuses.first.downcase]
+            if status == :registered && !body.match?(REGISTRATION_SUPPORT_LINE)
+              :unknown
+            else
+              status || :unknown
+            end
+          end
         end
       end
 
       property_supported :available? do
-        !!(content_for_scanner =~ /This domain name has not been registered/)
+        status == :available
       end
 
       property_supported :registered? do
-        !available?
+        status == :registered
       end
 
 
@@ -149,7 +166,51 @@ module Whois
       #   and will be replenished in 50 seconds.
       #
       def response_throttled?
-        !!(content_for_scanner =~ /The WHOIS query quota for .+ has been exceeded/)
+        content_for_scanner.match?(/^[ \t]*The WHOIS query quota for .+ has been exceeded\b/i) ||
+          RegistryResponseSafety.instance_method(:response_throttled?).bind_call(self)
+      end
+
+      def registration_status_values(body)
+        lines = body.lines
+        lines.each_with_index.filter_map do |line, index|
+          match = REGISTRATION_STATUS_LINE.match(line)
+          next unless match
+
+          value = match[1].strip
+          if value.empty?
+            next_index = index + 1
+            next_index += 1 while next_index < lines.length && lines[next_index].strip.empty?
+            value = lines[next_index].to_s.strip
+          end
+          value unless value.empty?
+        end
+      end
+
+      def domain_name_values(body)
+        lines = body.lines
+        lines.each_with_index.filter_map do |line, index|
+          match = DOMAIN_NAME_LINE.match(line)
+          next unless match
+
+          value = match[1].strip
+          if value.empty?
+            next_index = index + 1
+            next_index += 1 while next_index < lines.length && lines[next_index].strip.empty?
+            value = lines[next_index].to_s.strip.split(/\s+/, 2).first.to_s
+          end
+          value unless value.empty?
+        end
+      end
+
+      def authoritative_absence?(body)
+        no_match = body.lines.filter_map { |line| NO_MATCH_LINE.match(line)&.captures&.first }
+        not_registered = body.lines.count { |line| line.match?(NOT_REGISTERED_LINE) }
+        no_match.length == 1 && no_match.first.downcase.end_with?('.uk') &&
+          not_registered == 1 && !registration_evidence?(body) && !invalid?
+      end
+
+      def registration_evidence?(body)
+        body.match?(REGISTRATION_EVIDENCE_LINE)
       end
 
 

data/lib/whois/parsers/whois.nic.vip.rb

@@ -5,9 +5,30 @@ module Whois
     # Identity Digital's current .vip endpoint uses the ICANN key/value
     # layout and reports an absent name as `No Data Found`.
     class WhoisNicVip < BaseIcannCompliant
+      RECORD_EVIDENCE = /^(?:Domain Name|Registry Domain ID|Creation Date|Registrar|Domain Status):[ \t]*\S/i
+
       self.scanner = Scanners::BaseIcannCompliant, {
         pattern_available: /^No Data Found\s*$/,
       }
+
+      property_supported :available? do
+        raise ResponseIsThrottled if response_throttled?
+        raise ResponseIsUnavailable if response_unavailable?
+
+        super()
+      end
+
+      def response_unavailable?
+        body = content_for_scanner
+        ambiguous_absence = body.match?(/^No Data Found\s*$/i) && body.match?(RECORD_EVIDENCE)
+
+        super || body.match?(/^\s*access denied\b/i) ||
+          ambiguous_absence
+      end
+
+      def response_throttled?
+        super || content_for_scanner.match?(/^\s*too many requests\b/i)
+      end
     end
   end
 end

data/lib/whois/parsers/whois.nic.wiki.rb

@@ -2,7 +2,28 @@ require_relative 'base_identity_digital'
 module Whois
   class Parsers
     class WhoisNicWiki < BaseIdentityDigital
+      RECORD_EVIDENCE = /^(?:Domain Name|Registry Domain ID|Creation Date|Registrar|Domain Status):[ \t]*\S/i
+
       self.scanner = Scanners::BaseIcannCompliant, { pattern_available: /^No Data Found\s*$/i }
+
+      property_supported :available? do
+        raise ResponseIsThrottled if response_throttled?
+        raise ResponseIsUnavailable if response_unavailable?
+
+        super()
+      end
+
+      def response_unavailable?
+        body = content_for_scanner
+        ambiguous_absence = body.match?(/^No Data Found\s*$/i) && body.match?(RECORD_EVIDENCE)
+
+        super || body.match?(/^\s*access denied\b/i) ||
+          ambiguous_absence
+      end
+
+      def response_throttled?
+        super || content_for_scanner.match?(/^\s*too many requests\b/i)
+      end
     end
   end
 end

data/lib/whois/parsers/whois.nic.win.rb

@@ -5,6 +5,33 @@ module Whois
     # The current .win endpoint uses the same CentralNic/MarkMonitor layout
     # as .design, including the `No Data Found` absence response.
     class WhoisNicWin < WhoisNicDesign
+      RECORD_EVIDENCE = /^(?:Domain Name|Registry Domain ID|Creation Date|Registrar|Domain Status):[ \t]*\S/i
+
+      property_supported :status do
+        raise ResponseIsThrottled if response_throttled?
+        raise ResponseIsUnavailable if response_unavailable?
+
+        super()
+      end
+
+      property_supported :available? do
+        raise ResponseIsThrottled if response_throttled?
+        raise ResponseIsUnavailable if response_unavailable?
+
+        super()
+      end
+
+      def response_unavailable?
+        body = content_for_scanner
+        ambiguous_absence = body.match?(/^No Data Found\s*$/i) && body.match?(RECORD_EVIDENCE)
+
+        super || body.match?(/^\s*access denied\b/i) ||
+          ambiguous_absence
+      end
+
+      def response_throttled?
+        super || content_for_scanner.match?(/^\s*too many requests\b/i)
+      end
     end
   end
 end

data/lib/whois/parsers/whois.publicinterestregistry.org.rb

@@ -0,0 +1,52 @@
+require_relative 'whois.pir.org'
+require_relative 'registry_response_safety'
+
+module Whois
+  class Parsers
+    # IANA currently delegates .org WHOIS to whois.publicinterestregistry.org.
+    # Its field format matches the legacy whois.pir.org parser.
+    class WhoisPublicinterestregistryOrg < WhoisPirOrg
+      include RegistryResponseSafety
+
+      DOMAIN_LINE = /^Domain Name:[ \t]*(\S+)[ \t]*\r?$/i
+      ABSENCE_LINE = /\ADomain not found\.[ \t]*\z/i
+      REGISTERED_EVIDENCE = /^(Registry Domain ID|Creation Date|Updated Date|Registry Expiry Date|Registrar(?: IANA ID)?|Domain Status):[ \t]*\S/im
+      RECORD_EVIDENCE = /^(?:Domain Name|Registry Domain ID|Creation Date|Updated Date|Registry Expiry Date|Registrar(?: IANA ID)?|Domain Status|Name Server):[ \t]*\S/im
+      LEGACY_THROTTLE_LINE = /^[ \t]*WHOIS LIMIT EXCEEDED\b/i
+
+      # WhoisPirOrg has its own scanner-backed throttle check. Call the shared
+      # line guard directly as that inherited override parses the whole body.
+      # Preserve its established PIR marker without parsing unrelated lines.
+      def response_throttled?
+        body = content_for_scanner
+        body.match?(LEGACY_THROTTLE_LINE) ||
+          RegistryResponseSafety.instance_method(:response_throttled?).bind_call(self)
+      end
+
+      property_supported :status do
+        body = content_for_scanner
+        absence_count = body.lines.count { |line| line.chomp.match?(ABSENCE_LINE) }
+
+        if absence_count.positive?
+          absence_count == 1 && !body.match?(RECORD_EVIDENCE) ? :available : :unknown
+        else
+          domains = body.scan(DOMAIN_LINE).flatten
+          evidence_fields = body.scan(REGISTERED_EVIDENCE).flatten.map(&:downcase).uniq
+          if domains.length == 1 && domains.first.downcase.end_with?('.org') && evidence_fields.length >= 2
+            :registered
+          else
+            :unknown
+          end
+        end
+      end
+
+      property_supported :available? do
+        status == :available
+      end
+
+      property_supported :registered? do
+        status == :registered
+      end
+    end
+  end
+end

data/lib/whois/parsers/whois.punktum.dk.rb

@@ -0,0 +1,53 @@
+require_relative 'whois.dk-hostmaster.dk'
+require_relative 'registry_response_safety'
+
+module Whois
+  class Parsers
+    # Direct parser for IANA's current .dk WHOIS host. The older
+    # whois.dk-hostmaster.dk parser remains available for its legacy route.
+    class WhoisPunktumDk < WhoisDkHostmasterDk
+      include RegistryResponseSafety
+
+      DOMAIN_LINE = /^Domain:[ \t]*(\S+)[ \t]*\r?$/i
+      STATUS_LINE = /^Status:[ \t]*(\S+)[ \t]*\r?$/i
+      ABSENCE_LINE = /\ANo entries found for the selected source\.[ \t]*\z/i
+      REGISTERED_EVIDENCE = /^(Registered|Expires|Registrar|Hostname):[ \t]*\S/im
+      RECORD_EVIDENCE = /^(?:Domain|DNS|Registered|Expires|Registrar|Registration period|VID|DNSSEC|Status|Hostname):[ \t]*\S/im
+
+      property_supported :domain do
+        content_for_scanner.scan(DOMAIN_LINE).flatten.first&.downcase
+      end
+
+      property_supported :status do
+        body = content_for_scanner
+        absence_count = body.lines.count { |line| line.chomp.match?(ABSENCE_LINE) }
+
+        if absence_count.positive?
+          absence_count == 1 && !body.match?(RECORD_EVIDENCE) ? :available : :unknown
+        else
+          domains = body.scan(DOMAIN_LINE).flatten
+          statuses = body.scan(STATUS_LINE).flatten
+          evidence_fields = body.scan(REGISTERED_EVIDENCE).flatten.map(&:downcase).uniq
+          if domains.length == 1 && domains.first.downcase.end_with?('.dk') && statuses.length == 1 && evidence_fields.length >= 2
+            case statuses.first.downcase
+            when 'active' then :registered
+            when 'deactivated' then :expired
+            when 'reserved' then :reserved
+            else :unknown
+            end
+          else
+            :unknown
+          end
+        end
+      end
+
+      property_supported :available? do
+        status == :available
+      end
+
+      property_supported :registered? do
+        status == :registered
+      end
+    end
+  end
+end

data/lib/whois/parsers/whois.registry.click.rb

@@ -0,0 +1,9 @@
+require_relative 'base_top1000_icann'
+
+module Whois
+  class Parsers
+    # Parser for IANA's current .click WHOIS host, whois.registry.click.
+    class WhoisRegistryClick < BaseTop1000Icann
+    end
+  end
+end

data/lib/whois/parsers/whois.registry.gift.rb

@@ -0,0 +1,10 @@
+require_relative 'whois.uniregistry.net'
+
+module Whois
+  class Parsers
+    # The current IANA-listed WHOIS host for .GIFT uses the Uniregistry
+    # response format.
+    class WhoisRegistryGift < WhoisUniregistryNet
+    end
+  end
+end

data/lib/whois/parsers/whois.sr.rb

@@ -0,0 +1,44 @@
+require_relative 'base_top1000_icann'
+
+module Whois
+  class Parsers
+    # Parser for the IANA-listed WHOIS server for .SR.
+    #
+    # IANA's delegation record and current server responses were checked on
+    # 2026-09-25. The generated-name response uses an exact Message marker;
+    # other incomplete responses must remain unknown.
+    class WhoisSr < BaseTop1000Icann
+      property_supported :domain do
+        node("Domain", &:downcase)
+      end
+
+      property_supported :status do
+        if reserved?
+          :reserved
+        elsif available?
+          :available
+        elsif !node("Domain").to_s.strip.empty? &&
+              node("Status").to_s.casecmp("active").zero? &&
+              !node("Creation Date").to_s.strip.empty?
+          :registered
+        else
+          :unknown
+        end
+      end
+
+      property_supported :available? do
+        content_for_scanner.match?(/^Message: No Object Found\s*$/i)
+      end
+
+      property_supported :registered? do
+        status == :registered
+      end
+
+      property_supported :nameservers do
+        Array.wrap(node("Name server")).reject(&:empty?).map do |name|
+          Parser::Nameserver.new(name: name.downcase)
+        end
+      end
+    end
+  end
+end

data/lib/whois/parsers/whois.tcinet.ru.rb

@@ -8,6 +8,7 @@
 
 
 require_relative 'base'
+require_relative 'registry_response_safety'
 
 
 module Whois
@@ -23,30 +24,35 @@ module Whois
     #   The Example parser for the list of all available methods.
     #
     class WhoisTcinetRu < Base
+      include RegistryResponseSafety
+
+      DOMAIN_PATTERN = /\A(?:[[:alnum:]](?:[[:alnum:]-]{0,61}[[:alnum:]])?\.)+[[:alnum:]](?:[[:alnum:]-]{0,61}[[:alnum:]])?\z/i
+      KNOWN_STATES = %w[REGISTERED DELEGATED NOT\ DELEGATED VERIFIED UNVERIFIED].freeze
 
       property_supported :domain do
-        if content_for_scanner =~ /domain:\s+(.+?)\n/
-          ::Regexp.last_match(1).downcase
-        end
+        domain_value&.downcase
       end
 
       property_not_supported :domain_id
 
 
       property_supported :status do
-        if content_for_scanner =~ /state:\s+(.+?)\n/
-          ::Regexp.last_match(1).split(",").map(&:strip)
-        else
+        case classify_status
+        when :registered
+          state_values
+        when :available
           []
+        else
+          :unknown
         end
       end
 
       property_supported :available? do
-        !!(content_for_scanner =~ /No entries found/)
+        classify_status == :available
       end
 
       property_supported :registered? do
-        !available?
+        classify_status == :registered
       end
 
 
@@ -108,6 +114,75 @@ module Whois
         end
       end
 
+      def response_unavailable?
+        super || content_for_scanner.match?(/^\s*access denied\b/i)
+      end
+
+      def response_throttled?
+        super || content_for_scanner.match?(/^\s*too many requests\b/i)
+      end
+
+
+      private
+
+      def classify_status
+        cached_properties_fetch(:classified_status) do
+          response = content_for_scanner
+          domains = domain_lines
+          state_rows = state_lines
+          states = state_values
+          normalized_states = states.map(&:upcase)
+          valid_states = states.any? && normalized_states.all? { |state| KNOWN_STATES.include?(state) }
+          conflicting_delegation = normalized_states.include?("DELEGATED") &&
+            normalized_states.include?("NOT DELEGATED")
+          conflicting_verification = normalized_states.include?("VERIFIED") &&
+            normalized_states.include?("UNVERIFIED")
+          safe_response = !response_unavailable? && !response_throttled?
+          absence_count = response.lines.count do |line|
+            line.chomp.match?(/\ANo entries found for the selected source\(s\)\.[ \t]*\z/i)
+          end
+
+          if safe_response && absence_count == 1 && domains.empty? && state_rows.empty?
+            :available
+          elsif safe_response && domains.one? && domain_value && state_rows.one? &&
+              normalized_states.include?("REGISTERED") && valid_states &&
+              !conflicting_delegation && !conflicting_verification && absence_count.zero?
+            :registered
+          else
+            :unknown
+          end
+        end
+      end
+
+      def domain_lines
+        content_for_scanner.lines.filter_map do |line|
+          line.chomp.match(/\Adomain:[ \t]*(.*?)[ \t]*\z/i)&.[](1)
+        end
+      end
+
+      def domain_value
+        domains = domain_lines
+        return unless domains.one? && domains.first.match?(DOMAIN_PATTERN)
+
+        domains.first
+      end
+
+      def state_lines
+        content_for_scanner.lines.filter_map do |line|
+          line.chomp.match(/\Astate:[ \t]*(.*?)[ \t]*\z/i)&.[](1)
+        end
+      end
+
+      def state_values
+        rows = state_lines
+        return [] unless rows.one?
+
+        values = rows.first.split(",", -1).map(&:strip)
+        return [] if values.any?(&:empty?)
+
+        values
+      end
+
     end
 
   end

data/lib/whois/parsers/whois.tld.mu.rb

@@ -0,0 +1,20 @@
+require_relative 'base_icann_compliant'
+
+module Whois
+  class Parsers
+    # Parser for the IANA-listed .mu WHOIS server, whois.tld.mu.
+    #
+    # Captures from 2026-09-25 expose ICANN-style records and the exact
+    # `Domain not found.` absence marker. This host is distinct from the
+    # legacy whois.nic.mu mapping in whois 6.0.3.
+    class WhoisTldMu < BaseIcannCompliant
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: /^[ \t]*Domain not found\.[ \t]*$/i,
+      }
+
+      property_supported :expires_on do
+        node("Registry Expiry Date") { |value| parse_time(value) }
+      end
+    end
+  end
+end

data/lib/whois/parsers/whois.tonicregistry.to.rb

@@ -4,9 +4,63 @@ module Whois
   class Parsers
     # Parser for the whois.tonicregistry.to server.
     class WhoisTonicregistryTo < BaseIcannCompliant
+      AVAILABLE_DOMAIN_LINE = /^>>> Domain (?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+to is available for registration$/i
+      DOMAIN_PATTERN = /\A(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+to\z/i
+      REGISTRATION_FIELD = /^[ \t]*(?:Domain Name|Registry Domain ID|Updated Date|Creation Date|Registry Expiry Date|Registrar(?: URL| IANA ID| Abuse Contact (?:Email|Phone))?|Domain Status|Name Server|DNSSEC):[ \t]*\S/i
+
       self.scanner = Scanners::BaseIcannCompliant, {
-        pattern_available: /^>>> Domain .+ is available for registration\n/,
+        pattern_available: AVAILABLE_DOMAIN_LINE,
       }
+
+      property_supported :status do
+        if available_marker_count == 1
+          :available
+        elsif registered_record?
+          :registered
+        else
+          :unknown
+        end
+      end
+
+      property_supported :available? do
+        status == :available
+      end
+
+      property_supported :registered? do
+        status == :registered
+      end
+
+      def response_unavailable?
+        super || ambiguous_availability_response?
+      end
+
+      private
+
+      def available_marker_count
+        content_for_scanner.lines.count { |line| line.match?(AVAILABLE_DOMAIN_LINE) }
+      end
+
+      def ambiguous_availability_response?
+        marker_count = available_marker_count
+        marker_count.positive? && (
+          marker_count != 1 || content_for_scanner.match?(REGISTRATION_FIELD)
+        )
+      end
+
+      def registered_record?
+        response = content_for_scanner
+        domains = response.scan(/^[ \t]*Domain Name:[ \t]*(.*?)[ \t]*$/i).flatten
+        registry_ids = response.scan(/^[ \t]*Registry Domain ID:[ \t]*(.*?)[ \t]*$/i).flatten
+        creation_dates = response.scan(/^[ \t]*Creation Date:[ \t]*(.*?)[ \t]*$/i).flatten
+        registrars = response.scan(/^[ \t]*Registrar:[ \t]*(.*?)[ \t]*$/i).flatten
+        nameservers = response.scan(/^[ \t]*Name Server:[ \t]*(.*?)[ \t]*$/i).flatten
+
+        domains.one? && domains.first.match?(DOMAIN_PATTERN) &&
+          registry_ids.one? && !registry_ids.first.empty? &&
+          creation_dates.one? && parse_time(creation_dates.first) &&
+          registrars.one? && !registrars.first.empty? &&
+          nameservers.any? { |nameserver| !nameserver.empty? }
+      end
     end
   end
 end

data/lib/whois/parsers/whois.uniregistry.net.rb

@@ -19,8 +19,11 @@ module Whois
     #   The Example parser for the list of all available methods.
     #
     class WhoisUniregistryNet < BaseIcannCompliant
+      AVAILABLE_DOMAIN_LINE = /^>>> Domain (?:"[^"\r\n]+"|[^\s\r\n]+) is available for registration[ \t]*$/
+      RECORD_EVIDENCE = /^[ \t]*(?:Domain Name|Domain ID|Registry Domain ID|Creation Date|Registrar|Sponsoring Registrar|Name Server):[ \t]*\S/i
+
       self.scanner = Scanners::BaseIcannCompliant, {
-          pattern_available: />>> Domain ".+" is available/,
+          pattern_available: AVAILABLE_DOMAIN_LINE,
       }
 
 
@@ -52,12 +55,22 @@ module Whois
       def response_unavailable?
         super || content_for_scanner.match?(
           /^(?:>>> Tld not supported by this registry interface|TLD is not supported\.)$/i
-        )
+        ) || ambiguous_availability_response?
       end
 
 
       private
 
+      def ambiguous_availability_response?
+        marker_count = content_for_scanner.lines.count do |line|
+          line.match?(AVAILABLE_DOMAIN_LINE)
+        end
+
+        marker_count.positive? && (
+          marker_count != 1 || content_for_scanner.match?(RECORD_EVIDENCE)
+        )
+      end
+
       def build_contact(element, type)
         if (contact = super)
           contact.id = node("#{element} ID")

data/lib/whois/parsers/whois.weare.ie.rb

@@ -0,0 +1,12 @@
+require_relative 'base_icann_compliant'
+
+module Whois
+  class Parsers
+    # Parser for the current IANA-listed .IE WHOIS host, whois.weare.ie.
+    class WhoisWeareIe < BaseIcannCompliant
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: /^Not found: [a-z0-9-]+\.ie\s*$/i,
+      }
+    end
+  end
+end