whois 0.5.3 → 0.8.0

data/lib/whois/server.rb

@@ -17,7 +17,6 @@
 require 'ipaddr'
 require 'whois/server/adapters/base'
 require 'whois/server/adapters/afilias'
-require 'whois/server/adapters/arpa'
 require 'whois/server/adapters/formatted'
 require 'whois/server/adapters/none'
 require 'whois/server/adapters/not_implemented'

data/lib/whois/server/adapters/afilias.rb

@@ -22,11 +22,11 @@ module Whois
 
         def request(qstring)
           response = ask_the_socket(qstring, "whois.afilias-grs.info", DEFAULT_WHOIS_PORT)
-          endpoint = extract_referral(response)
-          if endpoint
-            response + "\n" + ask_the_socket(qstring, endpoint, DEFAULT_WHOIS_PORT)
-          else
-            response
+          append_to_buffer response, "whois.afilias-grs.info"
+
+          if endpoint = extract_referral(response)
+            response = ask_the_socket(qstring, endpoint, DEFAULT_WHOIS_PORT)
+            append_to_buffer response, endpoint
           end
         end
 

data/lib/whois/server/adapters/base.rb

@@ -14,38 +14,65 @@
 #++
 
 
+require 'whois/answer/part'
+require 'whois/answer'
+
+
 module Whois
   class Server
     module Adapters
       
       class Base
 
+        # Default Whois request port.
         DEFAULT_WHOIS_PORT = 43
 
         attr_reader :type
         attr_reader :allocation
         attr_reader :host
         attr_reader :options
+        attr_reader :buffer
 
-        
         def initialize(type, allocation, host, options = {})
           @type       = type
           @allocation = allocation
           @host       = host
           @options    = options || {}
         end
-        
+
+        # Performs a Whois query for <tt>qstring</tt> 
+        # using current server adapter and returns a <tt>Whois::Response</tt>
+        # instance with the result of the request.
+        #
+        # server.query("google.com")
+        # # => Whois::Response
+        #
         def query(qstring)
-          request(qstring)
+          with_buffer do |buffer|
+            request(qstring)
+            Answer.new(self, buffer)
+          end
         end
 
         def request(qstring)
           raise NotImplementedError
         end
 
-        
+
         protected
 
+          def with_buffer(&block)
+            @buffer = []
+            result = yield(@buffer)
+            # @buffer = []
+            # result
+          end
+          
+          # Store an answer part in <tt>@buffer</tt>.
+          def append_to_buffer(response, host)
+            @buffer << ::Whois::Answer::Part.new(response, host)
+          end
+
           def query_the_socket(qstring, host, port = nil)
             ask_the_socket(qstring, host, port || options[:port] || DEFAULT_WHOIS_PORT)
           end

data/lib/whois/server/adapters/formatted.rb

@@ -21,7 +21,9 @@ module Whois
       class Formatted < Base
         
         def request(qstring)
-          query_the_socket(sprintf(options[:format], qstring), host)
+          options[:format] || raise(ServerError, "Missing mandatory :format option for adapter `Formatted'")
+          response = query_the_socket(sprintf(options[:format], qstring), host)
+          append_to_buffer response, host
         end
         
       end

data/lib/whois/server/adapters/none.rb

@@ -17,9 +17,28 @@
 module Whois
   class Server
     module Adapters
-      
+
+      #
+      # = None Adapter
+      #
+      # Special adapter intended to be used when a WHOIS interface
+      # doesn't exist for given query.
+      # For example, the domain authority for some TLD doesn't offer
+      # any way to query for WHOIS data.
+      #
+      # In case the authority provides only a web based interface,
+      # you should use the <tt>Whois::Server::Adapters::Web</tt> adapter.
+      #
+      # Every query for an object associated to a <tt>Whois::Server::Adapters::None</tt>
+      # adapter raises a <tt>Whois::NoInterfaceError</tt> exception.
+      #
       class None < Base
         
+        # Always raises a <tt>Whois::NoInterfaceError</tt> exception.
+        #
+        # ==== Raises
+        # NoInterfaceError:: for every request
+        #
         def request(qstring)
           raise NoInterfaceError, "This `#{type}' has no whois server"
         end

data/lib/whois/server/adapters/pir.rb

@@ -22,11 +22,11 @@ module Whois
 
         def request(qstring)
           response = ask_the_socket("FULL #{qstring}", "whois.publicinterestregistry.net", DEFAULT_WHOIS_PORT)
-          endpoint = extract_referral(response)
-          if endpoint
-            response + "\n" + ask_the_socket(qstring, endpoint, DEFAULT_WHOIS_PORT)
-          else
-            response
+          append_to_buffer response, "whois.publicinterestregistry.net"
+
+          if endpoint = extract_referral(response)
+            response = ask_the_socket(qstring, endpoint, DEFAULT_WHOIS_PORT)
+            append_to_buffer response, endpoint
           end
         end
 

data/lib/whois/server/adapters/standard.rb

@@ -17,11 +17,22 @@
 module Whois
   class Server
     module Adapters
-      
+
+      #
+      # = Standard Adapter
+      #
+      # Provides ability to query standard WHOIS interfaces.
+      # A standard WHOIS interface accepts socket requests containing the name of the domain
+      # and returns a single response containing the answer for given query.
+      #
+      # By default the interface should listen on port 43.
+      # This adapter also supports an optional port number.
+      #
       class Standard < Base
         
         def request(qstring)
-          query_the_socket(qstring, host)
+          response = query_the_socket(qstring, host)
+          append_to_buffer response, host
         end
         
       end

data/lib/whois/server/adapters/verisign.rb

@@ -22,11 +22,11 @@ module Whois
         
         def request(qstring)
           response = ask_the_socket("=#{qstring}", host, DEFAULT_WHOIS_PORT)
-          endpoint = extract_referral(response)
-          if endpoint
-            response + "\n" + ask_the_socket(qstring, endpoint, DEFAULT_WHOIS_PORT)
-          else
-            response
+          append_to_buffer response, host
+
+          if endpoint = extract_referral(response)
+            response = ask_the_socket(qstring, endpoint, DEFAULT_WHOIS_PORT)
+            append_to_buffer response, endpoint
           end
         end
 

data/lib/whois/server/adapters/web.rb

@@ -18,8 +18,23 @@ module Whois
   class Server
     module Adapters
       
+      #
+      # = Web Adapter
+      #
+      # Special adapter intended to be used when you can only access
+      # the WHOIS database via an online interface.
+      #
+      # This adapter should be considered a <tt>Whois::Server::Adapters::None</tt>
+      # adapter a little more specific.
+      #
       class Web < Base
         
+        # Always raises a <tt>Whois::WebInterfaceError</tt> exception
+        # including the web address for the WHOIS inteface.
+        #
+        # ==== Raises
+        # WebInterfaceError:: for every request
+        #
         def request(qstring)
           raise WebInterfaceError,  "This TLD has no whois server, " +
                                     "but you can access the whois database at `#{options[:web]}'"

data/lib/whois/version.rb

@@ -18,8 +18,8 @@ module Whois
 
   module Version
     MAJOR = 0
-    MINOR = 5
-    TINY  = 3
+    MINOR = 8
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/whois/whois.rb

@@ -69,7 +69,7 @@ module Whois
   # If you want to save keystrokes, you can even use the handy <tt>Whois.query</tt> method.
   #
   #   Whois.query '72.14.207.99'
-  #   # => whois response
+  #   # => whois answer
   #
   class Whois # :nodoc
 
@@ -120,7 +120,7 @@ module Whois
     end
 
     def all
-      ::Whois.deprecate "#all will be removed in a future release. You are responsible for storing the whois response in a custom variable."
+      ::Whois.deprecate "#all will be removed in a future release. You are responsible for storing the whois answer in a custom variable."
       @all
     end
 

data/test/answer/parser/base_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+require 'whois/answer/parser/base'
+
+class AnswerParserBaseTest < Test::Unit::TestCase
+
+  def setup
+    @klass  = Whois::Answer::Parser::Base
+    @part   = Whois::Answer::Part.new("This is the response.", "whois.foo.com")
+  end
+
+
+  def test_initialize
+    parser = @klass.new(@part)
+    assert_instance_of @klass, parser
+  end
+
+  def test_initialize_should_require_part
+    assert_raise(ArgumentError) { @klass.new }
+  end
+
+
+  def test_content
+    parser = @klass.new(@part)
+    assert_equal @part.response, parser.content
+  end
+
+end

data/test/answer/parser/blank_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+require 'whois/answer/parser/blank'
+
+class AnswerParserBlankTest < Test::Unit::TestCase
+
+  def setup
+    @klass  = Whois::Answer::Parser::Blank
+    @part   = Whois::Answer::Part.new("This is the response.", "whois.foo.com")
+  end
+
+  Whois::Answer::Parser.registrable_methods.each do |method|
+    define_method "test_#{method}_should_raise" do
+      parser = @klass.new(@part)
+      error  = assert_raise(Whois::ParserNotFound) { parser.send(method) }
+      assert_match "whois.foo.com", error.message
+    end
+  end
+
+end

data/test/answer/parser/whois_crsnic_net_test.rb

@@ -0,0 +1,175 @@
+require 'test_helper'
+require 'whois/answer/parser/whois.crsnic.net'
+
+class AnswerParserWhoisCrsnicNetTest < Test::Unit::TestCase
+
+  TESTCASE_PATH = File.expand_path(File.dirname(__FILE__) + '/../../testcases/responses/whois.crsnic.net')
+
+  def setup
+    @klass  = Whois::Answer::Parser::WhoisCrsnicNet
+    @host   = "whois.crsnic.net"
+  end
+
+
+  def test_disclaimer
+    expected = <<-EOS.strip
+TERMS OF USE: You are not authorized to access or query our Whois \
+database through the use of electronic processes that are high-volume and \
+automated except as reasonably necessary to register domain names or \
+modify existing registrations; the Data in VeriSign Global Registry \
+Services' ("VeriSign") Whois database is provided by VeriSign for \
+information purposes only, and to assist persons in obtaining information \
+about or related to a domain name registration record. VeriSign does not \
+guarantee its accuracy. By submitting a Whois query, you agree to abide \
+by the following terms of use: You agree that you may use this Data only \
+for lawful purposes and that under no circumstances will you use this Data \
+to: (1) allow, enable, or otherwise support the transmission of mass \
+unsolicited, commercial advertising or solicitations via e-mail, telephone, \
+or facsimile; or (2) enable high volume, automated, electronic processes \
+that apply to VeriSign (or its computer systems). The compilation, \
+repackaging, dissemination or other use of this Data is expressly \
+prohibited without the prior written consent of VeriSign. You agree not to \
+use electronic processes that are automated and high-volume to access or \
+query the Whois database except as reasonably necessary to register \
+domain names or modify existing registrations. VeriSign reserves the right \
+to restrict your access to the Whois database in its sole discretion to ensure \
+operational stability.  VeriSign may restrict or terminate your access to the \
+Whois database for failure to abide by these terms of use. VeriSign \
+reserves the right to modify these terms at any time.
+EOS
+    assert_equal  expected,
+                  @klass.new(load_part('/registered.txt')).disclaimer
+  end
+
+  def test_disclaimer_with_available
+    expected = <<-EOS.strip
+TERMS OF USE: You are not authorized to access or query our Whois \
+database through the use of electronic processes that are high-volume and \
+automated except as reasonably necessary to register domain names or \
+modify existing registrations; the Data in VeriSign Global Registry \
+Services' ("VeriSign") Whois database is provided by VeriSign for \
+information purposes only, and to assist persons in obtaining information \
+about or related to a domain name registration record. VeriSign does not \
+guarantee its accuracy. By submitting a Whois query, you agree to abide \
+by the following terms of use: You agree that you may use this Data only \
+for lawful purposes and that under no circumstances will you use this Data \
+to: (1) allow, enable, or otherwise support the transmission of mass \
+unsolicited, commercial advertising or solicitations via e-mail, telephone, \
+or facsimile; or (2) enable high volume, automated, electronic processes \
+that apply to VeriSign (or its computer systems). The compilation, \
+repackaging, dissemination or other use of this Data is expressly \
+prohibited without the prior written consent of VeriSign. You agree not to \
+use electronic processes that are automated and high-volume to access or \
+query the Whois database except as reasonably necessary to register \
+domain names or modify existing registrations. VeriSign reserves the right \
+to restrict your access to the Whois database in its sole discretion to ensure \
+operational stability.  VeriSign may restrict or terminate your access to the \
+Whois database for failure to abide by these terms of use. VeriSign \
+reserves the right to modify these terms at any time.
+EOS
+    assert_equal  expected,
+                  @klass.new(load_part('/available.txt')).disclaimer
+  end
+
+
+  def test_domain
+    assert_equal  "googlelkjhgfdfghjklkjhgf.net",
+                  @klass.new(load_part('/available.txt')).domain
+    assert_equal  "google.net",
+                  @klass.new(load_part('/registered.txt')).domain
+  end
+
+  def test_domain_id
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).domain_id
+    assert_equal  nil,
+                  @klass.new(load_part('/registered.txt')).domain_id
+  end
+
+
+  def test_referral_whois
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).referral_whois
+    assert_equal  "whois.markmonitor.com",
+                  @klass.new(load_part('/registered.txt')).referral_whois
+  end
+
+  def test_referral_url
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).referral_url
+    assert_equal  "http://www.markmonitor.com",
+                  @klass.new(load_part('/registered.txt')).referral_url
+  end
+
+
+  def test_status
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).status
+    assert_equal  ["clientDeleteProhibited", "clientTransferProhibited", "clientUpdateProhibited"],
+                  @klass.new(load_part('/registered.txt')).status
+  end
+
+  def test_available?
+    assert !@klass.new(load_part('/registered.txt')).available?
+    assert  @klass.new(load_part('/available.txt')).available?
+  end
+
+  def test_registered?
+    assert !@klass.new(load_part('/available.txt')).registered?
+    assert  @klass.new(load_part('/registered.txt')).registered?
+  end
+
+
+  def test_created_on
+    assert_equal  Time.parse("1999-03-15 00:00:00"),
+                  @klass.new(load_part('/registered.txt')).created_on
+  end
+
+  def test_created_on_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).created_on
+  end
+
+  def test_updated_on
+    assert_equal  Time.parse("2009-02-10 00:00:00"),
+                  @klass.new(load_part('/registered.txt')).updated_on
+  end
+
+  def test_updated_on_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).updated_on
+  end
+
+  def test_expires_on
+    assert_equal  Time.parse("2010-03-15 00:00:00"),
+                  @klass.new(load_part('/registered.txt')).expires_on
+  end
+
+  def test_expires_on_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).expires_on
+  end
+
+
+  def test_registrar
+    assert_equal  nil,
+                  @klass.new(load_part('/registered.txt')).registrar
+  end
+
+  def test_registrar_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).registrar
+  end
+
+
+  protected
+
+    def load_part(path)
+      part(File.read(TESTCASE_PATH + path), @host)
+    end
+
+    def part(*args)
+      Whois::Answer::Part.new(*args)
+    end
+
+end