whois-parser-next 0.1.0

data/lib/whois/parsers/whois.dns.hr.rb

@@ -0,0 +1,119 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require_relative 'base'
+require 'whois/scanners/whois.dns.hr.rb'
+
+
+module Whois
+  class Parsers
+
+    # Parser for the whois.dns.hr server.
+    #
+    # @see Whois::Parsers::Example
+    #   The Example parser for the list of all available methods.
+    #
+    class WhoisDnsHr < Base
+      include Scanners::Scannable
+
+      self.scanner = Scanners::WhoisDnsHr
+
+
+      property_not_supported :disclaimer
+
+
+      property_supported :domain do
+        node("Domain Name") || node("domain")
+      end
+
+      property_not_supported :domain_id
+
+
+      property_supported :status do
+        if available?
+          :available
+        elsif node("Domain Name") || node("domain")
+          :registered
+        else
+          :unknown
+        end
+      end
+
+      property_supported :available? do
+        !!node("status:available")
+      end
+
+      property_supported :registered? do
+        status == :registered
+      end
+
+
+      property_not_supported :created_on
+
+      property_not_supported :updated_on
+
+      property_supported :expires_on do
+        node("Registrar Registration Expiration Date") { |value| parse_time(value) } ||
+          node("expires") { |value| parse_time(value) }
+      end
+
+
+      property_not_supported :registrar
+
+
+      property_supported :registrant_contacts do
+        if node("descr")
+          node("descr") do |array|
+            _, zip, city = array[2].match(/([\d\s]+) (.+)/).to_a
+            Parser::Contact.new(
+              :type         => Parser::Contact::TYPE_REGISTRANT,
+              :id           => nil,
+              :name         => array[0],
+              :organization => nil,
+              :address      => array[1],
+              :city         => city,
+              :zip          => zip,
+              :state        => nil,
+              :country      => nil,
+              :phone        => nil,
+              :fax          => nil,
+              :email        => nil
+            )
+          end
+        elsif node("Registrant Name")
+          Parser::Contact.new(
+            type: Parser::Contact::TYPE_REGISTRANT,
+            name: node("Registrant Name"),
+            address: node("Registrant Street"),
+            city: node("Registrant City"),
+            zip: node("Registrant Postal Code"),
+            country_code: node("Registrant Country"),
+            email: node("Registrant Email")
+          )
+        end
+      end
+
+      property_not_supported :admin_contacts
+
+      property_not_supported :technical_contacts
+
+
+      property_not_supported :nameservers
+
+      def response_unavailable?
+        body = content_for_scanner
+        !body.match?(/^%ERROR:\s*no entries found\s*$/i) &&
+          !body.match?(/^Domain Name:\s+\S+/i) &&
+          !body.match?(/^domain:\s+\S+/i)
+      end
+
+    end
+
+  end
+end

data/lib/whois/parsers/whois.dns.lu.rb

@@ -0,0 +1,125 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require_relative 'base'
+require_relative 'registry_response_safety'
+
+
+module Whois
+  class Parsers
+
+    # Parser for the whois.dns.lu server.
+    #
+    # @note This parser is just a stub and provides only a few basic methods
+    #   to check for domain availability and get domain status.
+    #   Please consider to contribute implementing missing methods.
+    #
+    # @see Whois::Parsers::Example
+    #   The Example parser for the list of all available methods.
+    #
+    class WhoisDnsLu < Base
+      include RegistryResponseSafety
+
+      property_supported :status do
+        if content_for_scanner.match?(/domaintype:\s+active\s*$/i)
+          :registered
+        elsif available?
+          :available
+        else
+          Whois::Parser.bug!(ParserError, "Unable to parse .lu response status.")
+        end
+      end
+
+      property_supported :available? do
+        !!(content_for_scanner =~ /% No such domain/)
+      end
+
+      property_supported :registered? do
+        status == :registered
+      end
+
+
+      property_supported :created_on do
+        if content_for_scanner =~ /registered:\s+(.*)\n/
+          # Force the parser to use the dd/mm/yyyy format.
+          Time.utc(*::Regexp.last_match(1).split("/").reverse)
+        end
+      end
+
+      property_not_supported :updated_on
+
+      property_not_supported :expires_on
+
+
+      property_supported :registrar do
+        if name = value_for_key('registrar-name')
+          Parser::Registrar.new(
+              name:         name,
+              url:          value_for_key('registrar-url')
+          )
+        end
+      end
+
+      property_supported :registrant_contacts do
+        build_contact('org', Parser::Contact::TYPE_REGISTRANT)
+      end
+
+      property_supported :admin_contacts do
+        build_contact('adm', Parser::Contact::TYPE_ADMINISTRATIVE)
+      end
+
+      property_supported :technical_contacts do
+        build_contact('tec', Parser::Contact::TYPE_TECHNICAL)
+      end
+
+
+      property_supported :nameservers do
+        values_for_key('nserver').map do |line|
+          if line =~ /(.+) \[(.+)\]/
+            Parser::Nameserver.new(name: ::Regexp.last_match(1), ipv4: ::Regexp.last_match(2))
+          else
+            Parser::Nameserver.new(name: line)
+          end
+        end
+      end
+
+
+      private
+
+      def build_contact(element, type)
+        return unless (name = value_for_key(format("%s-name", element)))
+
+        Parser::Contact.new(
+            type:         type,
+            id:           nil,
+            name:         name,
+            address:      value_for_key(format("%s-address", element)),
+            city:         value_for_key(format("%s-city", element)),
+            zip:          value_for_key(format("%s-zipcode", element)),
+            country_code: value_for_key(format("%s-country", element)),
+            email:        value_for_key(format("%s-email", element))
+        )
+      end
+
+      def value_for_key(key)
+        values = values_for_key(key)
+        if values.size > 1
+          values.join(', ')
+        else
+          values.first
+        end
+      end
+
+      def values_for_key(key)
+        content_for_scanner.scan(/#{key}:\s+(.+)\n/).flatten
+      end
+
+    end
+  end
+end

data/lib/whois/parsers/whois.dns.pl.rb

@@ -0,0 +1,151 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require_relative 'base'
+
+
+module Whois
+  class Parsers
+
+    # Parser for the whois.dns.pl server.
+    #
+    # @see Whois::Parsers::Example
+    #   The Example parser for the list of all available methods.
+    #
+    class WhoisDnsPl < Base
+
+      property_supported :domain do
+        if content_for_scanner =~ /DOMAIN NAME:\s+(.+)\n/
+          ::Regexp.last_match(1)
+        end
+      end
+
+      property_not_supported :domain_id
+
+
+      property_supported :status do
+        if available?
+          :available
+        else
+          :registered
+        end
+      end
+
+      property_supported :available? do
+        !!(content_for_scanner =~ /^No information available about domain name/)
+      end
+
+      property_supported :registered? do
+        !available?
+      end
+
+
+      property_supported :created_on do
+        if content_for_scanner =~ /created:\s+(.+?)\n/
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+      property_supported :updated_on do
+        if content_for_scanner =~ /last modified:\s+(.+?)\n/
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+      property_supported :expires_on do
+        if content_for_scanner =~ /renewal date:\s+(.+?)\n/ && ::Regexp.last_match(1) != "not defined"
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+
+      property_supported :registrar do
+        match = content_for_scanner.slice(/REGISTRAR:\n((.+\n)+)\n/, 1)
+        return unless match
+
+        lines = match.split("\n")
+        Parser::Registrar.new(
+          :name => lines[0]
+        )
+      end
+
+      property_not_supported :registrant_contacts
+
+      property_not_supported :admin_contacts
+
+      property_supported :technical_contacts do
+        build_contact("TECHNICAL CONTACT", Parser::Contact::TYPE_TECHNICAL)
+      end
+
+
+      property_supported :nameservers do
+        content_for_scanner.scan(/nameservers:\s+(.+)\n(.+)\n/).flatten.map do |line|
+          line.strip!
+          if line =~ /(.+) \[(.+)\]/
+            Parser::Nameserver.new(:name => ::Regexp.last_match(1).chomp("."), :ipv4 => ::Regexp.last_match(2))
+          else
+            Parser::Nameserver.new(:name => line.chomp("."))
+          end
+        end
+      end
+
+      # Checks whether the response has been throttled.
+      #
+      # @return [Boolean]
+      #
+      # @example
+      #   Looup quota exceeded.
+      #
+      def response_throttled?
+        !!(content_for_scanner =~ /^request limit exceeded for/)
+      end
+
+
+      private
+
+      def build_contact(element, type)
+        match = content_for_scanner.slice(/#{element}:\n((.+\n)+)\n/, 1)
+        return unless match
+
+        values = parse_contact_block(match.split("\n"))
+        zip, city = values["city"].match(/(.+?) (.+)/)[1..2]
+
+        Parser::Contact.new(
+          :type         => type,
+          :id           => values["handle"],
+          :name         => nil,
+          :organization => values["company"],
+          :address      => values["street"],
+          :city         => city,
+          :zip          => zip,
+          :state        => nil,
+          :country_code => values["location"],
+          :phone        => values["phone"],
+          :fax          => values["fax"],
+          :email        => nil
+        )
+      end
+
+      def parse_contact_block(lines)
+        key  = nil
+        hash = {}
+        lines.each do |line|
+          if line =~ /(.+):(.+)/
+            hash[key = ::Regexp.last_match(1)] = ::Regexp.last_match(2).strip
+          else
+            hash[key] += "\n#{line.strip}"
+          end
+        end
+        hash
+      end
+
+    end
+
+  end
+end

data/lib/whois/parsers/whois.dns.pt.rb

@@ -0,0 +1,92 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require_relative 'base'
+
+
+module Whois
+  class Parsers
+
+    # Parser for the whois.dns.pt server.
+    #
+    # @note This parser is just a stub and provides only a few basic methods
+    #   to check for domain availability and get domain status.
+    #   Please consider to contribute implementing missing methods.
+    #
+    # @see Whois::Parsers::Example
+    #   The Example parser for the list of all available methods.
+    #
+    class WhoisDnsPt < Base
+
+      property_supported :status do
+        if content_for_scanner =~ %r{^(?:Estado / Status|Domain Status):\s+(.+)$}i
+          case ::Regexp.last_match(1).downcase
+          when "active", "registered"
+            :registered
+          when "reserved"
+            :reserved
+          when "tech-pro"
+            :inactive
+          else
+            Whois::Parser.bug!(ParserError, "Unknown status `#{::Regexp.last_match(1)}'.")
+          end
+        else
+          :available
+        end
+      end
+
+      property_supported :available? do
+        !!(content_for_scanner =~ /^.* no match\s*$/i)
+      end
+
+      property_supported :registered? do
+        !available?
+      end
+
+
+      property_supported :created_on do
+        if content_for_scanner =~ / Creation Date .+?:\s+(.+)\n/
+          parse_pt_date(::Regexp.last_match(1))
+        elsif content_for_scanner =~ /^Creation Date:\s+(.+)$/i
+          parse_pt_date(::Regexp.last_match(1))
+        end
+      end
+
+      property_not_supported :updated_on
+
+      property_supported :expires_on do
+        if content_for_scanner =~ / Expiration Date .+?:\s+(.+)\n/
+          parse_pt_date(::Regexp.last_match(1))
+        elsif content_for_scanner =~ /^Expiration Date:\s+(.+)$/i
+          parse_pt_date(::Regexp.last_match(1))
+        end
+      end
+
+
+      property_supported :nameservers do
+        names = content_for_scanner.scan(/^\s*Name Server:\s+([^\s|]+)/i).flatten
+        names = content_for_scanner.scan(/Nameserver:\s+(?:.*)\s+NS\s+(.+?)\.\n/).flatten if names.empty?
+        names.map do |name|
+          Parser::Nameserver.new(:name => name)
+        end
+      end
+
+      private
+
+      def parse_pt_date(value)
+        date, time = value.strip.split(/\s+/, 2)
+        day, month, year = date.split("/").map(&:to_i)
+        hour, minute, second = (time || "00:00:00").split(":").map(&:to_i)
+        Time.utc(year, month, day, hour, minute, second)
+      end
+
+    end
+
+  end
+end

data/lib/whois/parsers/whois.domain-registry.nl.rb

@@ -0,0 +1,133 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require_relative 'base'
+
+
+module Whois
+  class Parsers
+
+    # Parser for the whois.domain-registry.nl server.
+    #
+    # @note This parser is just a stub and provides only a few basic methods
+    #   to check for domain availability and get domain status.
+    #   Please consider to contribute implementing missing methods.
+    #
+    # @see Whois::Parsers::Example
+    #   The Example parser for the list of all available methods.
+    #
+    class WhoisDomainRegistryNl < Base
+
+      property_supported :domain do
+        content_for_scanner.slice(/Domain name:\s+(.+?)\n/i, 1)
+      end
+
+      # == Values for Status
+      #
+      # - free: the .nl domain name is still available for registration
+      # - withdrawn: the .nl domain name is barred from registration
+      # - excluded: the .nl domain name is excluded from registration
+      # - requested: an application for the .nl domain name is being processed
+      # - active: the .nl domain name has already been registered. (If you want to know who has registered the name, tick the ‘Extended search’ box. You will then be shown more information about whoever has registered the name.)
+      # - inactive: the .nl domain name has already been registered, but has not yet been added to the .nl zone file. (If you want to know who has registered the name, tick the ‘Extended search’ box. You will then be shown more information about whoever has registered the name.)
+      # - in quarantine: this .nl domain name's registration has been cancelled. Following cancellation, a domain name is placed in quarantine for forty days.
+      #
+      # @see https://www.sidn.nl/en/whois/
+      # @see https://www.sidn.nl/en/about-nl/whois/looking-up-a-domain-name/
+      #
+      property_supported :status do
+        if content_for_scanner =~ /Status:\s+(.+?)\n/i
+          case ::Regexp.last_match(1).downcase
+          when "free"
+            :available
+          when "withdrawn", "excluded"
+            :reserved
+          when "requested"
+            :registered
+          when "active"
+            :registered
+          when "in quarantine"
+            :redemption
+          when "inactive"
+            :inactive
+          else
+            Whois::Parser.bug!(ParserError, "Unknown status `#{::Regexp.last_match(1)}'.")
+          end
+        else
+          :available
+        end
+      end
+
+      property_supported :available? do
+        status == :available
+      end
+
+      property_supported :registered? do
+        status != :available
+      end
+
+
+      property_supported :created_on do
+        if content_for_scanner =~ /(?:Date registered|Creation Date):\s+(.+)\n/i
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+      property_supported :updated_on do
+        if content_for_scanner =~ /(?:Record last updated|Updated Date):\s+(.+)\n/i
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+      property_not_supported :expires_on
+
+
+      property_supported :nameservers do
+        if content_for_scanner =~ /Domain nameservers:\n((.+\n)+)\n/
+          ::Regexp.last_match(1).split("\n").map do |line|
+            name, ipv4 = line.strip.split(/\s+/)
+            Parser::Nameserver.new(:name => name, :ipv4 => ipv4)
+          end
+        end
+      end
+
+
+      # Checks whether the response has been throttled.
+      #
+      # @return [Boolean]
+      #
+      # @example
+      #   whois.domain-registry.nl: only 1 request per second allowed, try again later
+      #
+      # @example
+      #   whois.domain-registry.nl: daily whois-limit exceeded
+      #
+      def response_throttled?
+        case content_for_scanner
+        when /^#{Regexp.escape('whois.domain-registry.nl: only 1 request per second allowed, try again later')}/
+          true
+        when /^#{Regexp.escape('whois.domain-registry.nl: daily whois-limit exceeded')}/
+          true
+        else
+          false
+        end
+      end
+
+      # Checks whether this response contains a message
+      # that can be reconducted to a "WHOIS Server Unavailable" status.
+      #
+      # @return [Boolean]
+      def response_unavailable?
+        !!(content_for_scanner =~ /Server too busy, try again later/)
+      end
+
+    end
+
+  end
+end