whois 0.5.3 → 0.8.0

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

@@ -0,0 +1,232 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/parser/base'
+
+
+module Whois
+  class Answer
+    class Parser
+
+      #
+      # = whois.publicinterestregistry.net parser
+      #
+      # Parser for the whois.publicinterestregistry.net server.
+      #
+      class WhoisPublicinterestregistryNet < Base
+
+        register_method :disclaimer do
+          node("Disclaimer")
+        end
+
+
+        register_method :domain do
+          node("Domain Name") { |value| value.downcase }
+        end
+
+        register_method :domain_id do
+          node("Domain ID")
+        end
+
+
+        register_method :status do
+          node("Status")
+        end
+
+        register_method :available? do
+          node("Domain ID").nil?
+        end
+
+        register_method :registered? do
+          !available?
+        end
+
+
+        register_method :created_on do
+          node("Created On") { |value| Time.parse(value) }
+        end
+
+        register_method :updated_on do
+          node("Last Updated On") { |value| Time.parse(value) }
+        end
+
+        register_method :expires_on do
+          node("Expiration Date") { |value| Time.parse(value) }
+        end
+
+        
+        register_method :registrar do
+          node("Sponsoring Registrar") do |registrar|
+            id, name = if registrar =~ /(.*?)\((.*?)\)/
+              [$2.strip, $1.strip]
+            else
+              [nil, registrar]
+            end
+            Answer::Registrar.new(
+              :id           => id,
+              :name         => name
+            )
+          end
+        end
+
+        register_method :registrant do
+          contact("Registrant")
+        end
+
+        register_method :admin do
+          contact("Admin")
+        end
+
+        register_method :technical do
+          contact("Tech")
+        end
+
+
+        register_method :nameservers do
+          node("Name Server") { |server| server.reject { |value| value.empty? }.map { |value| value.downcase }}
+        end
+
+
+        register_method :changed? do |other|
+          !unchanged?(other)
+        end
+
+        register_method :unchanged? do |other|
+          self == other ||
+          self.content.to_s == other.content.to_s
+        end
+
+
+        protected
+        
+          def contact(element)
+            node("#{element} ID") do |registrant_id|
+              Answer::Contact.new(
+                :id           => registrant_id,
+                :name         => node("#{element} Name"),
+                :organization => node("#{element} Organization"),
+                :address      => [node("#{element} Street1"),
+                                  node("#{element} Street2"),
+                                  node("#{element} Street3")].reject { |value| value.to_s.empty? }.join(" "),
+                :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 ast
+            @ast ||= parse
+          end
+
+          def node(key, &block)
+            if block_given?
+              value = ast[key]
+              value = yield(value) unless value.nil?
+              value
+            else
+              ast[key]
+            end
+          end
+
+          def node?(key)
+            !ast[key].nil?
+          end
+
+          def parse
+            Scanner.new(content.to_s).parse
+          end
+
+
+        class Scanner
+
+          def initialize(content)
+            @input = StringScanner.new(content.to_s)
+          end
+
+          def parse
+            @ast = {}
+            while !@input.eos?
+              parse_content
+            end
+            @ast
+          end
+          
+          private
+
+            def parse_content
+              trim_newline      ||
+              parse_not_found   ||
+              parse_disclaimer  ||
+              parse_pair        ||
+              error("Unexpected token")
+            end
+
+            def trim_newline
+              # The last line is \r\n\n
+              @input.scan(/\r\n+/)
+            end
+
+            def parse_not_found
+              @input.scan(/NOT FOUND\n/)
+            end
+
+            def parse_disclaimer
+              if @input.match?(/NOTICE:/)
+                lines = []
+                while !@input.match?(/\r\n/) && @input.scan(/(.*)\r\n/)
+                  lines << @input[1].strip
+                end
+                @ast["Disclaimer"] = lines.join(" ")
+              else
+                false
+              end
+            end
+
+            def parse_pair
+              if @input.scan(/(.*?):(.*?)\r\n/)
+                key, value = @input[1].strip, @input[2].strip
+                if @ast[key].nil?
+                  @ast[key] = value
+                else
+                  @ast[key].is_a?(Array) || @ast[key] = [@ast[key]]
+                  @ast[key] << value
+                end
+              else
+                false
+              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
+      
+    end
+  end
+end

data/lib/whois/answer/part.rb

@@ -0,0 +1,35 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/super_struct'
+
+
+module Whois
+  class Answer
+
+    #
+    # = Part
+    #
+    # A single <tt>Whois::Answer</tt> fragment. For instance, 
+    # in case of thin server, an <tt>Whois::Answer</tt> may be composed by 
+    # one or more parts corresponding to all responses 
+    # returned by the WHOIS servers.
+    #
+    class Part < SuperStruct.new(:response, :host)
+    end
+
+  end
+end

data/lib/whois/answer/registrar.rb

@@ -0,0 +1,42 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/super_struct'
+
+
+module Whois
+  class Answer
+
+    #
+    # = Registrar
+    #
+    # Holds the details of the Registrar extracted from the WHOIS answer.
+    #
+    # A Registrar is composed by the following attributes:
+    #
+    # <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.
+    #
+    class Registrar < SuperStruct.new(:id, :name, :organization, :url)
+    end
+
+  end
+end

data/lib/whois/answer/super_struct.rb

@@ -0,0 +1,57 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'ostruct'
+
+
+#
+# = SuperStruct
+#
+# SuperStruct is an enhanced version of the Ruby Standar library <tt>Struct</tt>.
+#
+# Compared with the original version, it provides the following additional features:
+# * ability to initialize an instance from Hash
+# * ability to pass a block on creation  
+#
+class SuperStruct < Struct
+
+  # Overwrites the standard Struct initializer
+  # to add the ability to create an instance from a Hash of parameters.
+  #
+  #   attributes = { :foo => 1, :bar => "baz" }
+  #   Struct.new(attributes)
+  #   # => #<Struct foo=1, bar="baz">
+  #
+  # If block is given, the block is called on self.
+  #
+  def initialize(*args, &block)
+    if args.first.is_a? Hash
+      initialize_with_hash(args.first)
+    else
+      super
+    end
+    yield(self) if block_given?
+  end
+
+  private
+
+    def initialize_with_hash(attributes = {})
+      attributes.each do |key, value|
+        self[key] = value
+      end
+    end
+  
+end

data/lib/whois/client.rb

@@ -60,6 +60,12 @@ module Whois
     end
     
     
+    # Queries the right whois server for <tt>qstring</tt> and returns
+    # a <tt>Whois::Answer</tt> instance containing the response from the server.
+    #
+    #   client.query("google.com")
+    #   # => #<Whois::Answer>
+    #
     def query(qstring)
       Timeout::timeout(timeout) do
         @server = Server.guess(qstring)

data/lib/whois/definitions/tlds.rb

@@ -34,7 +34,7 @@ Whois::Server.define :tld, ".arpa", "whois.iana.org"
 Whois::Server.define :tld, ".aero", "whois.aero"
 Whois::Server.define :tld, ".asia", "whois.nic.asia"
 Whois::Server.define :tld, ".biz", "whois.nic.biz"
-Whois::Server.define :tld, ".cat", "whois.cat", {:format => "-C US-ASCII ace %s"}
+Whois::Server.define :tld, ".cat", "whois.cat", {:adapter=>Whois::Server::Adapters::Formatted, :format => "-C US-ASCII ace %s"}
 Whois::Server.define :tld, ".coop", "whois.nic.coop"
 Whois::Server.define :tld, ".info", "whois.afilias.info"
 Whois::Server.define :tld, ".jobs", "jobswhois.verisign-grs.com", {:adapter=>Whois::Server::Adapters::Verisign}
@@ -102,7 +102,7 @@ Whois::Server.define :tld, ".cv", nil, {:adapter=>Whois::Server::Adapters::None}
 Whois::Server.define :tld, ".cx", "whois.nic.cx"
 Whois::Server.define :tld, ".cy", nil, {:web=>"http://www.nic.cy/nslookup/online_database.php", :adapter=>Whois::Server::Adapters::Web}
 Whois::Server.define :tld, ".cz", "whois.nic.cz"
-Whois::Server.define :tld, ".de", "whois.denic.de", {:format => "-T dn,ace -C US-ASCII %s"}
+Whois::Server.define :tld, ".de", "whois.denic.de", {:adapter=>Whois::Server::Adapters::Formatted, :format => "-T dn,ace -C US-ASCII %s"}
 Whois::Server.define :tld, ".dj", "whois.domain.dj"
 Whois::Server.define :tld, ".dk", "whois.dk-hostmaster.dk"
 Whois::Server.define :tld, ".dm", "whois.nic.dm"

data/lib/whois/errors.rb

@@ -25,33 +25,30 @@ module Whois
   class ServerError < Error
   end
   
-  
-  # Definition not found
+  # 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
   
-  
-  # Definition found
+  # 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)
+  # 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
-  # specific domains that only provide a web–based whois interface. (\x01)
+  # specific domains that only provide a web–based WHOIS interface. (\x01)
   class WebInterfaceError < InterfaceNotSupported
   end
 
-
-  # Known object, Definition unavailable
+  # Server Known object, Definition unavailable
 
   # Raised when we know about a specific functionality
   # but this functionality has not been implemented yet.
@@ -66,5 +63,25 @@ module Whois
   # Raised when unknown AS numer of IP network. (\x06)
   class AllocationUnknown < ServerError
   end
+  
+  
+  # Generic Parser 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
+  end
+
+  # Raised when the property method has not been overwritten (implemented)
+  # in a child parser class.
+  class PropertyNotImplemented < ParserError
+  end
+
+  # Raised when you are trying to access a property that is not supported
+  # by any of the parsers available for current WHOIS answer.
+  class PropertyNotSupported < ParserError
+  end
 
 end