whois-parser 0.0.1 → 1.0.0.pre.beta1

data/lib/whois/safe_record.rb

@@ -0,0 +1,169 @@
+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_method :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,116 @@
+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 = {}
+        while @input.scan(pattern)
+          results.merge! @input[1].strip => @input[2].strip
+        end
+        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

data/lib/whois/scanners/base_afilias.rb

@@ -0,0 +1,51 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    # Scanner for the Afilias-based records.
+    class BaseAfilias < Base
+
+      self.tokenizers += [
+          :skip_empty_line,
+          :scan_available,
+          :scan_reserved,
+          :scan_throttled,
+          :scan_disclaimer,
+          :scan_keyvalue,
+      ]
+
+
+      tokenizer :scan_available do
+        if @input.scan(/^NOT FOUND\n/)
+          @ast["status:available"] = true
+        end
+      end
+
+      tokenizer :scan_reserved do
+        if settings[:pattern_reserved] && @input.scan(settings[:pattern_reserved])
+          @ast["status:reserved"] = true
+        end
+      end
+
+      # .ORG
+      tokenizer :scan_throttled do
+        if @input.match?(/^WHOIS LIMIT EXCEEDED/)
+          @ast["response:throttled"] = true
+          @input.skip(/^.+\n/)
+        end
+      end
+
+      tokenizer :scan_disclaimer do
+        if settings[:pattern_disclaimer]
+          if @input.match?(settings[:pattern_disclaimer])
+            @ast["field:disclaimer"] = _scan_lines_to_array(/^(.+)\n/).join(" ")
+          end
+        elsif @input.pos == 0 && @input.match?(/^(.+\n){3,}\n/)
+          @ast["field:disclaimer"] = _scan_lines_to_array(/^(.+)\n/).join(" ")
+        end
+      end
+    end
+
+  end
+end

data/lib/whois/scanners/base_cocca2.rb

@@ -0,0 +1,43 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    class BaseCocca2 < Base
+
+      self.tokenizers += [
+          :skip_empty_line,
+          :scan_disclaimer,
+          :skip_lastupdate,
+          :skip_token_additionalsection,
+          :scan_keyvalue,
+      ]
+
+
+      DISCLAIMER_MATCHES = [
+        "TERMS OF USE:", # global
+        "Terminos de Uso:", # whois.nic.hn
+        "The data in the WHOIS database of Meridian", # whois.meridiantld.net
+        "This information is provided", # whois.gg
+      ]
+
+      tokenizer :scan_disclaimer do
+        if @input.match?(/^#{DISCLAIMER_MATCHES.join("|")}/)
+          @ast["field:disclaimer"] = @input.scan_until(/>>>/) ||
+                                     # special handler for whois.nic.cx exception
+                                     @input.scan_until(/\Z/)
+        end
+      end
+
+      tokenizer :skip_lastupdate do
+        @input.skip(/>>>(.+?)<<<\n/)
+      end
+
+      tokenizer :skip_token_additionalsection do
+        @input.skip(/Additional Section\n/)
+      end
+
+    end
+
+  end
+end

data/lib/whois/scanners/base_icann_compliant.rb

@@ -0,0 +1,45 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    # Scanner for the Icann Compliant-based records.
+    class BaseIcannCompliant < Base
+
+      self.tokenizers += [
+          :skip_head,
+          :scan_available,
+          :scan_throttled,
+          :skip_empty_line,
+          :skip_blank_line,
+          :scan_keyvalue,
+          :skip_end,
+      ]
+
+      tokenizer :scan_available do
+        if settings[:pattern_available] && @input.skip_until(settings[:pattern_available])
+          @ast['status:available'] = true
+        end
+      end
+
+      tokenizer :scan_throttled do
+        if settings[:pattern_throttled] && @input.skip_until(settings[:pattern_throttled])
+          @ast['response:throttled'] = true
+        end
+      end
+
+      tokenizer :skip_head do
+        if @input.skip_until(/Domain Name:/)
+          @input.scan(/\s?(.+)\n/)
+          @ast["Domain Name"] = @input[1].strip
+        end
+      end
+
+      tokenizer :skip_end do
+        @input.terminate
+      end
+
+    end
+
+  end
+end

data/lib/whois/scanners/base_iisse.rb

@@ -0,0 +1,36 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    # Scanner for the IIS.se company.
+    class BaseIisse < Base
+
+      self.tokenizers += [
+          :skip_empty_line,
+          :scan_available,
+          :scan_disclaimer,
+          :scan_keyvalue,
+      ]
+
+
+      tokenizer :scan_available do
+        if @input.skip(/^(domain )?"(.+)" not found.+\n/)
+          @ast["status:available"] = true
+        end
+      end
+
+      tokenizer :scan_disclaimer do
+        if @input.match?(/# Copyright/)
+          lines = []
+          while @input.scan(/#(.*)\n\n?/)
+            lines << @input[1].strip unless @input[1].strip == ""
+          end
+          @ast["field:disclaimer"] = lines.join(" ")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/whois/scanners/base_shared1.rb

@@ -0,0 +1,31 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    class BaseShared1 < Base
+
+      self.tokenizers += [
+          :skip_empty_line,
+          :scan_available,
+          :scan_reserved,
+          :scan_keyvalue,
+      ]
+
+
+      tokenizer :scan_available do
+        if @input.skip(/^No Data Found\n/)
+          @ast["status:available"] = true
+        end
+      end
+
+      tokenizer :scan_reserved do
+        if settings[:pattern_reserved] && @input.scan(settings[:pattern_reserved])
+          @ast["status:reserved"] = true
+        end
+      end
+
+    end
+
+  end
+end

data/lib/whois/scanners/base_shared2.rb

@@ -0,0 +1,35 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    class BaseShared2 < Base
+
+      self.tokenizers += [
+          :skip_blank_line,
+          :scan_available,
+          :scan_keyvalue,
+          :skip_lastupdate,
+          :skip_fuffa,
+      ]
+
+
+      tokenizer :scan_available do
+        if @input.scan(/^Not found: (.+)\n/)
+          @ast["Domain Name"] = @input[1]
+          @ast["status:available"] = true
+        end
+      end
+
+      tokenizer :skip_lastupdate do
+        @input.skip(/>>>(.+?)<<<\n/)
+      end
+
+      tokenizer :skip_fuffa do
+        @input.skip(/^\S(.+)\n/)
+      end
+
+    end
+
+  end
+end

data/lib/whois/scanners/base_shared3.rb

@@ -0,0 +1,37 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    class BaseShared3 < Base
+
+      self.tokenizers += [
+          :scan_disclaimer,
+          :skip_empty_line,
+          :skip_comment,
+          :scan_available,
+          :scan_keyvalue,
+      ]
+
+
+      tokenizer :skip_comment do
+        @input.skip(/^;.*\n/)
+      end
+
+      tokenizer :scan_available do
+        if @input.skip(/^not found.+\n/)
+          @ast["status:available"] = true
+        end
+      end
+
+      tokenizer :scan_disclaimer do
+        if @input.pos == 0 && @input.match?(/^;.*/)
+          @ast["field:disclaimer"] = _scan_lines_to_array(/^;(.*)\n/).join(" ")
+          @ast["field:disclaimer"].gsub!("  ", "\n")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/whois/scanners/base_whoisd.rb

@@ -0,0 +1,44 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    # Scanner for Whoisd-based records.
+    class BaseWhoisd < Base
+
+      self.tokenizers += [
+          :scan_available,
+          :skip_comment,
+          :scan_section,
+          :scan_keyvalue,
+          :skip_empty_line,
+      ]
+
+
+      tokenizer :scan_available do
+        if @input.skip(/^%ERROR:101: no entries found/)
+          @ast['status:available'] = true
+        end
+      end
+
+      tokenizer :scan_section do
+        if @input.scan(/\n(contact|nsset|keyset):\s+(.+)\n/)
+          @tmp["_section"] = "node:#{@input[1]}/#{@input[2].strip}"
+          while scan_keyvalue
+          end
+          @tmp.delete("_section")
+        end
+      end
+
+      tokenizer :todo_content do
+        @input.scan(/(.*)\n/)
+      end
+
+      tokenizer :skip_comment do
+        @input.skip(/^%.*\n/)
+      end
+
+    end
+
+  end
+end

data/lib/whois/scanners/iana.rb

@@ -0,0 +1,89 @@
+require_relative 'base'
+
+module Whois
+  module Scanners
+
+    class Iana < Base
+
+      self.tokenizers += [
+          :skip_empty_line,
+          :scan_disclaimer,
+          :scan_section,
+      ]
+
+
+      tokenizer :scan_disclaimer do
+        if @input.match?(/^\%(.*?)\n/)
+          @ast["Disclaimer"] = _scan_lines_to_array(/\%(.*?)\n/).select { |line| line =~ /\w+/ }.join(" ")
+        end
+      end
+
+      tokenizer :scan_section do
+        if @input.scan(/^(.+):(.+)\n/)
+
+          # Adapt the section's name depending on the first line
+          section = case @input[1].strip
+          when 'contact'
+            @input[2].strip # use the contact type name as identifier
+          when 'created', 'changed'
+            'dates'
+          when 'nserver'
+            'nameservers'
+          else
+            @input[1].strip # Default name is the first label found
+          end
+
+          content = parse_section_pairs
+          @input.match?(/\n+/) || error("Unexpected end of section")
+          @ast[section] = content
+        end
+      end
+
+
+    private
+
+      def parse_section_pairs
+        # Sets by default the firsts values found in the section parsing bellow
+        section_name, section_value = @input[1].strip, @input[2].strip
+        #contents = {section_name =>  section_value}
+
+        contents = {}
+
+        while content = parse_section_pair
+          contents.merge!(content)
+        end
+
+        if contents.has_key? section_name
+          contents[section_name].insert(0, "#{section_value}\n")
+        else
+          contents[section_name] = section_value
+        end
+
+        if !contents.empty?
+          contents
+        else
+          false
+        end
+      end
+
+        def parse_section_pair
+          if @input.scan(/^(.+):\s*(.+)\n/)
+            key     =  @input[1].strip
+            values  = [@input[2].strip]
+
+            while value = parse_section_pair_newlinevalue(key)
+              values << value
+            end
+            { key => values.join("\n") }
+          end
+        end
+
+          def parse_section_pair_newlinevalue(key)
+            if @input.scan(/^#{key}:\s*(.+)\n/)
+              @input[1].strip
+            end
+          end
+
+    end
+  end
+end