whois 2.0.7 → 2.1.0

data/lib/whois.rb

@@ -22,10 +22,6 @@ module Whois
   AUTHORS         = ["Simone Carletti <weppos@weppos.net>"]
 
 
-  # Backwards compatibility
-  autoload :Answer, 'whois/answer'
-
-
   class << self
 
     # Queries the WHOIS server for <tt>qstring</tt> and returns

data/lib/whois/definitions/tlds.rb

@@ -2,10 +2,12 @@ Whois::Server.define :tld, ".ae.org", "whois.centralnic.com"
 Whois::Server.define :tld, ".ar.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".br.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".cn.com", "whois.centralnic.com"
+Whois::Server.define :tld, ".com.de", "whois.centralnic.com"
 Whois::Server.define :tld, ".de.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".eu.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".gb.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".gb.net", "whois.centralnic.com"
+Whois::Server.define :tld, ".gr.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".hu.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".jpn.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".kr.com", "whois.centralnic.com"
@@ -18,6 +20,7 @@ Whois::Server.define :tld, ".se.net", "whois.centralnic.com"
 Whois::Server.define :tld, ".uk.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".uk.net", "whois.centralnic.com"
 Whois::Server.define :tld, ".us.com", "whois.centralnic.com"
+Whois::Server.define :tld, ".us.org", "whois.centralnic.com"
 Whois::Server.define :tld, ".uy.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".za.com", "whois.centralnic.com"
 Whois::Server.define :tld, ".com", "whois.crsnic.net", { :adapter => Whois::Server::Adapters::Verisign}
@@ -234,12 +237,12 @@ Whois::Server.define :tld, ".ps", "whois.pnina.ps"
 Whois::Server.define :tld, ".pt", "whois.dns.pt"
 Whois::Server.define :tld, ".pw", nil, { :adapter => Whois::Server::Adapters::None }
 Whois::Server.define :tld, ".py", nil, { :web => "http://www.nic.py/consultas.html", :adapter => Whois::Server::Adapters::Web }
-Whois::Server.define :tld, ".qa", nil, { :adapter => Whois::Server::Adapters::None }
+Whois::Server.define :tld, ".qa", "whois.registry.qa"
 Whois::Server.define :tld, ".re", "whois.nic.fr"
 Whois::Server.define :tld, ".ro", "whois.rotld.ro"
 Whois::Server.define :tld, ".rs", nil, { :web => "http://www.nic.rs/en/whois", :adapter => Whois::Server::Adapters::Web }
 Whois::Server.define :tld, ".edu.ru", "whois.informika.ru"
-Whois::Server.define :tld, ".ru", "whois.ripn.net"
+Whois::Server.define :tld, ".ru", "whois.tcinet.ru"
 Whois::Server.define :tld, ".rw", nil, { :adapter => Whois::Server::Adapters::Web, :web => "http://www.nic.rw/cgi-bin/whois.pl"}
 Whois::Server.define :tld, ".sa", "saudinic.net.sa"
 Whois::Server.define :tld, ".sb", "whois.nic.net.sb"
@@ -257,7 +260,7 @@ Whois::Server.define :tld, ".sn", "whois.nic.sn"
 Whois::Server.define :tld, ".so", "whois.nic.so"
 Whois::Server.define :tld, ".sr", nil, { :adapter => Whois::Server::Adapters::None }
 Whois::Server.define :tld, ".st", "whois.nic.st"
-Whois::Server.define :tld, ".su", "whois.ripn.net"
+Whois::Server.define :tld, ".su", "whois.tcinet.ru"
 Whois::Server.define :tld, ".sv", nil, { :web => "http://www.uca.edu.sv/dns/", :adapter => Whois::Server::Adapters::Web }
 Whois::Server.define :tld, ".sy", nil, { :adapter => Whois::Server::Adapters::None }
 Whois::Server.define :tld, ".sz", nil, { :adapter => Whois::Server::Adapters::None }
@@ -335,12 +338,14 @@ Whois::Server.define :tld, ".xn--mgbbh1a71e", nil, { :adapter => Whois::Server::
 Whois::Server.define :tld, ".xn--mgberp4a5d4ar", "whois.nic.net.sa"
 Whois::Server.define :tld, ".xn--o3cw4h", "whois.thnic.co.th"
 Whois::Server.define :tld, ".xn--ogbpf8fl", nil, { :adapter => Whois::Server::Adapters::None }
-Whois::Server.define :tld, ".xn--p1ai", "whois.ripn.net"
+Whois::Server.define :tld, ".xn--p1ai", "whois.tcinet.ru"
 Whois::Server.define :tld, ".xn--pgbs0dh", nil, { :adapter => Whois::Server::Adapters::None }
 Whois::Server.define :tld, ".xn--s9brj9c", nil, { :adapter => Whois::Server::Adapters::None }
 Whois::Server.define :tld, ".xn--wgbh1c", "whois.dotmasr.eg"
-Whois::Server.define :tld, ".xn--wgbl6a", nil, { :adapter => Whois::Server::Adapters::None }
+Whois::Server.define :tld, ".xn--wgbl6a", "whois.registry.qa"
+Whois::Server.define :tld, ".xn--lgbbat1ad8j", "whois.nic.dz"
 Whois::Server.define :tld, ".xn--xkc2al3hye2a", nil, { :adapter => Whois::Server::Adapters::None }
 Whois::Server.define :tld, ".xn--xkc2dl3a5ee0h", nil, { :adapter => Whois::Server::Adapters::None }
+Whois::Server.define :tld, ".xn--mgbc0a9azcg", nil, { :adapter => Whois::Server::Adapters::None }
 Whois::Server.define :tld, ".xn--yfro4i67o", "whois.sgnic.sg"
 Whois::Server.define :tld, ".xn--ygbi2ammx", "whois.pnina.ps"

data/lib/whois/record.rb

@@ -67,9 +67,6 @@ module Whois
         true
       elsif other.is_a?(self.class)
         to_s == other.to_s
-      elsif other.is_a?(String)
-        Whois.deprecate "Comparing an record with a String is deprecated and will be removed in Whois 2.1."
-        to_s == other.to_s
       else
         false
       end

data/lib/whois/record/parser.rb

@@ -283,10 +283,10 @@ module Whois
           elsif parser = select_parser(method, :supported)
             parser.send(method, *args, &block)
 
-          # Select a parser where the property is defined
-          # (but not supported) and call the method.
+          # Select a parser where the property is defined but not supported
+          # and call the method.
           # The call is expected to raise an exception.
-          elsif parser = select_parser(method)
+          elsif parser = select_parser(method, :not_supported)
             parser.send(method, *args, &block)
 
           # The property is not supported nor defined.

data/lib/whois/record/parser/NOTES.txt

@@ -6,10 +6,24 @@
 - verisign : indented keyvalue with text
 - cnnic : keyvalue
 - biz : keyvalue + lastupdate + disclaimer
-- info : disclaimer + keyvalue
 
 ---
 
+# afilias
+- whois.aero
+- whois.afilias-grs.info
+- whois.afilias.info
+- whois.nic.ag
+- whois.registry.in
+# also
+- whois.nic.xxx
+- whois.dotmobyregistry.net
+- whois.publicinternetregistry.org
+# also
+- whois.nic.asia
+- whois.meregistry.net
+
+
 .us
 .biz
 .travel
@@ -21,13 +35,6 @@ whois.cat
 .ve
 .uy
 
-# afilias
-whois.dotmobyregistry.net
-whois.afilias.info
-whois.afilias-grs.info
-whois.aero
-whois.nic.xxx
-
 whois.nic.af
 whois.nic.mu
 whois.nic.gl

data/lib/whois/record/parser/base.rb

@@ -11,7 +11,7 @@ require 'time'
 require 'whois/record/contact'
 require 'whois/record/registrar'
 require 'whois/record/nameserver'
-require 'whois/record/parser/features/ast'
+require 'whois/record/parser/scanners/ast'
 
 
 module Whois
@@ -19,41 +19,18 @@ module Whois
     class Parser
 
 
-      # This class is intended to be the base abstract class for all
+      # Represents the abstract base parser class for all
       # server-specific parser implementations.
       #
-      # == Available Methods
-      #
-      # The Base class is for the most part auto-generated via meta programming.
+      # NOTE. This class is for the most part auto-generated via meta programming.
       # This is the reason why RDoc can't detect and document all available methods.
       #
+      # @abstract
+      #
       class Base
 
-        @@property_registry = {}
-
-        # Returns the <tt>@@property_registry</tt> if <tt>klass</tt> is nil,
-        # otherwise returns the value in <tt>@@property_registry</tt> for given <tt>klass</tt>.
-        # <tt>klass</tt> is expected to be a class name.
-        #
-        # Returned value is always a hash. If <tt>@@property_registry[klass]</tt>
-        # doesn't exist, this method automatically initializes it to an empty Hash.
-        #
-        # @param  [Class] klass
-        # @return [Hash]
-        #
-        # @example Get the full registry
-        #   property_registry
-        #
-        # @example Get the registry for a specfic Class
-        #   property_registry(ParserClass)
-        #
-        def self.property_registry(klass = nil)
-          if klass.nil?
-            @@property_registry
-          else
-            @@property_registry[klass] ||= {}
-          end
-        end
+        class_attribute :_properties
+        self._properties = {}
 
         # Returns the status for the +property+ passed as symbol.
         #
@@ -70,11 +47,11 @@ module Whois
         #   # => :supported
         #
         def self.property_status(property)
-          property_registry(self)[property]
+          self._properties[property]
         end
 
         # Check if the +property+ passed as symbol
-        # is registered in the +property_registry+ for current parser.
+        # is registered in the registry for current parser.
         #
         # @param  [Symbol] property
         # @param  [Symbol] status
@@ -91,9 +68,9 @@ module Whois
         #
         def self.property_registered?(property, status = :any)
           if status == :any
-            property_registry(self).key?(property)
+            self._properties.key?(property)
           else
-            property_registry(self)[property] == status
+            self._properties[property] == status
           end
         end
 
@@ -105,7 +82,7 @@ module Whois
         # @return [void]
         #
         def self.property_register(property, status)
-          property_registry(self).merge!({ property => status })
+          self._properties = self._properties.merge({ property => status })
         end
 
 

data/lib/whois/record/parser/base_afilias.rb

@@ -0,0 +1,156 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2011 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require 'whois/record/parser/base'
+require 'whois/record/parser/scanners/afilias'
+
+
+module Whois
+  class Record
+    class Parser
+
+      # Base parser for Afilias servers.
+      #
+      # @abstract
+      #
+      class BaseAfilias < Base
+        include Scanners::Ast
+
+
+        property_supported :disclaimer do
+          node("property:disclaimer")
+        end
+
+
+        property_supported :domain do
+          node("Domain Name", &:downcase)
+        end
+
+        property_supported :domain_id do
+          node("Domain ID")
+        end
+
+
+        property_not_supported :referral_whois
+
+        property_not_supported :referral_url
+
+
+        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|
+            Time.parse(value)
+          end
+        end
+
+        property_supported :updated_on do
+          node("Last Updated On") do |value|
+            Time.parse(value)
+          end
+        end
+
+        property_supported :expires_on do
+          node("Expiration Date") do |value|
+            Time.parse(value)
+          end
+        end
+
+
+        property_supported :registrar do
+          node("Sponsoring Registrar") do |value|
+            parts = decompose_registrar(value) ||
+                Whois.bug!(ParserError, "Unknown registrar format `#{value}'")
+
+            Record::Registrar.new(
+              :id =>            parts[0],
+              :name =>          parts[1],
+              :organization =>  parts[1]
+            )
+          end
+        end
+
+        property_supported :registrant_contacts do
+          contact("Registrant", Whois::Record::Contact::TYPE_REGISTRANT)
+        end
+
+        property_supported :admin_contacts do
+          contact("Admin", Whois::Record::Contact::TYPE_ADMIN)
+        end
+
+        property_supported :technical_contacts do
+          contact("Tech", Whois::Record::Contact::TYPE_TECHNICAL)
+        end
+
+
+        property_supported :nameservers do
+          Array.wrap(node("Name Server")).reject(&:empty?).map do |name|
+            Nameserver.new(name.downcase)
+          end
+        end
+
+
+        # Initializes a new {Scanners::Afilias} instance
+        # passing the {#content_for_scanner}
+        # and calls +parse+ on it.
+        #
+        # @return [Hash]
+        def parse
+          Scanners::Afilias.new(content_for_scanner).parse
+        end
+
+
+        private
+
+          def 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")
+
+              Record::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/Province"),
+                :country_code => node("#{element} Country"),
+                :phone        => node("#{element} Phone"),
+                :fax          => node("#{element} FAX"),
+                :email        => node("#{element} Email")
+              )
+            end
+          end
+  
+          def decompose_registrar(value)
+            if value =~ /(.+?) \((.+?)\)/
+              [$2, $1]
+            end
+          end
+
+      end
+
+    end
+  end
+end

data/lib/whois/record/parser/example.rb

@@ -14,12 +14,16 @@ module Whois
   class Record
     class Parser
 
-      #
-      # = whois.example.com parser
-      #
       # Parser for the whois.example.com server.
+      #--
+      # In case you are not implementing all the methods,
+      # please add the following statement to the class docblock.
       #
-      class WhoisExampleCom < Base
+      # @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.
+      # ++
+      class Example < Base
 
         # Gets the registry disclaimer that comes with the record.
         #

data/lib/whois/record/parser/jobswhois.verisign-grs.com.rb

@@ -21,7 +21,7 @@ module Whois
       # Parser for the jobswhois.verisign-grs.com server.
       #
       class JobswhoisVerisignGrsCom < Base
-        include Features::Ast
+        include Scanners::Ast
 
         property_supported :disclaimer do
           node("Disclaimer")
@@ -87,7 +87,7 @@ module Whois
 
 
         # Initializes a new {Scanners::Verisign} instance
-        # passing the {Whois::Record::Parser::Base#content_for_scanner}
+        # passing the {#content_for_scanner}
         # and calls +parse+ on it.
         #
         # @return [Hash]

data/lib/whois/record/parser/scanners/afilias.rb

@@ -19,25 +19,34 @@ module Whois
 
           def parse_content
             parse_available   ||
+            parse_throttled   ||  # .ORG
             parse_disclaimer  ||
             parse_keyvalue    ||
-            trim_newline      ||
+
+            trim_empty_line   ||
             error!("Unexpected token")
           end
 
           def parse_available
             if @input.scan(/^NOT FOUND\n/)
-              @ast["status-available"] = true
+              @ast["status:available"] = true
+            end
+          end
+
+          def parse_throttled
+            if @input.match?(/^WHOIS LIMIT EXCEEDED/)
+              @ast["response:throttled"] = true
+              @input.skip(/^.+\n/)
             end
           end
 
           def parse_disclaimer
-            if @input.match?(/^Access to/)
+            if @input.pos == 0
               lines = []
               while @input.scan(/^(.+)\n/)
                 lines << @input[1].strip
               end
-              @ast["property-disclaimer"] = lines.join(" ")
+              @ast["property:disclaimer"] = lines.join(" ")
             end
           end