whois 0.5.3 → 0.8.0

data/lib/whois/answer/parser/whois.denic.de.rb

@@ -0,0 +1,202 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Aaron Mueller <mail@aaron-mueller.de>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/parser/base'
+
+
+module Whois
+  class Answer
+    class Parser
+      class WhoisDenicDe < Base
+
+        register_method :disclaimer do
+          ast['Disclaimer']
+        end
+
+        register_method :domain do
+          ast['Domain']
+        end
+
+        register_method :domain_id do
+          nil
+        end
+
+        register_method :status do
+          ast['Status']
+        end
+
+        register_method :registered? do
+          !ast['NotFound']
+        end
+
+        register_method :available? do
+          ast['NotFound']
+        end
+
+        register_method :created_on do
+          nil
+        end
+
+        register_method :expires_on do
+          nil
+        end
+
+        register_method :updated_on do
+          ast['Changed'] ? Time.parse(ast['Changed']) : nil
+        end
+
+        register_method :registrar do
+          return nil unless ast['Zone-C']
+          Answer::Registrar.new(
+              :id => nil,
+              :name => ast['Zone-C'].name,
+              :organization => ast['Zone-C'].organization,
+              :url => nil
+          )
+        end
+
+        register_method :registrant do
+          ast['Holder']
+        end
+
+        register_method :admin do
+          ast['Admin-C']
+        end
+
+        register_method :technical do
+          ast['Tech-C']
+        end
+
+        register_method :nameservers do
+          ast['Nserver']
+        end
+
+        
+        protected
+
+          def ast
+            @ast ||= parse
+          end
+
+          def parse
+            Scanner.new(content.to_s).parse
+          end
+
+
+        class Scanner
+
+          def initialize(content)
+            @input = StringScanner.new(content.to_s)
+          end
+
+          def parse
+            @ast = {}
+            while !@input.eos?
+              trim_newline  ||
+              parse_content
+            end
+            @ast
+          end
+
+          private
+
+            def trim_newline
+              @input.scan(/\n/)
+            end
+
+            def parse_content
+              parse_disclaimer ||
+              parse_not_found ||
+              parse_pair(@ast) ||
+              parse_contact ||
+              trim_newline ||
+              error('Unexpected token')
+            end
+
+            def parse_disclaimer
+              if @input.match?(/% Copyright \(c\)2008 by DENIC\n/)
+                8.times { @input.scan(/%(.*)\n/) } # strip junk
+                lines = []
+                while @input.match?(/%/) && @input.scan(/%(.*)\n/)
+                  lines << @input[1].strip unless @input[1].strip == ""
+                end
+                @ast['Disclaimer'] = lines.join(" ")
+                true
+              end
+              false
+            end
+
+            def parse_pair(node)
+              if @input.scan(/([^  \[]*):(.*)\n/)
+                key, value = @input[1].strip, @input[2].strip
+                if node[key].nil?
+                  node[key] = value
+                else
+                  node[key].is_a?(Array) || node[key] = [node[key]]
+                  node[key] << value
+                end
+                true
+              else
+                false
+              end
+            end
+
+            def parse_contact
+              if @input.scan(/\[(.*)\]\n/)
+                contact_name = @input[1]
+                contact = {}
+                while parse_pair(contact)
+                end
+                @ast[contact_name] = Answer::Contact.new(
+                    :id => nil,
+                    :name => contact['Name'],
+                    :organization => contact['Organisation'],
+                    :address => contact['Address'],
+                    :city => contact['City'],
+                    :zip => contact['Pcode'],
+                    :state => nil,
+                    :country => nil,
+                    :country_code => contact['Country'],
+                    :phone => contact['Phone'],
+                    :fax => contact['Fax'],
+                    :email => contact['Email'],
+                    :created_on => nil,
+                    :updated_on => contact['Changed']
+                )
+                true
+              else
+                false
+              end
+            end
+
+            def parse_not_found
+              if @input.match?(/% Object "(.*)" not found in database\n/)
+                6.times { @input.scan(/%(.*)\n/) } # strip junk
+                return @ast['NotFound'] = true
+              end
+              @ast['NotFound'] = false
+            end
+
+            def error(message)
+              raise "#{message}: #{@input.peek(@input.string.length)}"
+            end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/whois/answer/parser/whois.nic.it.rb

@@ -0,0 +1,330 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/parser/base'
+
+
+module Whois
+  class Answer
+    class Parser
+
+      #
+      # = whois.nic.it parser
+      #
+      # Parser for the whois.nic.it server.
+      #
+      class WhoisNicIt < Base
+
+        # Returns the registry disclaimer that comes with the answer.
+        register_method :disclaimer do
+          node("Disclaimer")
+        end
+
+
+        # If available, returns the domain name as stored by the registry.
+        register_method :domain do
+          node("Domain") { |raw| raw.downcase }
+        end
+
+        # If available, returns the unique domain ID set by the registry.
+        register_method :domain_id do
+          nil
+        end
+
+
+        # Returns the record status or an array of status,
+        # in case the registry supports it.
+        register_method :status do
+          node("Status") { |raw| raw.downcase.to_sym }
+        end
+
+        # Returns whether this record is available.
+        register_method :available? do
+          node("Status") == "AVAILABLE"
+        end
+
+        # Returns whether this record is registered.
+        register_method :registered? do
+          !available?
+        end
+
+
+        # If available, returns a Time object representing the date
+        # the record was created, according to the registry answer.
+        register_method :created_on do
+          node("Created") { |raw| Time.parse(raw) }
+        end
+        
+        # If available, returns a Time object representing the date
+        # the record was last updated, according to the registry answer.
+        register_method :updated_on do
+          node("Last Update") { |raw| Time.parse(raw) }
+        end
+        
+        # If available, returns a Time object representing the date
+        # the record is set to expire, according to the registry answer.
+        register_method :expires_on do
+          node("Expire Date") { |raw| Time.parse(raw) }
+        end
+
+
+        # If available, returns a <tt>Whois::Answer::Registrar</tt> record
+        # containing the registrar details extracted from the registry answer.
+        register_method :registrar do
+          node("Registrar") do |raw|
+            Answer::Registrar.new(
+              :id           => raw["Name"],
+              :name         => raw["Name"],
+              :organization => raw["Organization"]
+            )
+          end
+        end
+
+        # If available, returns a <tt>Whois::Answer::Contact</tt> record
+        # containing the registrant details extracted from the registry answer.
+        register_method :registrant do
+          contact("Registrant")
+        end
+
+        # If available, returns a <tt>Whois::Answer::Contact</tt> record
+        # containing the admin contact details extracted from the registry answer.
+        register_method :admin do
+          contact("Admin Contact")
+        end
+
+        # If available, returns a <tt>Whois::Answer::Contact</tt> record
+        # containing the technical contact details extracted from the registry answer.
+        register_method :technical do
+          contact("Technical Contacts")
+        end
+
+
+        # If available, returns an array of name servers entries for this domain
+        # if any name server is available in the registry answer.
+        # Each name server is a lower case string.
+        #
+        # ==== Examples
+        #
+        #   nameserver
+        #   # => nil
+        #   nameserver
+        #   # => ["ns2.google.com", "ns1.google.com", "ns3.google.com"]
+        #
+        register_method :nameservers do
+          node("Nameservers")
+        end
+
+
+        # Returns whether this answer changed compared to <tt>other</tt>.
+        #
+        # Comparing the Answer contents is not always as trivial as it seems.
+        # Whois servers sometimes inject dynamic method into the whois answer such as
+        # the timestamp the request was generated.
+        # This causes two answers to be different even if they actually should be considered equal
+        # because the registry data didn't change.
+        #
+        # This method should provide a bulletproof way to detect whether this answer
+        # changed if compared with <tt>other</tt>.
+        register_method :changed? do |other|
+          !unchanged?(other)
+        end
+
+        # The opposite of <tt>changed?</tt>.
+        register_method :unchanged? do |other|
+          self == other ||
+          self.content.to_s == other.content.to_s
+          # (self == other)                 ||
+          # (domain     == other.domain     &&
+          #  created_on == other.created_on &&
+          #  updated_on == other.updated_on &&
+          #  expires_on == other.expires_on )
+        end
+
+
+        protected
+
+          def contact(element)
+            node(element) do |raw|
+              address = (raw["Address"] || "").split("\n")
+              Answer::Contact.new(
+                :id           => raw["ContactID"],
+                :name         => raw["Name"],
+                :organization => raw["Organization"],
+                :address      => address[0],
+                :city         => address[1],
+                :country_code => address[3],
+                :created_on   => raw["Created"] ? Time.parse(raw["Created"]) : nil,
+                :updated_on   => raw["Last Update"] ? Time.parse(raw["Created"]) : nil
+              )
+            end
+          end
+
+
+          def ast
+            @ast ||= parse
+          end
+
+          def node(key, &block)
+            if block_given?
+              value = ast[key]
+              value = yield(value) unless value.nil?
+              value
+            else
+              ast[key]
+            end
+          end
+
+          def node?(key)
+            !ast[key].nil?
+          end
+
+          def parse
+            Scanner.new(content.to_s).parse
+          end
+
+
+        class Scanner
+
+          def initialize(content)
+            @input = StringScanner.new(content.to_s)
+          end
+
+          def parse
+            @ast = {}
+            while !@input.eos?
+              trim_newline  ||
+              parse_content
+            end
+            @ast
+          end
+
+          private
+
+            def parse_content
+              parse_disclaimer  ||
+              parse_pair        ||
+              parse_section     ||
+              error("Unexpected token")
+            end
+
+            def trim_newline
+              @input.scan(/\n/)
+            end
+
+            def parse_pair
+              if @input.scan(/(.*?):(.*?)\n/)
+                key, value = @input[1].strip, @input[2].strip
+                @ast[key] = value
+              else
+                false
+              end
+            end
+
+            def parse_disclaimer
+              if @input.match?(/\*(.*?)\*\n/)
+                disclaimer = []
+                while @input.scan(/\*(.*?)\*\n/)
+                  matched = @input[1].strip
+                  disclaimer << matched if matched =~ /\w+/
+                end
+                @ast["Disclaimer"] = disclaimer.join(" ")
+              else
+                false
+              end
+            end
+
+            def parse_section
+              if @input.scan(/([^:]*?)\n/)
+                section = @input[1].strip
+                content = parse_section_pairs ||
+                          parse_section_items
+                @input.match?(/\n+/) || error("Unexpected end of section")
+                @ast[section] = content
+              else
+                false
+              end
+            end
+
+              def parse_section_items
+                if @input.match?(/(\s+)([^:]*?)\n/)
+                  items = []
+                  indentation = @input[1].length
+                  while item = parse_section_items_item(indentation)
+                    items << item
+                  end
+                  items
+                else
+                  false
+                end
+              end
+
+                def parse_section_items_item(indentation)
+                  if @input.scan(/\s{#{indentation}}(.*)\n/)
+                    @input[1]
+                  else
+                    false
+                  end
+                end
+
+              def parse_section_pairs
+                contents = {}
+                while content = parse_section_pair
+                  contents.merge!(content)
+                end
+                if !contents.empty?
+                  contents
+                else
+                  false
+                end
+              end
+
+                def parse_section_pair
+                  if @input.scan(/(\s+)(.*?):(\s+)(.*?)\n/)
+                    key = @input[2].strip
+                    values = [@input[4].strip]
+                    indentation = @input[1].length + @input[2].length + 1 + @input[3].length
+                    while value = parse_section_pair_newlinevalue(indentation)
+                      values << value
+                    end
+                    { key => values.join("\n") }
+                  else
+                    false
+                  end
+                end
+
+                  def parse_section_pair_newlinevalue(indentation)
+                    if @input.scan(/\s{#{indentation}}(.*)\n/)
+                      @input[1]
+                    else
+                      false
+                    end
+                  end
+
+            def error(message)
+              if @input.eos?
+                raise "Unexpected end of input."
+              else
+                raise "#{message}: #{@input.peek(@input.string.length)}"
+              end
+            end
+
+        end
+
+      end
+      
+    end
+  end
+end