whois 2.5.1 → 2.6.0

data/lib/whois/record/parser/whois.registry.om.rb

@@ -0,0 +1,125 @@
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2012 Simone Carletti <weppos@weppos.net>
+#++
+
+
+require 'whois/record/parser/base'
+require 'whois/record/scanners/whois.registry.om.rb'
+
+
+module Whois
+  class Record
+    class Parser
+
+      # Parser for the whois.registry.om server.
+      # 
+      # @see Whois::Record::Parser::Example
+      #   The Example parser for the list of all available methods.
+      #
+      # @since RELEASE
+      class WhoisRegistryOm < Base
+        include Scanners::Ast
+
+        property_not_supported :disclaimer
+
+
+        property_supported :domain do
+          node('Domain Name')
+        end
+
+        property_not_supported :domain_id
+
+
+        property_not_supported :referral_whois
+
+        property_not_supported :referral_url
+
+
+        property_supported :status do
+          case (s = node('Status'))
+          when nil
+            :available
+          when 'ok'
+            :registered
+          else
+            Whois.bug!(ParserError, "Unknown status `#{s}'.")
+          end
+        end
+
+        property_supported :available? do
+          !!node('status:available')
+        end
+
+        property_supported :registered? do
+          !available?
+        end
+
+
+        property_not_supported :created_on
+
+        property_not_supported :updated_on
+
+        property_not_supported :expires_on
+
+
+        property_supported :registrar do
+          node('Registrar Name') do |name|
+            Record::Registrar.new(
+                :name         => name
+            )
+          end
+        end
+
+
+        property_supported :registrant_contacts do
+          build_contact('Registrant', Whois::Record::Contact::TYPE_REGISTRANT)
+        end
+
+        property_not_supported :admin_contacts
+
+        property_supported :technical_contacts do
+          build_contact('Tech', Whois::Record::Contact::TYPE_TECHNICAL)
+        end
+
+
+        property_supported :nameservers do
+          node('Name Server') do |names|
+            names.map do |name|
+              Record::Nameserver.new(:name => name)
+            end
+          end
+        end
+
+
+        # Initializes a new {Scanners::WhoisRegistryOm} instance
+        # passing the {#content_for_scanner}
+        # and calls +parse+ on it.
+        #
+        # @return [Hash]
+        def parse
+          Scanners::WhoisRegistryOm.new(content_for_scanner).parse
+        end
+
+
+        private
+
+        def build_contact(element, type)
+          node("#{element} Contact ID") do
+            Record::Contact.new(
+                :type         => type,
+                :id           => node("#{element} Contact ID"),
+                :name         => node("#{element} Contact Name"),
+                :email        => node("#{element} Contact Email")
+            )
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/whois/record/parser/whois.registrypro.pro.rb

@@ -61,7 +61,7 @@ module Whois
 
         property_supported :nameservers do
           content_for_scanner.scan(/Name Server:(.+)\n/).flatten.map do |name|
-            Record::Nameserver.new(name.downcase)
+            Record::Nameserver.new(:name => name.downcase)
           end
         end
 

data/lib/whois/record/parser/whois.ripe.net.rb

@@ -59,7 +59,7 @@ module Whois
         property_supported :nameservers do
           content_for_scanner.scan(/nserver:\s+(.+)\n/).flatten.map do |line|
             name, ipv4 = line.split(/\s+/)
-            Record::Nameserver.new(name.downcase, ipv4)
+            Record::Nameserver.new(:name => name.downcase, :ipv4 => ipv4)
           end
         end
 

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

@@ -97,7 +97,7 @@ module Whois
 
         property_supported :nameservers do
           Array.wrap(node("DNS")).map do |line|
-            name, ipv4 = line.split("-").map(&:strip)
+            name, ipv4 = line.split(/ - ?/).map(&:strip)
             name.chomp!(".")
             Nameserver.new(:name => name, :ipv4 => ipv4)
           end

data/lib/whois/record/parser/whois.rotld.ro.rb

@@ -30,9 +30,10 @@ module Whois
         property_supported :status do
           if content_for_scanner =~ /Domain Status:\s(.+?)\n/
             case $1.downcase
-              when "ok" then :registered
-              else
-                Whois.bug!(ParserError, "Unknown status `#{$1}'.")
+            when "ok"
+              :registered
+            else
+              Whois.bug!(ParserError, "Unknown status `#{$1}'.")
             end
           else
             :available
@@ -57,7 +58,7 @@ module Whois
 
         property_supported :nameservers do
           content_for_scanner.scan(/Name Server:\s+(.+)\n/).flatten.map do |name|
-            Record::Nameserver.new(name)
+            Record::Nameserver.new(:name => name)
           end
         end
 

data/lib/whois/record/parser/whois.samoanic.ws.rb

@@ -66,7 +66,7 @@ module Whois
         property_supported :nameservers do
           if content_for_scanner =~ /Current Nameservers:\n\n((.+\n)+)\n/
             $1.split("\n").map do |name|
-              Record::Nameserver.new(name.strip.downcase)
+              Record::Nameserver.new(:name => name.strip.downcase)
             end
           end
         end

data/lib/whois/record/parser/whois.sgnic.sg.rb

@@ -58,22 +58,22 @@ module Whois
         property_supported :nameservers do
           if content_for_scanner =~ /Name Servers:\n((.+\n)+)\n/
             values = case value = $1.downcase
-              # schema-1
-              when /^(?:\s+([\w.-]+)\n){2,}/
-                value.scan(/\s+([\w.-]+)\n/).map do |match|
-                  { :name => match[0] }
-                end
-              when /^(?:\s+([\w.-]+)\s+\((.+)\)\n){2,}/
-                value.scan(/\s+([\w.-]+)\s+\((.+)\)\n/).map do |match|
-                  { :name => match[0], :ipv4 => match[1] }
-                end
-              # schema-2
-              when /^(?:\s+([\w.-]+)){2,}/
-                value.strip.split(/\s+/).map do |name|
-                  { :name => name }
-                end
-              else
-                Whois.bug!(ParserError, "Unknown nameservers format `#{value}'")
+            # schema-1
+            when /^(?:\s+([\w.-]+)\n){2,}/
+              value.scan(/\s+([\w.-]+)\n/).map do |match|
+                { :name => match[0] }
+              end
+            when /^(?:\s+([\w.-]+)\s+\((.+)\)\n){2,}/
+              value.scan(/\s+([\w.-]+)\s+\((.+)\)\n/).map do |match|
+                { :name => match[0], :ipv4 => match[1] }
+              end
+            # schema-2
+            when /^(?:\s+([\w.-]+)){2,}/
+              value.strip.split(/\s+/).map do |name|
+                { :name => name }
+              end
+            else
+              Whois.bug!(ParserError, "Unknown nameservers format `#{value}'")
             end
 
             values.map do |params|

data/lib/whois/record/parser/whois.sk-nic.sk.rb

@@ -36,21 +36,28 @@ module Whois
           if content_for_scanner =~ /^Domain-status\s+(.+)\n/
             case $1.downcase
             # The domain is registered and paid.
-            when  "dom_ok"    then :registered
+            when  "dom_ok"
+              :registered
             # The domain is registered and registration fee has to be payed (14 days).
             # Replacement 14-day period for domain payment.
-            when  "dom_ta"    then :registered
+            when  "dom_ta"
+              :registered
             # 28 days before the expiration of one year's notice is sent to the first call for an extension of domains.
             # The domain is still fully functional (14 days).
-            when  "dom_dakt"  then :registered
+            when  "dom_dakt"
+              :registered
             # 14 days before the expiration of one year's notice is sent to the second call to the extension of domains.
             # The domain is still fully functional (14 days).
-            when  "dom_warn"  then :registered
+            when  "dom_warn"
+              :registered
             # The domain is expired and has not been renewed (14 days).
-            when  "dom_lnot"  then :registered
-            when  "dom_exp"   then :registered
+            when  "dom_lnot"
+              :registered
+            when  "dom_exp"
+              :registered
             # The domain losts its registrar (28 days).
-            when  "dom_held"  then :redemption
+            when  "dom_held"
+              :redemption
             else
               Whois.bug!(ParserError, "Unknown status `#{$1}'.")
             end
@@ -85,7 +92,7 @@ module Whois
 
         property_supported :nameservers do
           content_for_scanner.scan(/dns_name\s+(.+)\n/).flatten.map do |name|
-            Record::Nameserver.new(name)
+            Record::Nameserver.new(:name => name)
           end
         end
 

data/lib/whois/record/parser/whois.smallregistry.net.rb

@@ -75,7 +75,15 @@ module Whois
 
 
         property_supported :registrar do
-          node("registrar") { |hash| Registrar.new(*hash.values_at('nil', 'name', 'name', 'web')) }
+          node("registrar") do |hash|
+            v1, v2, v3, v4 = hash.values_at('nil', 'name', 'name', 'web')
+            Registrar.new(
+                :id           => v1,
+                :name         => v2,
+                :organization => v3,
+                :url          => v4
+            )
+          end
         end
 
         property_supported :registrant_contacts do
@@ -93,7 +101,7 @@ module Whois
 
         property_supported :nameservers do
           Array.wrap(node("name_servers")).map do |hash|
-            Record::Nameserver.new(hash)
+            Record::Nameserver.new(:name => hash)
           end
         end
 

data/lib/whois/record/parser/whois.srs.net.nz.rb

@@ -14,31 +14,35 @@ module Whois
   class Record
     class Parser
 
-      #
-      # = whois.srs.net.nz parser
-      #
       # Parser for the whois.srs.net.nz 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.
+      # @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 Whois::Record::Parser::Example
+      #   The Example parser for the list of all available methods.
       #
       class WhoisSrsNetNz < Base
 
         # @see http://dnc.org.nz/content/srs-whois-spec-1.0.html
         property_supported :status do
           if content_for_scanner =~ /query_status:\s(.+)\n/
-            case s = $1.downcase
-              when /active/               then :registered
-              when /available/            then :available
-              when /invalid characters/   then :invalid
-              # The domain is no longer active but is in the period prior
-              # to being released for general registrations
-              when "210 pendingrelease"   then :redemption
-              else
-                Whois.bug!(ParserError, "Unknown status `#{s}'.")
+            case (s = $1.downcase)
+            when "200 active"
+              :registered
+            # The domain is no longer active but is in the period prior
+            # to being released for general registrations
+            when "210 pendingrelease"
+              :redemption
+            when "220 available"
+              :available
+            when "404 request denied"
+              :error
+            when /invalid characters/
+              :invalid
+            else
+              Whois.bug!(ParserError, "Unknown status `#{s}'.")
             end
           else
             Whois.bug!(ParserError, "Unable to parse status.")
@@ -46,11 +50,11 @@ module Whois
         end
 
         property_supported :available? do
-          (status == :available)
+          status == :available
         end
 
         property_supported :registered? do
-          (status == :registered) || (status == :redemption)
+          status == :registered || status == :redemption
         end
 
 
@@ -75,7 +79,21 @@ module Whois
 
         property_supported :nameservers do
           content_for_scanner.scan(/ns_name_[\d]+:\s(.+)\n/).flatten.map do |name|
-            Record::Nameserver.new(name)
+            Record::Nameserver.new(:name => name)
+          end
+        end
+
+
+        # Checks whether the response has been throttled.
+        #
+        # @return [Boolean]
+        #
+        # @example
+        #   query_status: 440 Request Denied
+        #
+        def response_throttled?
+          cached_properties_fetch(:response_throttled?) do
+            !!(content_for_scanner =~ /^query_status: 440 Request Denied/)
           end
         end
 

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

@@ -60,7 +60,9 @@ module Whois
 
         property_supported :registrar do
           if content_for_scanner =~ /registrar:\s+(.*)\n/
-            Record::Registrar.new(:id => $1)
+            Record::Registrar.new(
+                :id           => $1
+            )
           end
         end
 
@@ -91,7 +93,7 @@ module Whois
         property_supported :nameservers do
           content_for_scanner.scan(/nserver:\s+(.+)\n/).flatten.map do |line|
             name, ipv4 = line.split(/\s+/)
-            Record::Nameserver.new(name.chomp("."), ipv4)
+            Record::Nameserver.new(:name => name.chomp("."), :ipv4 => ipv4)
           end
         end
 

data/lib/whois/record/parser/whois.thnic.co.th.rb

@@ -30,9 +30,10 @@ module Whois
         property_supported :status do
           if content_for_scanner =~ /Status: (.+?)\n/
             case $1.downcase
-              when "active" then :registered
-              else
-                Whois.bug!(ParserError, "Unknown status `#{$1}'.")
+            when "active"
+              :registered
+            else
+              Whois.bug!(ParserError, "Unknown status `#{$1}'.")
             end
           else
             :available
@@ -69,7 +70,7 @@ module Whois
 
         property_supported :nameservers do
           content_for_scanner.scan(/Name Server:\s+(.+)\n/).flatten.map do |name|
-            Record::Nameserver.new(name.downcase)
+            Record::Nameserver.new(:name => name.downcase)
           end
         end
 

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

@@ -69,22 +69,22 @@ module Whois
 
 
         property_supported :registrar do
-          if content_for_scanner =~ /registrar:\s+(.*)\n/
+          if content_for_scanner =~ /registrar:\s+(.+)\n/
             Whois::Record::Registrar.new(
-                :id => $1,
-                :name => $1
+                :id           => $1,
+                :name         => $1
             )
           end
         end
 
         property_supported :admin_contacts do
-          if content_for_scanner =~ /admin-c:\s+(.*)\n/
+          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/
+          if content_for_scanner =~ /registrant:\s+(.+)\n/
             build_contact($1, Whois::Record::Contact::TYPE_REGISTRANT)
           end
         end
@@ -95,9 +95,9 @@ module Whois
         property_supported :nameservers do
           content_for_scanner.scan(/nserver:\s+(.+)\n/).flatten.map do |line|
             if line =~ /(.+) \((.+)\)/
-              Record::Nameserver.new($1, $2)
+              Record::Nameserver.new(:name => $1, :ipv4 => $2)
             else
-              Record::Nameserver.new(line)
+              Record::Nameserver.new(:name => line)
             end
           end
         end