mlightner-universal_ruby_whois 1.0.0 → 1.2.1

data/CHANGELOG.rdoc

@@ -0,0 +1,5 @@
+== 11/10/08
+  * Support for expiration date parsing added as requested by Jorge Yau.
+  * Renamed "created_date" to "creation_date" for consistency.
+  * Moved supporting libraries into a support folder.
+  * Added support for .jp and .co.jp etc. domain names.

data/README.rdoc

@@ -0,0 +1,76 @@
+= Universal Whois Server
+
+*Author*: Matt Lightner <mailto:mlightner@gmail.com>
+
+*License*: MIT[link:files/LICENSE.html]
+
+This library attempts to interpret WHOIS output from a variety of different registrars.
+The ultimate goal is to have a complete "dictionary" of all of the TLD registrars (including
+double domain TLDs such as .co.uk) on the Internet, and corresponding regular expressions
+to parse the unique output format for each one.
+
+This package requires a command line whois utility to retrieve output.  It will then attempt
+to interpret that output based on a series of regular expressions.
+
+
+=== DEFINING WHOIS SERVERS
+
+Whois servers can be defined on a per-TLD basis, so each registrar can have a unique set
+of regular expressions to match its particular output format.  Whois servers are defined in the
+file server_list.rb.
+
+If you're using this module and come across a TLD that isn't yet supported or isn't working
+quite right, I highly encourage you to fork the project and commit your updates.  The more
+people we have working on the list, the more comprehensive and effective it becomes!
+
+
+=== TLD SEARCH PRIORITY
+
+When deciding which whois server to use, the script will always choose the most specific
+server entry it can find.  For instance, if you have defined a server for .uk domains,
+but also a server for .co.uk domains, the domain name "test.co.uk" will always use the
+latter whois server.
+
+
+=== EXAMPLE USAGE
+
+Here is the output from a sample IRB session using this library:
+
+  require 'universal_ruby_whois'
+  => true
+  domain = Whois.find("mattlightner.com")
+  => #<Whois::Domain:0xb7a3b014 @domain="mattlightner.com", @server_tld_key="com">
+  domain.status
+  => :registered
+  domain.available?
+  => false
+  domain.registered?
+  => true
+  domain.created_date
+  => Mon Aug 28 00:00:00 EDT 2006
+  domain = Whois.find("9384jf398ejf9832ej.com")            
+  => #<Whois::Domain:0xb7a1ab34 @domain="9384jf398ejf9832ej.com", @server_tld_key="com">
+  domain.status      
+  => :free
+
+
+=== NOTES
+
+Some registrars are relatively unreliable or may add a server to a blacklist after a certain number of
+queries.  In particular, the registrars for these domains:
+
+- es and related TLDs:  They only provide an HTTP whois access interface, which is unreliable at
+  best (although this module supports HTTP lookups quite well).
+- asn.au com.au id.au net.au org.au: 'whois.aunic.net', seems as though they will blacklist a server
+  making too many queries.  Not sure about their blacklist removal policy.
+
+
+=== TODO
+
+- Add better support for creation date parsing for major registrars.
+- Find a more reliable way to look up domains from registrars not providing a whois server.
+
+
+=== CONTRIBUTIONS
+
+Contribution is encouraged!  Grab the source from: git://github.com/mlightner/universal_ruby_whois.git

data/lib/support/extended_regexp.rb

@@ -0,0 +1,94 @@
+module Whois
+
+  module ExtendedRegexp #:nodoc:
+
+    def self.included(base) #:nodoc:
+      base.send(:include, Whois::ExtendedRegexp::InstanceMethods)
+    end
+
+    # Extensions for Ruby's core Regexp class.
+    module InstanceMethods
+
+      # Find and replace literal values in a regular expression source string.  You pass it a Hash
+      # where the keys are either strings or regular expressions to search for, and their values are
+      # the replacement values.  A completely new Regexp object is returned and options are preserved.
+      #
+      #   /a __REPLACE___ day/i.interpolate("__REPLACE__" => "fun") => /a fun day/i
+      #
+      def interpolate(*args)
+        if args.length > 1
+          replacements = Hash[*args]
+        elsif args.first.kind_of?(Hash)
+          replacements = args.first
+        else
+          raise ArgumentError, "Must pass hash to interpolate."
+        end
+
+        string = self.source
+
+        replacements.each do |key, value|
+          if key.kind_of?(Regexp)
+            string.gsub!(key, value.to_s)
+          else
+            string.gsub!(/#{self.class.escape(key)}/im, value.to_s)
+          end
+        end
+
+        string = (self.source.to_s).interpolate(*args)
+        self.class.new(string, self.options)
+      end
+
+      # Make a copy of the current regular expression object but with new options.  Options are given
+      # as a string, like so:
+      #
+      #  /testing/i.new_options('im') => /testing/im
+      def new_options(option_string)
+        options_list = []
+        { :i => Regexp::IGNORECASE,
+          :x => Regexp::EXTENDED,
+          :m => Regexp::MULTILINE }.each_pair do |charcode, constant|
+          options_list.push(constant) if option_string =~ /#{charcode.to_s}/i
+        end
+
+        self.class.new(self.source, options_list)
+      end
+
+
+      # === Inverted Regular Expressions
+      #
+      # Gives the ability to invert a regular expression so that running a match against it
+      # will yield a true result when it does NOT match the target string.
+      #
+      # Invert this regular expression.
+      def invert!
+        @inverted = true
+        self
+      end
+
+      # Uninvert this regular expression.
+      def uninvert!
+        @inverted = false
+        self
+      end
+
+      def set_inverted(value = true)
+        @inverted = (value) ? true : false
+      end
+
+      # Is this an inverted regular expression?
+      def inverted?
+        @inverted rescue false
+      end
+
+      # Run an inversion-aware match using this Regexp.
+      def match_with_inversion(*args, &block)
+        result = self.match(*args, &block)
+        if @inverted
+          result.nil? ? true : false
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/support/string.rb

@@ -0,0 +1,22 @@
+class String #:nodoc:
+  def interpolate(*args)
+    if args.length > 1
+      replacements = Hash[*args]
+    elsif args.first.kind_of?(Hash)
+      replacements = args.first
+    else
+      raise ArgumentError, "Must pass hash to interpolate."
+    end
+
+    string = self.dup
+    replacements.each do |key, value|
+      if key.kind_of?(Regexp)
+        string.gsub!(key, value.to_s)
+      else
+        string.gsub!(/#{key}/i, value.to_s)
+      end
+    end
+
+    string
+  end
+end

data/lib/universal_ruby_whois.rb

@@ -1,17 +1,30 @@
 require 'rubygems'
 require 'activesupport'
-
 require 'net/http'
 require 'uri'
 require 'time'
 require 'timeout'
 
-require File.dirname(__FILE__) + '/universal_ruby_whois/inverted_regexp'
+require File.dirname(__FILE__) + '/support/string'
+require File.dirname(__FILE__) + '/support/extended_regexp'
 Regexp.class_eval do
-  include MattLightner::InvertedRegexp
+  include Whois::ExtendedRegexp
 end
 
 require File.dirname(__FILE__) + '/universal_ruby_whois/domain'
 require File.dirname(__FILE__) + '/universal_ruby_whois/server'
 require File.dirname(__FILE__) + '/universal_ruby_whois/server_list'
 
+module Whois
+
+  # This is a wrapper around the main domain lookup function.  It allows you to simply call:
+  #   Whois.find("somedomain.com")
+  #
+  # It returns a Whois::Domain object if found, or nil if an appropriate whois server can't be found.
+  def find(domain)
+    ::Whois::Domain.find(domain)
+  end
+
+  module_function :find #:nodoc:
+
+end

data/lib/universal_ruby_whois/domain.rb

@@ -1,29 +1,73 @@
+require File.dirname(__FILE__) + '/server'
 require 'time'
 
 module Whois
 
   class Domain
 
-    attr_accessor :domain, :server_tld_key, :whois_output
+    # The domain name, lower case, no spaces.
+    attr_reader :domain
 
-    def initialize(domain, server_tld_key = nil)
+    # The TLD server being used for this domain.
+    attr_reader :server_tld_key
+
+    # The cached output from a whois request for this domain.
+    attr_reader :whois_output
+
+    # Look up a domain name.  If a proper whois server can not be found for this domain name's extension,
+    # it will return nil.  Otherwise it returns a Whois::Domain object.
+    #
+    # Note: the preferred way to call this method is through the wrapper:
+    #
+    #   Whois.find(domain)
+    def self.find(domain)
+      ::Whois::Server.find(domain)
+    end
+
+    def initialize(domain, server_tld_key = nil) #:nodoc:
       @domain, @server_tld_key = domain.to_s.strip.downcase, server_tld_key
     end
 
+    # Returns the Whois::Server object for this domain name.
     def server
-      Whois::Server.list[@server_tld_key]
+      Whois::Server.list[@server_tld_key] rescue nil
     end
 
+    # The set of regular expressions that will be used in matching this domain's whois output.
     def regexes
-      server.regexes
+      server.regexes rescue {}
+    end
+
+    # Does this object have a domain name set?
+    def has_domain?
+      return false if domain.nil?
+      (domain.to_s =~ /\w/) ? true : false
     end
 
+    # Does this domain have a server which is available?
+    def has_available_server?
+      server && !(server.unavailable? rescue true)
+    end
+
+    # Does this domain have sufficient info to perform a lookup?
+    def has_domain_and_server?
+      has_domain? && has_available_server?
+    end
+    alias_method :valid?, :has_domain_and_server?
+
+    # The raw whois server output obtained when looking up this domain.
     def whois_output
       return @whois_output if !@whois_output.blank?
-      @whois_output = server.raw_response(domain) || ""
+      @whois_output = has_domain_and_server? ? server.raw_response!(domain) : ''
     end
 
+    # The domain name's current registration status:
+    # <tt>:registered</tt> The domain name is registered.
+    # <tt>:free</tt> The domain name is not registered (available).
+    # <tt>:error</tt> There was an error looking up the domain name.
+    # <tt>:unknown</tt> The domain name status could not be determined.
     def status
+      return :unknown unless has_domain_and_server?
       return @status unless @status.blank?
       [ :registered, :free, :error ].each do |status|
         #return status if Regexp.new(regexes[status].source, 5).match(res)
@@ -32,20 +76,54 @@ module Whois
       return @status = :unknown
     end
 
+    # Is this domain available?  Returns true/false.
     def available?
+      return nil unless has_domain_and_server?
       status == :free
     end
 
+    # Is this domain name registered?  Returns true/false.
     def registered?
+      return nil unless has_domain_and_server?
       status == :registered
     end
 
-    def created_date
-      return @created_date unless @created_date.blank?
-      if regexes[:created_date] && (regexes[:created_date] =~ whois_output)
-        @created_date = (Time.local(*ParseDate.parsedate($2)) rescue nil)
+    # Returns a Time object representing the date this domain name was created.
+    def creation_date
+      return nil unless has_domain_and_server?
+      return @creation_date unless @creation_date.blank?
+      if regexes[:creation_date] && (regexes[:creation_date] =~ whois_output)
+        @creation_date = (Time.local(*ParseDate.parsedate($2)) rescue nil)
       end
-      @created_date
+      @creation_date
+    end
+
+    # Depreciated.  Use creation_date instead.
+    alias_method :created_date, :creation_date
+
+    # Do we know the creation date for this domain?
+    def creation_date_known?
+      creation_date.kind_of?(Time)
+    end
+
+
+    # Returns a Time object representing the date this domain name is set to expire.
+    def expiration_date
+      return nil unless has_domain_and_server?
+      return @expiration_date unless @expiration_date.blank?
+      if regexes[:expiration_date] && (regexes[:expiration_date] =~ whois_output)
+        @expiration_date = (Time.local(*ParseDate.parsedate($2)) rescue nil)
+      end
+      @expiration_date
+    end
+
+    # Do we know the expiration date for this domain?
+    def expiration_date_known?
+      expiration_date.kind_of?(Time)
+    end
+
+    def to_s
+      domain.to_s rescue nil
     end
   end
 

data/lib/universal_ruby_whois/server.rb

@@ -1,24 +1,75 @@
 module Whois
 
+  # = Whois::Server
+  #
+  # A Whois server object represents a single TLD mapped to a whois server hostname, and a set of regular expressions
+  # that are used to match against the raw whois output and determine various information about the domain name (currently
+  # registration status is supported on most domain TLDs, and creation date on a good number).
   class Server
-    @@whois_bin = `which whois`.gsub(/\s/, '')
 
-    attr_accessor :tld, :nic_server, :regexes, :port
+    # Exception class thrown when a WHOIS server is down or unavailable.
+    class Unavailable < StandardError
+    end
+
+    # The default regular expressions used when defining a new server if none are supplied.
+    DEFAULT_WHOIS_REGULAR_EXPRESSIONS = {
+        :free => /(avail|free|no match|no entr|not taken|not registered|not found)/im,
+        :registered => /(registered|Domain ID|domain name\s*\:|is active|is not available|exists|\bregistrant\b|Created on)/im,
+        :creation_date => /(Creation date|created on|created at|Commencement Date|Registration Date)\s*[\:\.\]]*\s*([\w\-\:\ \/]+)[^\n\r]*[\n\r]/im,
+        :expiration_date => /(expiration date|expires on|registered through|Renewal date)\s*[\:\.\]]*\s*([\w\-\:\ \/]+)[^\n\r]*[\n\r]/im,
+        :error => /(error)/im,
+        :server_unavailable => /(Sorry\. Server busy\.|too many requests|been blocked)/im
+      }
+
+    # The location of the 'whois' binary utility.
+    WHOIS_BIN = `which whois`.gsub(/\s/, '')
+
+    attr_reader :tld, :nic_server, :regexes, :port, :unavailable, :unavailable_response
+
+    # === Whois Server Definition
+    #
+    # Define a whois server for one or more TLDs.  TLDs can be given as a single string or an array of strings representing
+    # TLDs that are handled by this server.  The second argument should be a whois server hostname.  If none is given,
+    # the generic output from the command line whois program is used (with any available redirection).  An optional third
+    # argument is an array of regular expressions used to parse output from this particular server.  A set of relatively
+    # liberal defaults is used if none (or only some) are given.  Supported regex keys are :free, :registered, :creation_date
+    # and :error.
+    #
+    # ==== Regex Options
+    # * <tt>:registered</tt> -- If this regular expression matches the whois output, this domain is considered registered.
+    # * <tt>:free</tt> -- If this regular expression matches the whois output, the domain is considered available.
+    # * <tt>:error</tt> -- If this regular expression matches, an error is said to have occurred.
+    # * <tt>:creation_date</tt> -- If this regular expression matches, the value of the second set of parentheses is parsed
+    #   using ParseDate and used as the creation date for this domain.
+    #
+    # Note, the preferred location for Whois::Server definitions is the server_list.rb file.  Definitions should go from
+    # least specific to most specific, as subsequent definitions for a TLD will override previous ones.
+    def self.define(tlds, server = nil, regexes = nil, &block)
+      tlds = tlds.kind_of?(Array) ? tlds : [tlds]
+      tlds.each do |tld|
+        define_single(tld, server, regexes, &block)
+      end
+      tlds
+    end
 
-    def initialize(tld, nic_server = nil, options = {})
-      @tld = tld
+    def initialize(tld, nic_server = nil, options = nil) #:nodoc:
+      @tld = tld.gsub(/^\.+/, '')
+      options ||= Hash.new
       @response_cache = Hash.new("")
       @nic_server = nic_server
       @port = options.delete(:port)
-      @regexes = options.reverse_merge(
-        :free => /(avail|free|no match|no entr|not taken|not registered|not found)/im,
-        :registered => /(registered|Domain ID|domain name\s*\:|is active|is not available|exists|\bregistrant\b|Created on)/im,
-        :created_date => /(Creation date|created on|created at|Commencement Date|Registration Date)\s*[\:\.]*\s*([\w\-\:\ ]+)[^\n\r]*[\n\r]/im,
-        :error => /(error)/im
-        )
+      @regexes = options.reverse_merge(DEFAULT_WHOIS_REGULAR_EXPRESSIONS)
+      @regexes.each do |key, rx|
+        next unless rx.kind_of?(Array)
+        rx2 = Regexp.new(Regexp.escape(rx.first).gsub(/\s+/, '\s*'))
+        rx2 = rx2.new_options(rx[1])
+        rx2 = rx2.interpolate(/\s+/, '\s+')
+        rx2.invert! if ((rx[2] == true) rescue false)
+        @regexes[key] = rx2
+      end
     end
 
-    # Class variable accessors
+    # A hash of all of the known whois servers indexed by TLD
     def self.list
       @@list ||= Hash.new
     end
@@ -27,21 +78,21 @@ module Whois
       @@list = value
     end
 
-    def self.domain_object_cache
+    def self.domain_object_cache #:nodoc:
       @@domain_object_cache ||= Hash.new
     end
 
-    def self.domain_object_cache=(value)
+    def self.domain_object_cache=(value) #:nodoc:
       @@domain_object_cache = value
     end
 
+    # A list of strings representing all supported TLDs.
     def self.defined_tlds
       self.list.collect {|tld,server| tld.gsub(/^\./, '') }
     end
 
-    # Find a TLD from a full domain name.  There is special care to check for
-    # two part TLD's (such as .co.uk, .kids.us, etc) first and then to look for
-    # the last part alone.
+    # Find a TLD from a full domain name.  There is special care to check for two part TLDs
+    # (such as .co.uk, .kids.us, etc) first and then to look for the last part alone.
     def self.find_server_from_domain(domain)
       # valid domain?
       return nil unless domain =~ /^((?:[-a-zA-Z0-9]+\.)+[a-zA-Z]{2,})$/
@@ -67,6 +118,12 @@ module Whois
       return tld
     end
 
+    # Look up a domain name.  If a proper whois server can not be found for this domain name's extension,
+    # it will return nil.  Otherwise it returns a Whois::Domain object.
+    #
+    # Note: the preferred way to call this method is through the wrapper:
+    #
+    #   Whois.find(domain)
     def self.find(domain)
       domain = domain.to_s.strip.downcase
       return domain_object_cache[domain] unless domain_object_cache[domain].blank?
@@ -74,6 +131,7 @@ module Whois
       domain_object_cache[domain] = Whois::Domain.new(domain, server.tld)
     end
 
+    # Determine the appropriate whois server object for a domain name.
     def self.server_for_domain(domain)
       server = self.find_server_from_domain(domain)
       # This will only work on single extension domains
@@ -86,21 +144,67 @@ module Whois
       server
     end
 
+    def unavailable?
+      @unavailable ? true : false
+    end
+
+    # Retrieve the raw WHOIS server output for a domain.
     def raw_response(domain)
+      return nil if unavailable?
       return @response_cache[domain] if !@response_cache[domain].blank?
       @response_cache[domain] = ""
-      if nic_server =~ /^http/
+      if nic_server.kind_of?(Array)
+        interpolate_vars = {
+          '%DOMAIN%' => domain,
+          '%DOMAIN_NO_TLD%' => domain.gsub(/\.#{tld.to_s}$/i, ''),
+          '%TLD%' => tld
+          }
+
+        url = URI.parse(nic_server.first.dup.interpolate(interpolate_vars))
+        method = nic_server[1] || :post
+        req = "Net::HTTP::#{method.to_s.capitalize}".constantize.new(url.path)
+        form_data = nic_server[2].dup || {}
+        form_data.each { |k,v| form_data[k] = v.interpolate(interpolate_vars) }
+        req.set_form_data(form_data)
+        res = begin
+          Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+        rescue Net::HTTPBadResponse
+          nil # Ignore these for now...
+        end
+        @response_cache[domain] = case res
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          res.body
+        else
+          ''
+        end
+      elsif nic_server.to_s =~ /^http/
         url = nic_server.gsub(/\%DOMAIN\%/, domain)
         @response_cache[domain] = Net::HTTP.get_response(URI.parse(url)).body
       else
-        command = "#{@@whois_bin} #{('-h ' + @nic_server) unless @nic_server.blank?} #{self.class.shell_escape(domain)} 2>&1"
+        command = "#{WHOIS_BIN} #{('-h ' + @nic_server) unless @nic_server.blank?} #{self.class.shell_escape(domain)} 2>&1"
         @response_cache[domain] = Whois::Server.run_command_with_timeout(command, 10, true)
       end
-      @response_cache[domain]
+      if match = regexes[:server_unavailable].match_with_inversion(@response_cache[domain])
+        @server_unavailable = true
+        @unavailable_response = match[1]
+        nil
+      else
+        @response_cache[domain]
+      end
+    end
+
+    def raw_response!(domain)
+      res = raw_response(domain)
+      if !res || !res.respond_to?(:to_s) || res.blank?
+        raise Whois::Server::Unavailable, "The WHOIS server for TLD #{tld.to_s} is currently unavailable. (response: #{unavailable_response})"
+      end
+      res
     end
 
+    # Used as a fallback in case no specific WHOIS server is defined for a given TLD.  An attempt will be made to search
+    # the IANA global registrar database to find a suitable whois server.
     def self.define_from_iana(tld)
-      iana_out = run_command_with_timeout("#{@@whois_bin} -h whois.iana.org #{shell_escape(tld.to_s)} 2>&1", 10, false)
+      iana_out = run_command_with_timeout("#{WHOIS_BIN} -h whois.iana.org #{shell_escape(tld.to_s)} 2>&1", 10, false)
       return false if iana_out.blank?
       return false unless iana_out =~ /Whois\s+Server\s+\(port ([\d]+)\)\: ([\w\-\.\_]+)/im
       port = $1
@@ -108,23 +212,14 @@ module Whois
       define_single(tld.to_s, server, :port => port)
     end
 
-    def self.define_single(*args, &block)
+    def self.define_single(*args, &block) #:nodoc:
       new_server = allocate
       new_server.send(:initialize, *args, &block)
       list[args.first.to_s] = new_server
       new_server
     end
 
-    def self.define(*args, &block)
-      tld_list = args.shift
-      tld_list = tld_list.kind_of?(Array) ? tld_list : [tld_list]
-      tld_list.each do |tld|
-        define_single(*args.clone.unshift(tld.to_s), &block)
-      end
-      tld_list
-    end
-
-    def self.run_command_with_timeout(command, timeout = 10, do_raise = false)
+    def self.run_command_with_timeout(command, timeout = 10, do_raise = false) #:nodoc:
       @output = ""
       begin
         status = Timeout::timeout(10) do
@@ -137,14 +232,15 @@ module Whois
           raise "Running command \"#{command}\" timed out."
         end
       end
+      @output.strip!
       @output
     end
 
-    def self.shell_escape(word)
-      word.to_s.gsub(/[^\w\-\_\.]+/, '')
+    def self.shell_escape(word) #:nodoc:
+      word.to_s.gsub(/[^\w\-\_\.]+/, '') rescue ''
     end
 
-  end # class Server
+  end
 
 end
 

data/lib/universal_ruby_whois/server_list.rb

@@ -68,8 +68,6 @@ Whois::Server.define('ch',"whois.nic.ch")
 Whois::Server.define('cn',"whois.cnnic.net.cn")
 Whois::Server.define('cz',"whois.nic.cz")
 Whois::Server.define('ee',"whois.eenet.ee")
-Whois::Server.define('es',"https://www.nic.es/esnic/servlet/BuscarDomSolAlta?dominio=%DOMAIN%")
-Whois::Server.define('com.es',"https://www.nic.es/esnic/servlet/BuscarDomSolAlta?dominio=%DOMAIN%")
 Whois::Server.define('gr',"https://grweb.ics.forth.gr/")
 Whois::Server.define('it',"whois.nic.it")
 Whois::Server.define('li',"whois.nic.li")
@@ -88,6 +86,24 @@ Whois::Server.define('tc',"whois.adamsnames.tc")
 Whois::Server.define('vg',"whois.adamsnames.tc")
 Whois::Server.define('ws',"whois.worldsite.ws")
 
+#Whois::Server.define('es',"https://www.nic.es/esnic/servlet/BuscarDomSolAlta?dominio=%DOMAIN%")
+#Whois::Server.define('com.es',"https://www.nic.es/esnic/servlet/BuscarDomSolAlta?dominio=%DOMAIN%")
+
+Whois::Server.define(
+  %w(jp co.jp or.jp ne.jp ac.jp ad.jp ed.jp go.jp gr.jp lg.jp),
+  ['http://whois.jprs.jp/en/', :post, { :submit => 'query', :key => '%DOMAIN%', :type => 'DOM'}],
+  :registered => /Domain Information\:/im,
+  :free => /No match\!\!/im
+)
+
+Whois::Server.define(
+  %w(es com.es nom.es org.es gob.es edu.es),
+  ['https://www.nic.es/esnic/servlet/BuscarDomSolAlta', :post, { :Submit => 'Buscar', :domino => '%DOMAIN_NO_TLD%',
+    :sufijo => '%TLD%', :tipo => 'dominio'}],
+  :registered => [%q{%DOMAIN% </a> </th> <td class="disp"> <img src="../images/icon_disp_no.gif" alt="no" />}, 'im'],
+  :free => [%q{%DOMAIN% </a> </th> <td class="disp"> <img src="../images/icon_disp_yes.gif" alt="si" />}, 'im']
+)
+
 
 # By leaving out the whois server, we force it to follow the internic redirection.
 Whois::Server.define(
@@ -104,7 +120,8 @@ Whois::Server.define(
 
 Whois::Server.define(%w(asn.au com.au id.au net.au org.au), 'whois.aunic.net',
   :free => /No Data Found/im,
-  :registered => /No Data Found/im.invert! )
+  :registered => /No Data Found/im.invert!,
+  :error => /BLACKLISTED/m )
 
 Whois::Server.define(
  %w(hk com.hk net.hk edu.hk org.hk gov.hk idv.hk),
@@ -238,3 +255,9 @@ Whois::Server.define('asia', 'whois.nic.asia',
   :registered => /Domain ID/im,
   :free => /NOT FOUND/im
 )
+Whois::Server.define(
+ '.co.il',
+ 'whois.isoc.org.il',
+ :registered => /validity:/im,
+ :free => /No data was found to match the request criteria./im
+)

data/test/regexp.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/universal_ruby_whois'
+
+class RegexpTest < Test::Unit::TestCase
+
+  def test_inversion
+    r = /hi there/.invert!
+    assert !r.match_with_inversion("hi there")
+    r.uninvert!
+    assert r.match_with_inversion("hi there")
+  end
+
+  def test_interpolation
+    r = /hello __REPLACEME__ end/
+    assert_equal "hello __REPLACEME__ end", r.source
+    old_options = r.options
+    r2 = r.interpolate("__REPLACEME__" => "a value")
+    assert_equal old_options, r2.options
+    assert_equal "hello a value end", r2.source
+  end
+
+end

data/test/string.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/universal_ruby_whois'
+
+class StringTest < Test::Unit::TestCase
+
+  def test_interpolation
+    s = "hello __REPLACEME__ end"
+    assert_equal "hello __REPLACEME__ end", s
+    s2 = s.interpolate("__REPLACEME__" => "a value")
+    assert_equal "hello a value end", s2
+  end
+
+end

data/test/whois.rb

@@ -3,21 +3,60 @@ require File.dirname(__FILE__) + '/../lib/universal_ruby_whois'
 
 class WhoisTest < Test::Unit::TestCase
 
+  TEST_TLDS = %w(com org co.uk eu.com ru info jp)
+  REGISTERED_DOMAIN = "google"
+  AVAILABLE_DOMAIN = "asdfasdfasdfcvr3rwsdc2e"
+
+  def test_invalid_tld
+    domain = Whois.find("hello.blahblah")
+    assert_nil domain
+  end
+
   def test_unavailable
-    domain = Whois::Server.find("google.com")
-    assert !domain.available?
-    assert domain.registered?
+    TEST_TLDS.each do |tld|
+      domain = find_and_assert_domain("#{REGISTERED_DOMAIN}.#{tld}")
+      assert !domain.available?, "The domain name #{domain} shows as available but should not."
+      assert domain.registered?, "The domain name #{domain} does not show as registered but should."
+    end
   end
 
   def test_available
-    domain = Whois::Server.find("j983jf89ej2e09d2jd.com")
-    assert domain.available?
-    assert !domain.registered?
+    TEST_TLDS.each do |tld|
+      domain = find_and_assert_domain("#{AVAILABLE_DOMAIN}.#{tld}")
+      assert domain.available?, "The domain name #{domain} does not show as available but should."
+      assert !domain.registered?, "The domain name #{domain} shows as registered but should not."
+    end
   end
 
   def test_creation_date
-    domain = Whois::Server.find("google.com")
-    domain.created_date == Time.local(*ParseDate.parsedate("1997-09-15"))
+    domain = find_and_assert_domain("google.com")
+    assert_equal Time.local(*ParseDate.parsedate("1997-09-15")), domain.creation_date
+
+    TEST_TLDS.each do |tld|
+      domain = find_and_assert_domain("#{REGISTERED_DOMAIN}.#{tld}")
+      next unless domain.creation_date_known?
+      assert_kind_of Time, domain.creation_date, "Can't find creation date for domain: #{domain}"
+    end
+  end
+
+  def test_expiration_date
+    domain = find_and_assert_domain("google.com")
+    assert_equal Time.local(*ParseDate.parsedate("2011-09-13")), domain.expiration_date
+
+    TEST_TLDS.each do |tld|
+      domain = find_and_assert_domain("#{REGISTERED_DOMAIN}.#{tld}")
+      next unless domain.expiration_date_known?
+      assert_kind_of Time, domain.expiration_date, "Can't find expiration date for domain: #{domain}"
+    end
+  end
+
+  protected
+
+  def find_and_assert_domain(domain)
+    domain_object = ::Whois.find(domain)
+    assert_kind_of Whois::Domain, domain_object, "Unable to look up info for domain name: #{domain}"
+    assert domain_object.valid?, "The domain name object for #{domain} is not valid (perhaps the whois server is down or busy?)"
+    domain_object
   end
 
 end

data/universal_ruby_whois.gemspec

@@ -0,0 +1,40 @@
+PKG_NAME      = 'universal_ruby_whois'
+PKG_VERSION   = '1.2.1'
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = 'universalwhois'
+RUBY_FORGE_USER    = 'mlightner'
+
+GEM_SPEC = spec = Gem::Specification.new do |s| 
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.author = "Matt Lightner"
+  s.email = "mlightner@gmail.com"
+  s.homepage = "http://github.com/mlightner/universal_ruby_whois/tree/master"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "A module that attempts to act as a universal WHOIS output interpreter allowing you to get information about most domain name extensions."
+  s.files = %w(
+    README.rdoc
+    CHANGELOG.rdoc
+    LICENSE
+    universal_ruby_whois.gemspec
+    lib/universal_ruby_whois.rb
+    lib/universal_ruby_whois/server.rb
+    lib/universal_ruby_whois/server_list.rb
+    lib/universal_ruby_whois/domain.rb
+    lib/support/extended_regexp.rb
+    lib/support/string.rb
+    test/whois.rb
+    test/string.rb
+    test/regexp.rb
+    )
+  s.require_path = "lib"
+  s.autorequire = "name"
+  s.add_dependency('activesupport', '>= 1.4.4')
+  s.test_files = %w(
+    test/whois.rb
+    test/string.rb
+    test/regexp.rb
+    )    
+  s.has_rdoc = true
+  #s.extra_rdoc_files = ["README", "LICENSE"]
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mlightner-universal_ruby_whois
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.2.1
 platform: ruby
 authors: 
 - Matt Lightner
@@ -9,7 +9,7 @@ autorequire: name
 bindir: bin
 cert_chain: []
 
-date: 2008-10-09 00:00:00 -07:00
+date: 2008-10-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,16 +27,22 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README
-- LICENSE
+extra_rdoc_files: []
+
 files: 
-- README
+- README.rdoc
+- CHANGELOG.rdoc
 - LICENSE
+- universal_ruby_whois.gemspec
 - lib/universal_ruby_whois.rb
-- lib/universal_ruby_whois/domain.rb
 - lib/universal_ruby_whois/server.rb
 - lib/universal_ruby_whois/server_list.rb
+- lib/universal_ruby_whois/domain.rb
+- lib/support/extended_regexp.rb
+- lib/support/string.rb
+- test/whois.rb
+- test/string.rb
+- test/regexp.rb
 has_rdoc: true
 homepage: http://github.com/mlightner/universal_ruby_whois/tree/master
 post_install_message: 
@@ -65,3 +71,5 @@ specification_version: 2
 summary: A module that attempts to act as a universal WHOIS output interpreter allowing you to get information about most domain name extensions.
 test_files: 
 - test/whois.rb
+- test/string.rb
+- test/regexp.rb