whois 0.9.0 → 1.0.0

data/lib/whois.rb

@@ -19,7 +19,6 @@ require 'whois/errors'
 require 'whois/client'
 require 'whois/server'
 require 'whois/answer'
-require 'whois/whois'
 
 
 module Whois

data/lib/whois/answer.rb

@@ -113,11 +113,9 @@ module Whois
     # Returns a Hash containing all supported properties for this Answer
     # along with corresponding values.
     def properties
-      list = Parser.properties.inject([]) do |l,a|
-        l.concat([a, send(a)]) if property_supported?(a)
-        l
-      end
-      Hash[*list]
+      hash = {}
+      Parser.properties.each { |property| hash[property] = send(property) }
+      hash
     end
 
     # Returns <tt>true</tt> if the <tt>property</tt> passed as symbol
@@ -127,23 +125,36 @@ module Whois
       parser.property_supported?(property)
     end
 
-    def supported?(*args)
-      ::Whois.deprecate "supported? is deprecated. Use property_supported? instead."
-      property_supported?(*args)
-    end
-
 
     protected
-      
+
       # Delegates all method calls to the internal parser.
       def method_missing(method, *args, &block)
         if Parser.properties.include?(method)
-          parser.send(method, *args, &block)
+          self.class.class_eval foo = %{
+            def #{method}(*args, &block)
+              if property_supported?(:#{method})
+                parser.#{method}(*args, &block)
+              else
+                nil
+              end
+            end
+          }, __FILE__, __LINE__
+          send(method, *args, &block)
+
+        elsif method.to_s =~ /([a-z_]+)\?/ and Parser.properties.include?($1.to_sym)
+          self.class.class_eval %{
+            def #{$1}?
+              !#{$1}.nil?
+            end
+          }, __FILE__, __LINE__
+          send($1)
+
         else
           super
         end
       end
-      
+
   end
 
 end

data/lib/whois/answer/parser.rb

@@ -59,29 +59,40 @@ module Whois
       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
+      private
 
         def method_missing(method, *args, &block)
           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)
-              parser.send(method, *args, &block)
-            else
-              raise PropertyNotSupported, "Unable to find a parser for `#{method}'"
-            end
+            delegate_to_parsers(method, *args, &block)
           else
             super
           end
         end
 
+        def delegate_to_parsers(method, *args, &block)
+          # Raise an error without any parser
+          if parsers.empty?
+            raise ParserError, "Unable to select a parser because the answer is empty"
+
+          # Select a parser where the property is supported
+          # and call the method.
+          elsif parser = select_parser(method, :supported)
+            parser.send(method, *args, &block)
+
+          # Select a parser where the property is defined
+          # (but not supported) and call the method.
+          # The call is expected to raise an exception.
+          elsif parser = select_parser(method)
+            parser.send(method, *args, &block)
+
+          # The property is not supported nor defined.
+          else
+            raise PropertyNotAvailable, "Unable to find a parser for `#{method}'"
+          end
+        end
+
         # Loops through all answer parts, for each parts tries to guess
         # the appropriate Whois::Answer::Parser::<parser> if it exists
         # and returns the final array of server-specific parsers.
@@ -98,9 +109,9 @@ module Whois
           answer.parts.reverse.map { |part| self.class.parser_for(part) }
         end
 
-        def select_parser(method)
+        def select_parser(property, status = :any)
           parsers.each do |parser|
-            return parser if parser.method_registered?(method)
+            return parser if parser.class.property_registered?(property, status)
           end
           nil
         end
@@ -150,7 +161,7 @@ module Whois
       #
       def self.host_to_parser(host)
         host.to_s.
-          gsub(/\./, '_').
+          gsub(/[.-]/, '_').
           gsub(/(?:^|_)(.)/)  { $1.upcase }
       end
 

data/lib/whois/answer/parser/NOTES.txt

@@ -0,0 +1,3 @@
+.us == .biz == .travel
+.mobi == .info (afilias)
+ (afilias)

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

@@ -37,146 +37,185 @@ module Whois
       #
       class Base
 
-        attr_reader :part
+        @@property_registry = {}
 
-
-        def initialize(part)
-          @part = part
-        end
-
-        ::Whois::Answer::Parser.properties.each do |method|
-          define_method(method) do
-            raise PropertyNotImplemented, "You should overwrite this method."
+        #
+        # :call-seq:
+        #   property_registry => hash
+        #   property_registry(ParserClass) => hash
+        #
+        # Returns the <tt>@@property_registry</tt> if <tt>klass</tt> is nil,
+        # otherwise returns the value in <tt>@@property_registry</tt> for given <tt>klass</tt>.
+        # <tt>klass</tt> is expected to be a class name.
+        # 
+        # Returned value is always a hash. If <tt>@@property_registry[klass]</tt> 
+        # doesn't exist, this method automatically initializes it to an empty Hash.
+        #
+        def self.property_registry(klass = nil)
+          if klass.nil?
+            @@property_registry
+          else
+            @@property_registry[klass] ||= {}
           end
         end
 
-        # Returns <tt>true</tt> if the <tt>property</tt> passed as symbol
-        # is supported by current parser.
+        # Returns the status for <tt>property</tt> passed as symbol.
         #
-        #   parser.property_supported? :disclaimer
-        #   # => false
+        #   property_status(:disclaimer)
+        #   # => nil
         #
-        #   parser.register_method(:disclaimer) {}
-        #   parser.property_supported? :disclaimer
-        #   # => true
+        #   register_property(:discaimer, :supported) {}
+        #   property_status(:disclaimer)
+        #   # => :supported
         #
-        # 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>property_supported?</tt> returns <tt>false</tt> if <tt>property</tt> exists as a method
-        # but it's not a property method.
+        def self.property_status(property)
+          property = property.to_s.to_sym
+          property_registry(self)[property]
+        end
+
+        # Returns <tt>true</tt> if the <tt>property</tt> passed as symbol
+        # is registered in the <tt>property_registry</tt> for current parser.
         #
-        #   parser.respond_to?(:disclaimer)
-        #   # => true
-        #   parser.property_supported?(:disclaimer)
+        #   property_registered?(:disclaimer)
         #   # => false
         #
-        #   parser.register_method(:disclaimer) {}
-        #   parser.respond_to?(:disclaimer)
-        #   # => true
-        #   parser.property_supported?(:disclaimer)
+        #   register_property(:discaimer) {}
+        #   property_registered?(:disclaimer)
         #   # => true
         #
-        #   parser.respond_to?(:contact)
-        #   # => true
-        #   parser.property_supported?(:contact)
-        #   # => false
-        #
-        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)
+        def self.property_registered?(property, status = :any)
+          property = property.to_s.to_sym
+          if status == :any
+            property_registry(self).key?(property)
+          else
+            property_registry(self)[property] == status
+          end
         end
 
-
-        # This is an internal method primaly used as a common access point
-        # to get the content to be parsed as a string.
         #
-        # The main reason behind this method is because I changed the internal
-        # representation of the data to be parsed more than once
-        # and I always had to rewrite all single parsers in order to reflect these changes.
-        # Now, as far as the parser access the data via the content method,
-        # there's no need to change each single implementation in case the content source changes.
+        # :call-seq:
+        #   register_property(:property, :status) { }
+        #   register_property(:property, :status) { |parameter| ... }
+        #   register_property(:property, :status) { |parameter, ...| ... }
         #
-        # That said, the only constraints about this method is to return the data to be parsed as string.
+        # This method creates a new method called <tt>property</tt>
+        # with the content of <tt>block</tt> and registers
+        # the <tt>property</tt> in the <tt>property_registry</tt>
+        # with given <tt>status</tt>.
         #
-        def content
-          part.response
+        #   register_property(:disclaimer, :supported) do
+        #     ...
+        #   end
+        #   
+        #   # def disclaimer
+        #   #   ...
+        #   # end
+        #   
+        #   property_registered?(:disclaimer)
+        #   # => true
+        #   
+        #   
+        #   register_property(:changed?, :implemented) do |other|
+        #     ...
+        #   end
+        #   
+        #   # def changed?(other)
+        #   #   ...
+        #   # end
+        #
+        def self.register_property(property, status, &block)
+          property = property.to_s.to_sym
+          property_registry(self).merge!({ property => status })
+          define_method(property, &block)
         end
 
 
-        @@method_registry = {}
-
-        #
-        # :call-seq:
-        #   method_registry => hash
-        #   method_registry(:key) => array
+        # Registers a <tt>property</tt> as <tt>:not_implemented</tt>
+        # and defines a method which will raise a <tt>PropertyNotImplemented</tt> error.
         #
-        # Returns the <tt>@@method_registry</tt> if <tt>key</tt> is nil,
-        # otherwise returns the value in <tt>@@method_registry</tt> for given <tt>key</tt>.
+        #   # Defines a not implemented property called :disclaimer.
+        #   property_not_implemented(:disclaimer) do
+        #     ...
+        #   end
         #
-        # <tt>@@method_registry</tt> is always a Hash while <tt>@@method_registry[:key]</tt>
-        # is always an array. If <tt>@@method_registry[:key]</tt> doesn't exist, this method
-        # automatically initializes it to an empty array.
+        #   # def disclaimer
+        #   #   raise PropertyNotImplemented, "You should overwrite this method."
+        #   # end
         #
-        def self.method_registry(key = nil)
-          if key.nil?
-            @@method_registry
-          else
-            @@method_registry[key] ||= []
+        def self.property_not_implemented(property)
+          register_property(property, :not_implemented) do
+            raise PropertyNotSupported
           end
         end
 
-        # Returns true if <tt>method</tt> is registered for current class.
+        # Registers a <tt>property</tt> as <tt>:not_supported</tt>
+        # and defines a method which will raise a <tt>PropertyNotSupported</tt> error.
         #
-        #   method_registered?(:disclaimer)
-        #   # => false
+        #   # Defines an unsupported property called :disclaimer.
+        #   property_not_supported(:disclaimer) do
+        #     ...
+        #   end
         #
-        #   register_method(:discaimer) {}
-        #   method_registered?(:disclaimer)
-        #   # => true
+        #   # def disclaimer
+        #   #   raise PropertyNotSupported
+        #   # end
         #
-        def self.method_registered?(method)
-          method_registry(self).include?(method)
+        def self.property_not_supported(property)
+          register_property(property, :not_supported) do
+            raise PropertyNotSupported
+          end
         end
-
-        #
-        # :call-seq:
-        #   register_method(:method) { }
-        #   register_method(:method) { |parameter| ... }
-        #   register_method(:method) { |parameter, ...| ... }
-        #
-        # Creates <tt>method</tt> with the content of <tt>block</tt>
-        # and automatically registers <tt>method</tt> for current class.
-        #
-        #   register_method(:discaimer) do
-        #     ...
-        #   end
+        
+        # Registers a <tt>property</tt> as <tt>:supported</tt>
+        # and defines a method with the content of the block.
         #
-        #   register_method(:changed?) do |other|
+        #   # Defines a supported property called :disclaimer.
+        #   property_supported(:disclaimer) do
         #     ...
         #   end
         #
-        #   method_registered?(:disclaimer)
-        #   # => true
+        #   # def disclaimer
+        #   #   ...
+        #   # end
         #
-        def self.register_method(method, &block)
-          method_registry(self) << method
-          define_method(method, &block)
+        def self.property_supported(property, &block)
+          register_property(property, :supported, &block)
         end
 
-        # Instance-level version of <tt>Base.method_registered?</tt>.
-        def method_registered?(method)
-          self.class.method_registered?(method)
+
+
+        def initialize(part)
+          @part = part
         end
 
-        # Instance-level version of <tt>Base.register_method</tt>.
-        def register_method(method, &block)
-          self.class.register_method(method, &block)
+        ::Whois::Answer::Parser.properties.each do |property|
+          property_not_implemented(property)
+        end
+
+        def part
+          @part
+        end
+
+        # This is an internal method primaly used as a common access point
+        # to get the content to be parsed as a string.
+        #
+        # The main reason behind this method is because I changed the internal
+        # representation of the data to be parsed more than once
+        # and I always had to rewrite all single parsers in order to reflect these changes.
+        # Now, as far as the parser access the data via the content method,
+        # there's no need to change each single implementation in case the content source changes.
+        #
+        # That said, the only constraints about this method is to return the data to be parsed as string.
+        #
+        def content
+          part.response
+        end
+
+
+        # Returns <tt>true</tt> if the <tt>property</tt> passed as symbol
+        # is supported by the current parser.
+        def property_supported?(property)
+          self.class.property_registered?(property, :supported)
         end
 
       end

data/lib/whois/answer/parser/jobswhois.verisign-grs.com.rb

@@ -0,0 +1,99 @@
+#
+# = 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'
+require 'whois/answer/parser/scanners/verisign'
+
+
+module Whois
+  class Answer
+    class Parser
+
+      #
+      # = jobswhois.verisign-grs.com parser
+      #
+      # Parser for the jobswhois.verisign-grs.com server.
+      #
+      class JobswhoisVerisignGrsCom < Base
+        include Ast
+
+        property_supported :disclaimer do
+          node("Disclaimer")
+        end
+
+
+        property_supported :domain do
+          node("Domain Name") { |raw| raw.downcase }
+        end
+
+        property_supported :domain_id do
+          nil
+        end
+
+
+        property_supported :referral_whois do
+          node("Whois Server")
+        end
+
+        property_supported :referral_url do
+          node("Referral URL")
+        end
+
+
+        property_supported :status do
+          node("Status")
+        end
+
+        property_supported :available? do
+          node("Registrar").nil?
+        end
+
+        property_supported :registered? do
+          !available?
+        end
+
+
+        property_supported :created_on do
+          node("Creation Date") { |raw| Time.parse(raw) }
+        end
+
+        property_supported :updated_on do
+          node("Updated Date") { |raw| Time.parse(raw) }
+        end
+
+        property_supported :expires_on do
+          node("Expiration Date") { |raw| Time.parse(raw) }
+        end
+
+
+        property_supported :registrar do
+          # Return nil because when the response contains more than one registrar section
+          # the response can be messy. See, for instance, the Verisign response for google.com.
+          nil
+        end
+
+
+        protected
+
+          def parse
+            Scanners::VerisignScanner.new(content.to_s).parse
+          end
+
+      end
+
+    end
+  end
+end