whois 0.8.1 → 0.9.0

data/lib/whois/answer/parser.rb

@@ -22,7 +22,7 @@ module Whois
     #
     class Parser
 
-      @@registrable_methods = [
+      @@properties = [
         :disclaimer,
         :domain, :domain_id,
         :referral_whois, :referral_url,
@@ -32,11 +32,11 @@ module Whois
         :nameservers,
       ]
 
-      # Returns an array containing the name of all methods
+      # Returns an array containing the name of all properties
       # that can be registered and should be implemented by
       # server-specific parsers.
-      def self.registrable_methods
-        @@registrable_methods
+      def self.properties
+        @@properties
       end
 
       attr_reader :answer
@@ -56,15 +56,20 @@ module Whois
       # Returns <tt>true</tt> if the <tt>property</tt> passed as symbol
       # is supported by any available parser.
       # See also <tt>Whois::Answer::Parser::Base.supported?</tt>.
-      def supported?(property)
-        parsers.any? { |parser| parser.supported?(property) }
+      def property_supported?(property)
+        parsers.any? { |parser| parser.property_supported?(property) }
+      end
+      
+      def supported?(*args)
+        ::Whois.deprecate "supported? is deprecated. Use property_supported? instead."
+        property_supported?(*args)
       end
 
 
       protected
 
         def method_missing(method, *args, &block)
-          if Parser.registrable_methods.include?(method)
+          if Parser.properties.include?(method)
             if parsers.empty?
               raise ParserError, "Unable to select a parser because the answer is empty"
             elsif parser = select_parser(method)
@@ -101,28 +106,60 @@ module Whois
         end
 
 
+      # Returns the proper <tt>Whois::Answer::Parser::Base</tt> instance
+      # for given <tt>part</tt>.
+      # The parser class depends on the <tt>Whois::Answer::Part</tt> host.
       def self.parser_for(part)
         parser_klass(part.host).new(part)
       end
 
+      # Detects the proper parser class according to given <tt>host</tt>
+      # and returns the class constant.
+      # If no parser exists for <tt>host</tt>, then returns a generic
+      # <tt>Whois::Answer::Parser::Blank</tt>.
+      #
+      # This method autoloads missing parser classes. If you want to define
+      # a custom parser, simple make sure the class is loaded in the Ruby
+      # environment before this method is called.
+      #
+      #   Parser.parser_klass("whois.missing.com")
+      #   # => Whois::Answer::Parser::Blank
+      #
+      #   class Whois::Answer::Parser::WhoisMissingCom
+      #   end
+      #   Parser.parser_klass("whois.missing.com")
+      #   # => Whois::Answer::Parser::WhoisMissingCom
+      #
       def self.parser_klass(host)
-        file = "whois/answer/parser/#{host}"
-        require file
-
         name = host_to_parser(host)
+        Parser.const_defined?(name) || autoload(host)
         Parser.const_get(name)
 
       rescue LoadError
-        require "whois/answer/parser/blank"
+        Parser.const_defined?("Blank") || autoload("blank")
         Parser::Blank
       end
 
+      # Converts <tt>host</tt> to a parser class name.
+      # Note. Returns a <tt>String</tt>, not a <tt>Class</tt>.
+      #
+      #   Parser.host_to_parser("whois.nic.it")
+      #   # => "WhoisNicIt"
+      #   Parser.host_to_parser("whois.nic-info.it")
+      #   # => "WhoisNicInfoIt"
+      #
       def self.host_to_parser(host)
         host.to_s.
           gsub(/\./, '_').
           gsub(/(?:^|_)(.)/)  { $1.upcase }
       end
 
+      # Requires the file at "whois/answer/parser/#{name}".
+      def self.autoload(name)
+        file = "whois/answer/parser/#{name}"
+        require file
+      end
+
     end
 
   end

data/lib/whois/answer/parser/ast.rb

@@ -0,0 +1,72 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'strscan'
+
+
+module Whois
+  class Answer
+    class Parser
+
+      # The Ast module tries to emulate a super-simple Abstract Syntax Tree structure
+      # including method for accessing ast nodes.
+      #
+      # == Usage
+      #
+      # Include the Ast module and provide a <tt>parse</tt> instance method.
+      # <tt>parse</tt> should returns a Hash representing the AST.
+      #
+      #   def parse
+      #     Scanner.new.parse
+      #   end
+      #   # => { "created_on" => "2009-12-12", ... }
+      #
+      # Now you can access the AST using the <tt>node</tt> method.
+      #
+      #   node "created_on"
+      #   # => "2009-12-12"
+      #
+      #   node? "created_on"
+      #   # => true
+      #
+      #   node? "created_at"
+      #   # => false
+      #
+      module Ast
+
+        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
+
+      end
+
+    end
+  end
+end

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

@@ -14,10 +14,10 @@
 #++
 
 
-require 'strscan'
 require 'time'
 require 'whois/answer/contact'
 require 'whois/answer/registrar'
+require 'whois/answer/parser/ast'
 
 
 module Whois
@@ -44,7 +44,7 @@ module Whois
           @part = part
         end
 
-        ::Whois::Answer::Parser.registrable_methods.each do |method|
+        ::Whois::Answer::Parser.properties.each do |method|
           define_method(method) do
             raise PropertyNotImplemented, "You should overwrite this method."
           end
@@ -53,40 +53,45 @@ module Whois
         # Returns <tt>true</tt> if the <tt>property</tt> passed as symbol
         # is supported by current parser.
         #
-        #   parser.supported? :disclaimer
+        #   parser.property_supported? :disclaimer
         #   # => false
         #
         #   parser.register_method(:disclaimer) {}
-        #   parser.supported? :disclaimer
+        #   parser.property_supported? :disclaimer
         #   # => true
         #
         # This method is different than <tt>respond_to?</tt>.
         # While <tt>respond_to?</tt> always returns true for any registrable property,
         # including those not effectively implemented,
         # this method only returns <tt>true</tt> if the parser implements <tt>property</tt>.
-        # Also, <tt>supported?</tt> returns <tt>false</tt> if <tt>property</tt> exists as a method
+        # Also, <tt>property_supported?</tt> returns <tt>false</tt> if <tt>property</tt> exists as a method
         # but it's not a property method.
         #
         #   parser.respond_to?(:disclaimer)
         #   # => true
-        #   parser.supported?(:disclaimer)
+        #   parser.property_supported?(:disclaimer)
         #   # => false
         #
         #   parser.register_method(:disclaimer) {}
         #   parser.respond_to?(:disclaimer)
         #   # => true
-        #   parser.supported?(:disclaimer)
+        #   parser.property_supported?(:disclaimer)
         #   # => true
         #
         #   parser.respond_to?(:contact)
         #   # => true
-        #   parser.supported?(:contact)
+        #   parser.property_supported?(:contact)
         #   # => false
         #
-        def supported?(property)
+        def property_supported?(property)
           method_registered?(property.to_s.to_sym)
         end
 
+        def supported?(*args)
+          ::Whois.deprecate "supported? is deprecated. Use property_supported? instead."
+          property_supported?(*args)
+        end
+
 
         # This is an internal method primaly used as a common access point
         # to get the content to be parsed as a string.

data/lib/whois/answer/parser/blank.rb

@@ -32,7 +32,7 @@ module Whois
       #
       class Blank < Base
 
-        ::Whois::Answer::Parser.registrable_methods.each do |method|
+        ::Whois::Answer::Parser.properties.each do |method|
           define_method(method) do
             raise ParserNotFound, "Unable to find a parser for the server `#{part.host}'"
           end

data/lib/whois/answer/parser/scanners/verisign.rb

@@ -0,0 +1,117 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+module Whois
+  class Answer
+    class Parser
+      module Scanners
+        
+        class VerisignScanner
+
+          def initialize(content)
+            content = content.to_s.gsub("\r", "")
+            @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_notice      ||
+              parse_pair        ||
+              trim_last_update  ||
+              trim_fuffa        ||
+              error("Unexpected token")
+            end
+
+            def trim_newline
+              @input.scan(/\n/)
+            end
+
+            def trim_last_update
+              @input.scan(/>>>(.*?)<<<\n/)
+            end
+
+            def trim_fuffa
+              @input.scan(/^\w(.*)\n/) ||
+              (@input.scan(/^\w(.*)/) and @input.eos?)
+            end
+
+            def parse_not_found
+              if @input.scan(/No match for "(.*?)"\.\n/)
+                @ast["Domain Name"] = @input[1].strip
+              end
+            end
+
+            # NOTE: parse_notice and parse_disclaimer are similar!
+            def parse_notice
+              if @input.match?(/NOTICE:/)
+                lines = []
+                while !@input.match?(/\n/) && @input.scan(/(.*)\n/)
+                  lines << @input[1].strip
+                end
+                @ast["Notice"] = lines.join(" ")
+              else
+                false
+              end
+            end
+
+            def parse_disclaimer
+              if @input.match?(/TERMS OF USE:/)
+                lines = []
+                while !@input.match?(/\n/) && @input.scan(/(.*)\n/)
+                  lines << @input[1].strip
+                end
+                @ast["Disclaimer"] = lines.join(" ")
+              else
+                false
+              end
+            end
+
+            def parse_pair
+              if @input.scan(/\s+(.*?):(.*?)\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)
+              raise "#{message}: #{@input.peek(@input.string.length)}"
+            end
+
+        end
+        
+      end
+    end
+  end
+end

data/lib/whois/answer/parser/whois.aero.rb

@@ -0,0 +1,74 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+#
+# 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.aero parser
+      #
+      # Parser for the whois.aero 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.
+      #
+      class WhoisAero < Base
+
+        register_method :status do
+          @status ||= if content.to_s =~ /Domain Status:(.*?)[\r\n]+/
+            $1.downcase.to_sym
+          end
+        end
+
+        register_method :available? do
+          @available ||= (content.to_s.strip == "NOT FOUND")
+        end
+
+        register_method :registered? do
+          !available?
+        end
+
+
+        register_method :created_on do
+          @created_on ||= if content.to_s =~ /Created On:(.*?)[\r\n]+/
+            Time.parse($1)
+          end
+        end
+        
+        register_method :updated_on do
+          @updated_on ||= if content.to_s =~ /Updated On:(.*?)[\r\n]+/
+            Time.parse($1)
+          end
+        end
+        
+        register_method :expires_on do
+          @expires_on ||= if content.to_s =~ /Expires On:(.*?)[\r\n]+/
+            Time.parse($1)
+          end
+        end
+
+      end
+      
+    end
+  end
+end