whois-parser-next 0.1.0

data/lib/whois/parsers/whois.yoursrs.com.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 'whois/scanners/whois.yoursrs.com'
+
+
+module Whois
+  class Parsers
+
+    # Parser for the whois.yoursrs.com server.
+    #
+    # @see Whois::Parsers::Example
+    #   The Example parser for the list of all available methods.
+    #
+    class WhoisYoursrsCom < Base
+      include Scanners::Scannable
+
+      self.scanner = Scanners::WhoisYoursrsCom
+
+
+      property_supported :domain do
+        node("Domain Name", &:downcase)
+      end
+
+      property_not_supported :domain_id
+
+
+      property_supported :status do
+        Array.wrap(node("Status"))
+      end
+
+      property_supported :available? do
+        !!node("status:available")
+      end
+
+      property_supported :registered? do
+        !available?
+      end
+
+
+      property_supported :created_on do
+        node("Created On") do |value|
+          parse_time(value)
+        end
+      end
+
+      property_supported :updated_on do
+        node("Last Updated On") do |value|
+          parse_time(value)
+        end
+      end
+
+      property_supported :expires_on do
+        node("Expiration Date") do |value|
+          parse_time(value)
+        end
+      end
+
+
+      property_supported :registrar do
+        node("Sponsoring Registrar") do |value|
+          Parser::Registrar.new(
+              name: value
+          )
+        end
+      end
+
+
+      property_supported :registrant_contacts do
+        build_contact("Registrant", Parser::Contact::TYPE_REGISTRANT)
+      end
+
+      property_supported :admin_contacts do
+        build_contact("ADMIN", Parser::Contact::TYPE_ADMINISTRATIVE)
+      end
+
+      property_supported :technical_contacts do
+        build_contact("TECH", Parser::Contact::TYPE_TECHNICAL)
+      end
+
+
+      property_supported :nameservers do
+        Array.wrap(node("Name Server")).reject(&:empty?).map do |name|
+          Parser::Nameserver.new(name: name.downcase)
+        end
+      end
+
+
+      private
+
+      def build_contact(element, type)
+        node("#{element} ID") do
+          address = (1..3)
+                    .map { |i| node("#{element} Street#{i}") }
+                    .delete_if { |i| i.nil? || i.empty? }
+                    .join("\n")
+
+          Parser::Contact.new(
+              type:         type,
+              id:           node("#{element} ID"),
+              name:         node("#{element} Name"),
+              organization: node("#{element} Organization"),
+              address:      address,
+              city:         node("#{element} City"),
+              zip:          node("#{element} Postal Code"),
+              state:        node("#{element} State"),
+              country_code: node("#{element} Country"),
+              phone:        node("#{element} Phone"),
+              fax:          node("#{element} Fax"),
+              email:        node("#{element} Email")
+          )
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,72 @@
+#--
+# 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
+
+    #
+    # = whois.za.net parser
+    #
+    # Parser for the whois.za.net 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 WhoisNicIt parser for an explanation of all available methods
+    # and examples.
+    #
+    class WhoisZaNet < Base
+
+      property_supported :status do
+        if available?
+          :available
+        else
+          :registered
+        end
+      end
+
+      property_supported :available? do
+        !!(content_for_scanner =~ /No such domain:/)
+      end
+
+      property_supported :registered? do
+        !available?
+      end
+
+
+      property_supported :created_on do
+        if content_for_scanner =~ /Record Created\s+:\s+(.*)\n/
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+      property_supported :updated_on do
+        if content_for_scanner =~ /Record Last Updated\s+:\s+(.*)\n/
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+      property_not_supported :expires_on
+
+
+      property_supported :nameservers do
+        if content_for_scanner =~ /Domain Name Servers listed in order:\n\n((.+\n)+)\n/
+          ::Regexp.last_match(1).split("\n").reject { |value| value.strip.empty? }.map do |name|
+            Parser::Nameserver.new(:name => name.strip)
+          end
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,72 @@
+#--
+# 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
+
+    #
+    # = whois.za.org parser
+    #
+    # Parser for the whois.za.org 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 WhoisNicIt parser for an explanation of all available methods
+    # and examples.
+    #
+    class WhoisZaOrg < Base
+
+      property_supported :status do
+        if available?
+          :available
+        else
+          :registered
+        end
+      end
+
+      property_supported :available? do
+        !!(content_for_scanner =~ /No such domain:/)
+      end
+
+      property_supported :registered? do
+        !available?
+      end
+
+
+      property_supported :created_on do
+        if content_for_scanner =~ /Record Created\s+:\s+(.*)\n/
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+      property_supported :updated_on do
+        if content_for_scanner =~ /Record Last Updated\s+:\s+(.*)\n/
+          parse_time(::Regexp.last_match(1))
+        end
+      end
+
+      property_not_supported :expires_on
+
+
+      property_supported :nameservers do
+        if content_for_scanner =~ /Domain Name Servers listed in order:\n\n((.+\n)+)\n/
+          ::Regexp.last_match(1).split("\n").reject { |value| value.strip.empty? }.map do |name|
+            Parser::Nameserver.new(:name => name.strip)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/whois/parsers/whois.zicta.zm.rb

@@ -0,0 +1,13 @@
+require_relative 'base_icann_compliant'
+
+module Whois
+  class Parsers
+    # ZICTA's current endpoint uses ICANN key/value fields and the CoCCA-style
+    # no-object marker for an absent name.
+    class WhoisZictaZm < BaseIcannCompliant
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: /^The queried object does not exist: No Object Found\s*$/i,
+      }
+    end
+  end
+end

data/lib/whois/parsers/whois1.nic.bi.rb

@@ -0,0 +1,25 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require_relative 'base_cocca2'
+
+
+module Whois
+  class Parsers
+
+    # Parser for the whois1.nic.bi server.
+    #
+    # @see Whois::Parsers::Example
+    #   The Example parser for the list of all available methods.
+    #
+    class Whois1NicBi < BaseCocca2
+    end
+
+  end
+end

data/lib/whois/parsers/za_central_registry.rb

@@ -0,0 +1,80 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require_relative 'base_icann_compliant'
+
+
+module Whois
+  class Parsers
+
+    # Parser for the ZA Central Registry servers.
+    #
+    class ZaCentralRegistry < BaseIcannCompliant
+
+      property_supported :domain_id do
+        node('Domain ID')
+      end
+
+      property_supported :expires_on do
+        node('Registry Expiry Date') do |value|
+          parse_time(value)
+        end
+      end
+
+      property_supported :registrar do
+        return unless node("Sponsoring Registrar")
+
+        Parser::Registrar.new(
+            id:           node('Sponsoring Registrar IANA ID'),
+            name:         node('Sponsoring Registrar'),
+            organization: node('Sponsoring Registrar')
+        )
+      end
+
+      property_supported :available? do
+        !node("Creation Date")
+      end
+
+      # Checks whether the response has been throttled.
+      #
+      # @return [Boolean]
+      #
+      # @example
+      #   Please go away for 13 Seconds
+      #
+      def response_throttled?
+        !!(content_for_scanner =~ /Please go away for \d+ [Ss]econds/)
+      end
+
+
+      private
+
+      def build_contact(element, type)
+        node("#{element} Name") do
+          Parser::Contact.new(
+              type:         type,
+              id:           node("#{element} ID").presence,
+              name:         value_for_property(element, 'Name'),
+              organization: value_for_property(element, 'Organization'),
+              address:      value_for_property(element, 'Street'),
+              city:         value_for_property(element, 'City'),
+              zip:          value_for_property(element, 'Postal Code'),
+              state:        value_for_property(element, 'State/Province'),
+              country_code: value_for_property(element, 'Country'),
+              phone:        value_for_phone_property(element, 'Phone'),
+              fax:          value_for_phone_property(element, 'Fax'),
+              email:        value_for_property(element, 'Email')
+          )
+        end
+      end
+
+    end
+
+  end
+end

data/lib/whois/parsers.rb

@@ -0,0 +1 @@
+require_relative 'parsers/base'

data/lib/whois/safe_record.rb

@@ -0,0 +1,170 @@
+require_relative 'parser'
+
+module Whois
+  class SafeRecord < BasicObject
+
+    # @api private
+    def self.define_property_method(method)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, &block)
+          if property_any_supported?(:#{method})
+            parser.#{method}(*args, &block)
+          end
+        end
+      RUBY
+    end
+
+    # @api private
+    def self.define_method_method(method)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, &block)
+          if parser.respond_to?(:#{method})
+            parser.#{method}(*args, &block)
+          end
+        end
+      RUBY
+    end
+
+    # @api private
+    def self.define_question_method(method)
+      return if method.to_s.end_with?("?")
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}?
+          !#{method}.nil?
+        end
+      RUBY
+    end
+
+    Parser::PROPERTIES.each do |method|
+      define_property_method(method)
+    end
+
+    Parser::METHODS.each do |method|
+      define_method_method(method)
+    end
+
+    (Parser::PROPERTIES + Parser::METHODS).each do |method|
+      define_question_method(method)
+    end
+
+
+    attr_reader :record
+
+    def initialize(record)
+      @record = record
+    end
+
+    alias target record
+
+
+    # Checks if this class respond to given method.
+    #
+    # Overrides the default implementation to add support
+    # for {Whois::Parser::PROPERTIES} and {Whois::Parser::METHODS}.
+    #
+    # @return [Boolean]
+    #
+    def respond_to?(*args)
+      respond_to_parser_method?(args.first) || target.respond_to?(*args)
+    end
+
+
+    # Lazy-loads and returns the parser proxy for current record.
+    #
+    # @return [Whois::Parser]
+    def parser
+      @parser ||= Parser.new(record)
+    end
+
+    # Returns a Hash containing all supported properties for this record
+    # along with corresponding values.
+    #
+    # @return [{ Symbol => Object }]
+    def properties
+      hash = {}
+      Parser::PROPERTIES.each do |property|
+        hash[property] = __send__(property)
+      end
+      hash
+    end
+
+    # Shortcut for <tt>#registrant_contacts.first</tt>.
+    #
+    # @see Whois::Parser#registrant_contacts
+    #
+    # @return [Whois::Parser::Contact]
+    #         If the property is supported and a contact exists.
+    # @return [nil]
+    #         If the property is not supported or the contact doesn't exist.
+    def registrant_contact
+      if property_any_supported?(:registrant_contacts)
+        registrant_contacts.first
+      end
+    end
+
+    # Shortcut for <tt>#admin_contacts.first</tt>.
+    #
+    # @see Whois::Parser#admin_contacts
+    #
+    # @return [Whois::Parser::Contact]
+    #         If the property is supported and a contact exists.
+    # @return [nil]
+    #         If the property is not supported or the contact doesn't exist.
+    def admin_contact
+      if property_any_supported?(:admin_contacts)
+        admin_contacts.first
+      end
+    end
+
+    # Shortcut for <tt>#technical_contacts.first</tt>.
+    #
+    # @see Whois::Parser#technical_contacts
+    #
+    # @return [Whois::Parser::Contact]
+    #         If the property is supported and a contact exists.
+    # @return [nil]
+    #         If the property is not supported or the contact doesn't exist.
+    def technical_contact
+      if property_any_supported?(:technical_contacts)
+        technical_contacts.first
+      end
+    end
+
+    # Collects and returns all the contacts.
+    #
+    # @see Whois::Parser#contacts
+    #
+    # @return [Array<Whois::Parser::Contact>]
+    def contacts
+      parser.contacts
+    end
+
+
+    private
+
+    # @api private
+    def respond_to_parser_method?(symbol)
+      name = symbol.to_s =~ /\?$/ ? symbol.to_s[0..-2] : symbol
+      Parser::PROPERTIES.include?(name.to_sym) || Parser::METHODS.include?(name.to_sym)
+    end
+
+    # Checks if the property passed as symbol
+    # is supported in any of the parsers.
+    #
+    # @api private
+    # @see Whois::Parser::Parser#property_any_supported?
+    #
+    # @param  [Symbol] property The name of the property to check.
+    # @return [Boolean]
+    def property_any_supported?(property)
+      parser.property_any_supported?(property)
+    end
+
+    # Delegates any missing method to Record.
+    def method_missing(method, *args, &block)
+      target.send(method, *args, &block)
+    end
+
+  end
+end

data/lib/whois/scanners/base.rb

@@ -0,0 +1,114 @@
+module Whois
+  module Scanners
+
+    class Base
+
+      class_attribute :tokenizers
+      self.tokenizers = []
+
+      def self.tokenizer(name, &block)
+        define_method(name, &block)
+      end
+
+
+      attr_reader :settings
+
+      def initialize(settings = nil)
+        @settings = settings || {}
+      end
+
+      def parse(content)
+        # The temporary store.
+        # Scanners may use this to store pointers, states or other flags.
+        @tmp = {}
+
+        # A super-simple AST store.
+        @ast = {}
+
+        @input = StringScanner.new(content)
+        tokenize until @input.eos?
+
+        @ast
+      end
+
+
+      tokenizer :skip_empty_line do
+        @input.skip(/^\n/)
+      end
+
+      tokenizer :skip_blank_line do
+        @input.skip(/^\s*\n/)
+      end
+
+      tokenizer :skip_newline do
+        @input.skip(/\n/)
+      end
+
+      # Scan a key/value pair and stores the result in the current target.
+      #  target is the global @ast if no '_section' is set, else '_section' is used.
+      tokenizer :scan_keyvalue do
+        if @input.scan(/(.+?):(.*?)(\n|\z)/)
+          key, value = @input[1].strip, @input[2].strip
+          target = @tmp['_section'] ? (@ast[@tmp['_section']] ||= {}) : @ast
+
+          if target[key].nil?
+            target[key] = value
+          else
+            target[key] = Array.wrap(target[key])
+            target[key] << value
+          end
+        end
+      end
+
+      protected
+
+      def _scan_lines_to_array(pattern)
+        results = []
+        while @input.scan(pattern)
+          @input[1].strip
+          results << @input[1].strip
+        end
+        results
+      end
+
+      def _scan_lines_to_hash(pattern)
+        results = {}
+        results.merge! @input[1].strip => @input[2].strip while @input.scan(pattern)
+        results
+      end
+
+      def _scan_keyvalues(pattern)
+        results = []
+        while @input.scan(/(.+?):(.*?)\n/)
+          key, value = @input[1].strip, @input[2].strip
+          if results[key].nil?
+            results[key] = value
+          else
+            results[key] = Array.wrap(results[key])
+            results[key] << value
+          end
+        end
+      end
+
+
+      private
+
+      def tokenize
+        tokenizers.each do |tokenizer|
+          return if send(tokenizer)
+        end
+        unexpected_token
+      end
+
+      def unexpected_token
+        error!("Unexpected token")
+      end
+
+      def error!(message)
+        raise ParserError, "#{message}: #{@input.peek(@input.string.length)}"
+      end
+
+    end
+
+  end
+end