whois 1.2.2 → 1.3.0

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

@@ -128,7 +128,7 @@ module Whois
           def parse
             @ast = {}
             while !@input.eos?
-              trim_newline  ||
+#              trim_empty_line  ||
               parse_content
             end
             @ast
@@ -136,20 +136,30 @@ module Whois
 
           private
 
-            def trim_newline
-              @input.scan(/\n/)
+            def parse_content
+              parse_disclaimer  ||
+              parse_invalid     ||
+              parse_not_found   ||
+              parse_pair(@ast)  ||
+              parse_contact     ||
+
+              trim_empty_line   ||
+              error("Unexpected token")
+            end
+  
+            def trim_empty_line
+              @input.skip(/^\n/)
             end
 
-            def parse_content
-              parse_disclaimer ||
-              parse_invalid ||
-              parse_not_found ||
-              parse_pair(@ast) ||
-              parse_contact ||
-              trim_newline ||
-              error('Unexpected token')
+            def error(message)
+              if @input.eos?
+                raise "Unexpected end of input."
+              else
+                raise "#{message}: `#{@input.peek(@input.string.length)}'"
+              end
             end
 
+
             def parse_disclaimer
               if @input.match?(/% Copyright \(c\) *\d{4} by DENIC\n/)
                 @input.scan_until(/% Terms and Conditions of Use\n/)
@@ -157,7 +167,7 @@ module Whois
                 while @input.match?(/%/) && @input.scan(/%(.*)\n/)
                   lines << @input[1].strip unless @input[1].strip == ""
                 end
-                @ast['Disclaimer'] = lines.join(" ")
+                @ast["Disclaimer"] = lines.join(" ")
                 true
               end
               false
@@ -208,22 +218,17 @@ module Whois
 
             def parse_not_found
               if @input.match?(/% Object "(.*)" not found in database\n/)
-                6.times { @input.scan(/%(.*)\n/) } # strip junk
-                return @ast['NotFound'] = true
+                while @input.scan(/%(.*)\n/)  # strip junk
+                end
+                @ast["NotFound"] = true
               end
-              @ast['NotFound'] = false
             end
 
             def parse_invalid
               if @input.match?(/% ".*" is not a valid domain name\n/)
-                 @input.scan(/%.*\n/)
-                 return @ast['Invalid'] = true
+                @input.scan(/%.*\n/)
+                @ast["Invalid"] = true
               end 
-              @ast['Invalid'] = false
-            end 
-
-            def error(message)
-              raise "#{message}: #{@input.peek(@input.string.length)}"
             end
 
         end

data/lib/whois/answer/parser/whois.iana.org.rb

@@ -15,6 +15,7 @@
 
 
 require 'whois/answer/parser/base'
+require 'whois/answer/parser/scanners/iana'
 
 
 module Whois
@@ -26,16 +27,11 @@ module Whois
       #
       # Parser for the whois.iana.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 WhoisIanaOrg < Base
+        include Ast
 
         property_supported :status do
-          if available?
+          @status ||= if available?
             :available
           else
             :registered
@@ -43,33 +39,77 @@ module Whois
         end
 
         property_supported :available? do
-          @available ||= !!(content_for_scanner =~ /Domain (.*?) not found/)
+          @available  ||= !!(content_for_scanner =~ /This query returned 0 objects|organisation: Not assigned/)
         end
 
         property_supported :registered? do
-          !available?
+          @registered ||= !available?
+        end
+
+
+        property_supported :registrant_contact do
+          @registrant_contact ||= contact("organisation", Whois::Answer::Contact::TYPE_REGISTRANT)
+        end
+
+        property_supported :admin_contact do
+          @admin_contact ||= contact("administrative", Whois::Answer::Contact::TYPE_ADMIN)
+        end
+
+        property_supported :technical_contact do
+          @technical_contact ||= contact("technical", Whois::Answer::Contact::TYPE_TECHNICAL)
         end
 
 
         property_supported :created_on do
-          @created_on ||= if content_for_scanner =~ /\nRegistration Date:\s+(.*)\n/
-            Time.parse($1)
-          end
+          @created_on ||= node("dates") { |raw| Time.parse(raw["created"]) if raw.has_key? "created" }
         end
 
         property_supported :updated_on do
-          @updated_on ||= if content_for_scanner =~ /\nLast Updated Date:\s+(.*)\n/
-            Time.parse($1)
-          end
+          @updated_on ||= node("dates") { |raw| Time.parse(raw["changed"]) if raw.has_key? "changed" }
         end
 
         property_not_supported :expires_on
 
 
         property_supported :nameservers do
-          @nameservers ||= content_for_scanner.scan(/Nameserver:\s(.*)\n/).flatten.map { |value| value.chomp(".") }
+          @nameservers ||= nameserver("nameservers") || []
         end
 
+
+        protected
+
+          def parse
+            Scanners::Iana.new(content_for_scanner).parse
+          end
+
+          def contact(element, type)
+            node(element) do |raw|
+              if raw["organisation"] != "Not assigned"
+                address = (raw["address"] || "").split("\n")
+                Answer::Contact.new(
+                  :type         => type,
+                  :name         => raw["name"],
+                  :organization => raw["organisation"],
+                  :address      => address[0],
+                  :city         => address[1],
+                  :zip          => address[2],
+                  :country      => address[3],
+                  :phone        => raw["phone"],
+                  :fax          => raw["fax-no"],
+                  :email        => raw["e-mail"]
+                )
+              end
+            end
+          end
+
+          def nameserver(element)
+            node(element) do |raw|
+              (raw["nserver"] || "").split("\n").map do |nameserver|
+                Answer::Nameserver.new(*nameserver.downcase.split(" "))
+              end
+            end
+          end
+
       end
 
     end

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

@@ -93,7 +93,7 @@ module Whois
         protected
 
           def parse
-            Scanners::VerisignScanner.new(content_for_scanner).parse
+            Scanners::Verisign.new(content_for_scanner).parse
           end
 
       end

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

@@ -179,10 +179,6 @@ module Whois
 
           private
 
-            def trim_empty_line
-              @input.scan(/^\n/)
-            end
-
             def parse_content
               parse_version     ||
               parse_disclaimer  ||
@@ -201,6 +197,18 @@ module Whois
               error("Unexpected token")
             end
 
+            def trim_empty_line
+              @input.skip(/^\n/)
+            end
+
+            def error(message)
+              if @input.eos?
+                raise "Unexpected end of input."
+              else
+                raise "#{message}: `#{@input.peek(@input.string.length)}'"
+              end
+            end
+
 
             def parse_version
               if @input.match?(/% Whois server .*\n/)
@@ -354,10 +362,6 @@ module Whois
               true
             end
 
-            def error(message)
-              raise "#{message}: `#{@input.peek(@input.string.length)}'"
-            end
-
         end
 
       end

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

@@ -51,7 +51,7 @@ module Whois
         end
 
         property_supported :available? do
-          @available ||= node("Status") == "AVAILABLE"
+          @available  ||= node("Status") == "AVAILABLE"
         end
 
         property_supported :registered? do

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

@@ -94,7 +94,7 @@ module Whois
         protected
 
           def parse
-            Scanners::VerisignScanner.new(content_for_scanner).parse
+            Scanners::Verisign.new(content_for_scanner).parse
           end
 
       end

data/lib/whois/answer/parser/whois.publicinterestregistry.net.rb

@@ -168,11 +168,12 @@ module Whois
           private
 
             def parse_content
-              trim_empty_line   ||
               parse_not_found   ||
               parse_throttle    ||
               parse_disclaimer  ||
               parse_pair        ||
+
+              trim_empty_line   ||
               error("Unexpected token")
             end
 
@@ -180,6 +181,15 @@ module Whois
               @input.skip(/^\n/)
             end
 
+            def error(message)
+              if @input.eos?
+                raise "Unexpected end of input."
+              else
+                raise "#{message}: `#{@input.peek(@input.string.length)}'"
+              end
+            end
+
+
             def parse_not_found
               @input.skip(/^NOT FOUND\n/)
             end
@@ -217,14 +227,6 @@ module Whois
               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

data/lib/whois/answer/registrar.rb

@@ -27,10 +27,10 @@ module Whois
     #
     # A Registrar is composed by the following attributes:
     #
-    # * <tt>:id</tt>::
-    # * <tt>:name</tt>::
-    # * <tt>:organization</tt>::
-    # * <tt>:url</tt>::
+    # * <tt>:id</tt>:
+    # * <tt>:name</tt>:
+    # * <tt>:organization</tt>:
+    # * <tt>:url</tt>:
     #
     # Be aware that every WHOIS server can return a different number of details
     # or no details at all.
@@ -39,4 +39,4 @@ module Whois
     end
 
   end
-end
+end

data/lib/whois/client.rb

@@ -46,7 +46,6 @@ module Whois
     #   end
     #   client.query("google.com")
     #
-    #
     # Returns a <tt>Whois::Client</tt>.
     def initialize(options = {}, &block)
       self.timeout = options[:timeout] || DEFAULT_TIMEOUT

data/lib/whois/errors.rb

@@ -16,34 +16,34 @@
 
 module Whois
 
-  # The base error class for all Whois error classes.
+  # The base error class for all <tt>Whois</tt> error classes.
   class Error < StandardError
   end
-  
-  
-  # Generic Server exception class.
+
+
+  # Generic <tt>Whois::Server</tt> exception class.
   class ServerError < Error
   end
-  
+
   # Server Definition not found
-  
+
   # Raised when the class hasn't been able to select a valid server
   # probably because definitions are outdated.
   class ServerNotFound < ServerError
   end
-  
+
   # Server Definition found
-  
+
   class InterfaceNotSupported < ServerError
   end
-  
+
   # Raised when a server is known to not be available for this kind of object
   # or because this specific object doesn't support WHOIS. (\x03)
   class NoInterfaceError < InterfaceNotSupported
   end
-  
+
   # Raised when the class has found a server but it doesn't support the
-  # standard whois interface via port 43. This is the case of some
+  # standard WHOIS interface via port 43. This is the case of some
   # specific domains that only provide a web–based WHOIS interface. (\x01)
   class WebInterfaceError < InterfaceNotSupported
     attr_reader :url
@@ -61,19 +61,19 @@ module Whois
   class ServerNotImplemented < ServerError
   end
 
-  # Raised when no whois server is known for this kind of object. (\x05)
+  # Raised when no WHOIS server is known for this kind of object. (\x05)
   class ServerNotSupported < ServerError
   end
-  
-  # Raised when unknown AS numer of IP network. (\x06)
+
+  # Raised when unknown AS number of IP network. (\x06)
   class AllocationUnknown < ServerError
   end
-  
-  
-  # Generic Parser exception class.
+
+
+  # Generic <tt>Whois::Answer::Parser</tt> exception class.
   class ParserError < Error
   end
-  
+
   # Raised when the class hasn't been able to load a valid parser
   # according to current settings.
   class ParserNotFound < ParserError
@@ -94,4 +94,4 @@ module Whois
   class PropertyNotAvailable < ParserError
   end
 
-end
+end

data/lib/whois/server.rb

@@ -44,14 +44,30 @@ module Whois
       Dir[File.dirname(__FILE__) + '/definitions/*.rb'].each { |file| load(file) }
     end
 
-    # Returns the active definition list.
-    # If <tt>type</tt>, returns only the definitions matching given type or
-    # nil if no definition exists.
+    # Lookup and returns the definition list for given <tt>type</tt>,
+    # or all definitions if <tt>type</tt> is <tt>nil</tt>.
+    #
+    # ==== Parameters
+    #
+    # type:: The type of WHOIS server to lookup.
+    #   Known values are :tld, :ipv4, :ipv6.
+    #
+    # ==== Returns
+    #
+    # Hash:: If the method is called without specifying a <tt>type</tt>.
+    # Array:: If the method is called specifying a <tt>type</tt>,
+    #   and the <tt>type</tt> exists.
+    # nil:: If the method is called specifying a <tt>type</tt>,
+    #   and the <tt>type</tt> doesn't exist.
+    #
+    # ==== Examples
     #
     #   Whois::Server.definitions
     #   # => { :tld => [...], :ipv4 => [], ... }
+    #
     #   Whois::Server.definitions(:tld)
     #   # => [...]
+    #
     #   Whois::Server.definitions(:invalid)
     #   # => nil
     #
@@ -65,27 +81,42 @@ module Whois
 
     # Defines a new server for <tt>:type</tt> queries.
     #
-    # == Parameters
+    # ==== Parameters
+    #
+    # type:: The type of WHOIS server to define.
+    #   Known values are :tld, :ipv4, :ipv6.
+    # allocation:: The allocation, range or hostname
+    #   this server is responsible for.
+    # host:: The server hostname.
+    #   Use nil if unknown or not available.
+    # options:: Hash of options to customize Adapter behavior.
+    #   The <tt>:adapter</tt> option has a special meaning and determines
+    #   the adapter Class to use.
+    #   Defaults to </tt>Whois::Server::Adapters::Standard</tt> unless specified.
+    #   All the other options are passed directly to the adapter which
+    #   can decide how to use them.
+    #
+    # ==== Returns
     #
-    # type::
-    #   The type of whois server to define. 
-    #   Allowed values are :tld, :ipv4, :ipv6.
-    # allocation::
-    #   The allocation, range or hostname this server is responsible for.
-    # host::
-    #   The server hostname.
-    # options::
-    #   Additional options to customize Adpter behavior.
+    # Nothing.
     #
     # ==== Examples
     #
     #   # Define a server for the .it extension
     #   Whois::Server.define :tld, ".it", "whois.nic.it"
+    #
     #   # Define a new server for an range of IPv4 addresses
     #   Whois::Server.define :ipv4, "61.192.0.0/12", "whois.nic.ad.jp"
+    #
     #   # Define a new server for an range of IPv6 addresses
     #   Whois::Server.define :ipv6, "2001:2000::/19", "whois.ripe.net"
     #
+    #   # Define a new server with a custom adapter
+    #   Whois::Server.define :tld, ".test", nil, :adapter => Whois::Server::Adapter::None
+    #
+    #   # Define a new server with a custom adapter and options
+    #   Whois::Server.define :tld, ".ar", nil, :adapter => Whois::Server::Adapters::Web, :web => "http://www.nic.ar/"
+    #
     def self.define(type, allocation, host, options = {})
       @@definitions[type] ||= []
       @@definitions[type] <<  [allocation, host, options]
@@ -94,14 +125,39 @@ module Whois
     # Creates a new server adapter from given arguments
     # and returns the server instance.
     #
-    # By default returns a new Whois::Servers::Adapter::Standard instance.
-    # You can customize the behavior passing a custom adapter class as :adapter option.
+    # By default, returns a new Whois::Servers::Adapter::Standard instance.
+    # You can customize the behavior passing a custom adapter class as <tt>:adapter</tt> option.
     #
     #   Whois::Server.factory :tld, ".it", "whois.nic.it"
     #   # => #<Whois::Servers::Adapter::Standard>
+    #
     #   Whois::Server.factory :tld, ".it", "whois.nic.it", :option => Whois::Servers::Adapter::Custom
     #   # => #<Whois::Servers::Adapter::Custom>
     #
+    # Please note that any adapter is responsible for a limited set of queries,
+    # which should be included in the range of the <tt>allocation</tt> parameter.
+    # Use <tt>Whois::Server#guess</tt> if you are not sure which adapter is the right one
+    # for a specific string.
+    #
+    # ==== Parameters
+    #
+    # type:: The type of WHOIS server to create.
+    #   Known values are :tld, :ipv4, :ipv6.
+    # allocation:: The allocation, range or hostname
+    #   this server is responsible for.
+    # host:: The server hostname.
+    #   Use nil if unknown or not available.
+    # options:: Hash of options to customize Adapter behavior.
+    #   The <tt>:adapter</tt> option has a special meaning and determines
+    #   the adapter Class to use.
+    #   Defaults to </tt>Whois::Server::Adapters::Standard</tt> unless specified.
+    #   All the other options are passed directly to the adapter which
+    #   can decide how to use them.
+    #
+    # ==== Returns
+    #
+    # Whois::Server::Adapters::Standard:: An adapter that can be used to perform queries.
+    #
     def self.factory(type, allocation, host, options = {})
       options = options.dup
       (options.delete(:adapter) || Adapters::Standard).new(type, allocation, host, options)
@@ -113,32 +169,47 @@ module Whois
     # It successfully detects the following query types:
     # * ipv6
     # * ipv4
-    # * top level domains
+    # * top level domains (e.g. .com, .net, .it)
+    # * domain names (e.g. google.com, google.net, google.it)
     # * emails
     #
+    # Note that not all query types actually have a corresponding adapter.
+    # For instance, the following request will result in a
+    # <tt>Whois::ServerNotSupported</tt> exception.
+    #
+    #   Whois::Server.guess "mail@example.com"
+    #
+    # ==== Returns
+    #
+    # Whois::Server::Adapters::Base:: The adapter that can be used to perform
+    #   WHOIS queries for <tt>qstring</tt>.
+    #
     # ==== Raises
     #
-    # ServerNotFound::
-    #   When unable to find an appropriate whois server for <tt>qstring</tt>.
+    # ServerNotFound:: When unable to find an appropriate WHOIS adapter
+    #   for <tt>qstring</tt>. Most of the cases, the <tt>qstring</tt>
+    #   haven't been recognised as one of the supported query types.
+    # ServerNotSupported:: When the <tt>qstring</tt> type is detected,
+    #   but the object type doesn't have any supported WHOIS adapter associated.
     #
     def self.guess(qstring)
-      # IPv6 address (secure match)
-      if valid_ipv6?(qstring)
-        return find_for_ipv6(qstring)
+      # Top Level Domain match
+      if matches_tld?(qstring)
+        return factory(:tld, ".", "whois.iana.org")
       end
-
-      # IPv4 address (secure match)
-      if valid_ipv4?(qstring)
-        return find_for_ipv4(qstring)
+      
+      # IP address (secure match)
+      if matches_ip?(qstring)
+        return find_for_ip(qstring)
       end
 
       # Email Address (secure match)
-      if qstring =~ /@/
+      if matches_email?(qstring)
         return find_for_email(qstring)
       end
-      
-      # TLD
-      if server = find_for_tld(qstring)
+
+      # Domain Name match
+      if server = find_for_domain(qstring)
         return server
       end
 
@@ -149,41 +220,42 @@ module Whois
 
     private
 
-      def self.find_for_ipv6(qstring)
-        ip = IPAddr.new(qstring)
-        definitions(:ipv6).each do |definition|
-          if IPAddr.new(definition.first).include?(ip)
-            return factory(:ipv6, *definition)
-          end
-        end
-        raise AllocationUnknown,
-                "IP Allocation for `#{qstring}' unknown." +
-                "Server definitions might be outdated."
+      def self.matches_tld?(string)
+        string =~ /^\.(xn--)?[a-z0-9]+$/
+      end
+
+      def self.matches_ip?(string)
+        valid_ipv4?(string) || valid_ipv6?(string)
       end
 
-      def self.find_for_ipv4(qstring)
+      def self.matches_email?(string)
+        string =~ /@/
+      end
+
+
+      def self.find_for_ip(qstring)
         ip = IPAddr.new(qstring)
-        definitions(:ipv4).each do |definition|
+        type = ip.ipv4? ? :ipv4 : :ipv6
+        definitions(type).each do |definition|
           if IPAddr.new(definition.first).include?(ip)
-            return factory(:ipv4, *definition)
+            return factory(type, *definition)
           end
         end
-        raise AllocationUnknown,
-                "IP Allocation for `#{qstring}' unknown." +
-                "Server definitions might be outdated."
+        raise AllocationUnknown, "IP Allocation for `#{qstring}' unknown. Server definitions might be outdated."
       end
 
       def self.find_for_email(qstring)
-        raise ServerNotSupported, "No whois server is known for email objects"
+        raise ServerNotSupported, "No WHOIS server is known for email objects"
       end
 
-      def self.find_for_tld(qstring)
+      def self.find_for_domain(qstring)
         definitions(:tld).each do |definition|
           return factory(:tld, *definition) if /#{Regexp.escape(definition.first)}$/ =~ qstring
         end
         nil
       end
 
+
       def self.valid_ipv4?(addr)
         if /\A(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\Z/ =~ addr
           return $~.captures.all? {|i| i.to_i < 256}