whois 2.6.3 → 2.6.4

data/lib/whois/record/parser/whois.rnids.rs.rb

@@ -43,8 +43,14 @@ module Whois
           case node("Domain status", &:downcase)
           when nil
             :available
-          when "active"
+          when 'active'
             :registered
+          when 'locked'
+            :registered
+          when 'in transfer'
+            :registered
+          when 'expired'
+            :expired
           else
             Whois.bug!(ParserError, "Unknown status `#{node("Domain status")}'.")
           end

data/lib/whois/record/parser/whois.tcinet.ru.rb

@@ -68,16 +68,20 @@ module Whois
 
 
         property_supported :admin_contacts do
-          content_for_scanner.scan(/e-mail:\s+(.+)\n/).flatten.map do |email|
+          url   = content_for_scanner[/admin-contact:\s+(.+)\n/, 1]
+          email = content_for_scanner[/e-mail:\s+(.+)\n/, 1]
+          contact = if url or email
             Record::Contact.new(
               :type         => Record::Contact::TYPE_ADMIN,
+              :url          => url,
+              :email        => email,
               :name         => content_for_scanner[/person:\s+(.+)\n/, 1],
               :organization => content_for_scanner[/org:\s+(.+)\n/, 1],
               :phone        => content_for_scanner[/phone:\s+(.+)\n/, 1],
-              :fax          => content_for_scanner[/fax-no:\s+(.+)\n/, 1],
-              :email        => email
+              :fax          => content_for_scanner[/fax-no:\s+(.+)\n/, 1]
             )
           end
+          Array.wrap(contact)
         end
 
         property_not_supported :registrant_contacts

data/lib/whois/record/parser/whois.tld.ee.rb

@@ -7,8 +7,8 @@
 #++
 
 
-require 'whois/record/parser/base'
-require 'whois/record/scanners/whois.tld.ee.rb'
+require 'whois/record/parser/base_whoisd'
+require 'whois/record/scanners/whoisd.rb'
 
 
 module Whois
@@ -16,118 +16,13 @@ module Whois
     class Parser
 
       # Parser for the whois.tld.ee server.
+      # 
+      # @see Whois::Record::Parser::Example
+      #   The Example parser for the list of all available methods.
       #
-      # 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 WhoisTldEe < Base
-        include Scanners::Ast
-
-        property_supported :status do
-          if content_for_scanner =~ /status:\s+(.+)\n/
-            case $1.downcase
-              when "paid and in zone" then :registered
-              # NEWSTATUS (redemption?)
-              when "expired" then :expired
-              else
-                Whois.bug!(ParserError, "Unknown status `#{$1}'.")
-            end
-          else
-            :available
-          end
-        end
-
-        property_supported :available? do
-          !!(content_for_scanner =~ /^%ERROR:101: no entries found/)
-        end
-
-        property_supported :registered? do
-          !available?
-        end
-
-
-        property_supported :created_on do
-          if content_for_scanner =~ /registered:\s+(.+?)\n/
-            Time.parse($1)
-          end
-        end
-
-        property_supported :updated_on do
-          if content_for_scanner =~ /changed:\s+(.+?)\n/
-            Time.parse($1)
-          end
-        end
-
-        property_supported :expires_on do
-          if content_for_scanner =~ /expire:\s+(.+?)\n/
-            Time.parse($1)
-          end
-        end
-
-
-        property_supported :registrar do
-          if content_for_scanner =~ /registrar:\s+(.+)\n/
-            Whois::Record::Registrar.new(
-                :id           => $1,
-                :name         => $1
-            )
-          end
-        end
-
-        property_supported :admin_contacts do
-          if content_for_scanner =~ /admin-c:\s+(.+)\n/
-            build_contact($1, Whois::Record::Contact::TYPE_ADMIN)
-          end
-        end
-
-        property_supported :registrant_contacts do
-          if content_for_scanner =~ /registrant:\s+(.+)\n/
-            build_contact($1, Whois::Record::Contact::TYPE_REGISTRANT)
-          end
-        end
-
-        property_not_supported :technical_contacts
-
-
-        property_supported :nameservers do
-          content_for_scanner.scan(/nserver:\s+(.+)\n/).flatten.map do |line|
-            if line =~ /(.+) \((.+)\)/
-              Record::Nameserver.new(:name => $1, :ipv4 => $2)
-            else
-              Record::Nameserver.new(:name => line)
-            end
-          end
-        end
-
-
-        # Initializes a new {Scanners::WhoisTldEe} instance
-        # passing the {#content_for_scanner}
-        # and calls +parse+ on it.
-        #
-        # @return [Hash]
-        def parse
-          Scanners::WhoisTldEe.new(content_for_scanner).parse
-        end
-
-
-      private
-
-        def build_contact(element, type)
-          node(element) do |raw|
-            Record::Contact.new(
-                :type           => type,
-                :id             => element,
-                :name           => raw["name"],
-                :organization   => raw["org"],
-                :created_on     => Time.parse(raw["created"])
-            )
-          end
-        end
-
+      class WhoisTldEe < BaseWhoisd
       end
+
     end
   end
 end

data/lib/whois/record/parser/whois.tznic.or.tz.rb

@@ -7,76 +7,19 @@
 #++
 
 
-require 'whois/record/parser/base'
+require 'whois/record/parser/base_whoisd'
 
 
 module Whois
   class Record
     class Parser
 
-      #
-      # = whois.tznic.or.tz parser
-      #
       # Parser for the whois.tznic.or.tz server.
+      # 
+      # @see Whois::Record::Parser::Example
+      #   The Example parser for the list of all available methods.
       #
-      # 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 WhoisTznicOrTz < Base
-
-        property_supported :status do
-          if content_for_scanner =~ /status:\s+(.+)\n/
-            case $1.downcase
-            when "paid and in zone"
-              :registered
-            # NEWSTATUS (redemption?)
-            when "expired"
-              :expired
-            else
-              Whois.bug!(ParserError, "Unknown status `#{$1}'.")
-            end
-          else
-            :available
-          end
-        end
-
-        property_supported :available? do
-          !!(content_for_scanner =~ /^%ERROR:101: no entries found/)
-        end
-
-        property_supported :registered? do
-          !available?
-        end
-
-
-        property_supported :created_on do
-          if content_for_scanner =~ /registered:\s+(.+?)\n/
-            Time.parse($1)
-          end
-        end
-
-        property_supported :updated_on do
-          if content_for_scanner =~ /changed:\s+(.+?)\n/
-            Time.parse($1)
-          end
-        end
-
-        property_supported :expires_on do
-          if content_for_scanner =~ /expire:\s+(.+?)\n/
-            Time.parse($1)
-          end
-        end
-
-
-        property_supported :nameservers do
-          content_for_scanner.scan(/nserver:\s+(.+)\n/).flatten.map do |name|
-            Record::Nameserver.new(:name => name.strip)
-          end
-        end
-
+      class WhoisTznicOrTz < BaseWhoisd
       end
 
     end

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

@@ -47,14 +47,18 @@ module Whois
           @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/)
             key, value = @input[1].strip, @input[2].strip
-            if @ast[key].nil?
-              @ast[key] = value
+            target = @tmp['_section'] ? (@ast[@tmp['_section']] ||= {}) : @ast
+
+            if target[key].nil?
+              target[key] = value
             else
-              @ast[key] = Array.wrap(@ast[key])
-              @ast[key] << value
+              target[key] = Array.wrap(target[key])
+              target[key] << value
             end
           end
         end

data/lib/whois/record/scanners/whois.rnids.rs.rb

@@ -23,7 +23,7 @@ module Whois
             :scan_available,
             :skip_comment,
             :flag_section_start,
-            :scan_section_keyvalue,
+            :scan_keyvalue,
             :flag_section_end,
             :skip_empty_line,
             :skip_privacy,
@@ -40,28 +40,14 @@ module Whois
 
         tokenizer :flag_section_start do
           if SECTIONS.any? { |section| @input.check(/^(#{section}):/) }
-            @tmp["section"] = @input[1]
+            @tmp['_section'] = @input[1]
           end
           false
         end
 
         tokenizer :flag_section_end do
           if @input.match?(/^\n/)
-            @tmp.delete("section")
-          end
-        end
-
-        tokenizer :scan_section_keyvalue do
-          if @input.scan(/(.+?):(.*?)\n/)
-            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
+            @tmp.delete('_section')
           end
         end
 

data/lib/whois/record/scanners/whoisd.rb

@@ -0,0 +1,56 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2012 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require 'whois/record/scanners/base'
+
+
+module Whois
+  class Record
+    module Scanners
+
+      # Scanner for Whoisd-based record.
+      class Whoisd < 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):\s+(.+)\n/)
+            @tmp['_section'] = @input[1].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
+end

data/lib/whois/server.rb

@@ -29,7 +29,6 @@ module Whois
       autoload :Formatted,        "whois/server/adapters/formatted"
       autoload :None,             "whois/server/adapters/none"
       autoload :NotImplemented,   "whois/server/adapters/not_implemented"
-      autoload :Pir,              "whois/server/adapters/pir"
       autoload :Standard,         "whois/server/adapters/standard"
       autoload :Verisign,         "whois/server/adapters/verisign"
       autoload :Web,              "whois/server/adapters/web"
@@ -120,7 +119,7 @@ module Whois
     #   # 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/"
+    #     :url => "http://www.nic.ar/"
     #
     def self.define(type, allocation, host, options = {})
       @@definitions[type] ||= []
@@ -164,7 +163,9 @@ module Whois
     #
     def self.factory(type, allocation, host, options = {})
       options = options.dup
-      (options.delete(:adapter) || Adapters::Standard).new(type, allocation, host, options)
+      adapter = options.delete(:adapter) || Adapters::Standard
+      adapter = Adapters.const_get(camelize(adapter)) unless adapter.respond_to?(:new)
+      adapter.new(type, allocation, host, options)
     end
 
 
@@ -225,6 +226,11 @@ module Whois
 
   private
 
+    def self.camelize(string)
+      string.to_s.split("_").collect(&:capitalize).join
+    end
+
+
     def self.matches_tld?(string)
       string =~ /^\.(xn--)?[a-z0-9]+$/
     end

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

@@ -31,11 +31,11 @@ module Whois
         # @return [void]
         #
         def request(string)
-          response = query_the_socket(string, host, DEFAULT_WHOIS_PORT)
+          response = query_the_socket(string, host)
           buffer_append response, host
 
           if endpoint = extract_referral(response)
-            response = query_the_socket(string, endpoint, DEFAULT_WHOIS_PORT)
+            response = query_the_socket(string, endpoint)
             buffer_append response, endpoint
           end
         end

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

@@ -71,6 +71,7 @@ module Whois
         #
         # @return [Boolean] Returns true if the other is the same object,
         #         or <tt>other</tt> attributes matches this object attributes.
+        #
         def ==(other)
           (
             self.equal?(other)
@@ -90,6 +91,7 @@ module Whois
         #
         # @param  [Hash] settings
         # @return [Hash] The updated options for this object.
+        #
         def configure(settings)
           options.merge!(settings)
         end
@@ -126,12 +128,13 @@ module Whois
         # @raise  [NotImplementedError]
         # @return [void]
         # @abstract
+        #
         def request(string)
           raise NotImplementedError
         end
 
 
-        private
+      private
 
         # Store a record part in {#buffer}.
         #
@@ -140,6 +143,7 @@ module Whois
         # @return [void]
         #
         # @api public
+        #
         def buffer_append(body, host)
           @buffer << Whois::Record::Part.new(:body => body, :host => host)
         end