coreymartella-universal_ruby_whois 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/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2008 Matt Lightner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,78 @@
+= 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.creation_date
+  => Mon Aug 28 00:00:00 EDT 2006
+  domain.expiration_date
+  => Fri Aug 28 00:00:00 EDT 2009
+  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

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'activesupport'
+require 'net/http'
+require 'uri'
+require 'time'
+require 'timeout'
+
+require File.dirname(__FILE__) + '/support/string'
+require File.dirname(__FILE__) + '/support/extended_regexp'
+Regexp.class_eval do
+  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

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/server'
+require 'time'
+
+module Whois
+
+  class Domain
+
+    # The domain name, lower case, no spaces.
+    attr_reader :domain
+
+    # 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] rescue nil
+    end
+
+    # The set of regular expressions that will be used in matching this domain's whois output.
+    def 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 = 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)
+        return(@status = status) if regexes[status].match_with_inversion(whois_output)
+      end
+      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
+
+    # 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
+      @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
+
+end
+

data/lib/universal_ruby_whois/server.rb

@@ -0,0 +1,246 @@
+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
+
+    # 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 = '/usr/bin/env whois'
+
+    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 = nil) #:nodoc:
+      @tld = tld.gsub(/^\.+/, '')
+      options ||= Hash.new
+      @response_cache = Hash.new("")
+      @nic_server = nic_server
+      @port = options.delete(:port)
+      @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
+
+    # A hash of all of the known whois servers indexed by TLD
+    def self.list
+      @@list ||= Hash.new
+    end
+
+    def self.list=(value)
+      @@list = value
+    end
+
+    def self.domain_object_cache #:nodoc:
+      @@domain_object_cache ||= Hash.new
+    end
+
+    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 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,})$/
+
+      # start the searching.
+      tld = nil
+      parts = domain.split('.')
+
+      # if the passed domain is more than two parts (. separated strings)
+      # try to find the TLD from the last two parts (ie, .co.uk)
+      if parts.size > 2
+        tld_string = parts[-2,2].join('.')
+        tld = self.list[tld_string]
+      end
+
+      # if nothing was found, check for a match on the last part only.
+      if tld.blank?
+        tld_string = parts.last
+        tld = self.list[tld_string]
+      end
+
+      return nil if !tld.kind_of?(Whois::Server)
+      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?
+      return nil unless server = server_for_domain(domain)
+      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
+      if server.blank? # && domain.scan(/(\.)/).length == 1
+        domain =~ /\.([\w\-]+)$/
+        tld = $1
+        self.define_from_iana(tld)
+        return false unless server = self.find_server_from_domain(domain)
+      end
+      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.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"
+        @response_cache[domain] = Whois::Server.run_command_with_timeout(command, 10, true)
+      end
+      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)
+      return false if iana_out.blank?
+      return false unless iana_out =~ /Whois\s+Server\s+\(port ([\d]+)\)\: ([\w\-\.\_]+)/im
+      port = $1
+      server = $2
+      define_single(tld.to_s, server, :port => port)
+    end
+
+    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.run_command_with_timeout(command, timeout = 10, do_raise = false) #:nodoc:
+      @output = ""
+      begin
+        status = Timeout::timeout(10) do
+          IO.popen(command, "r") do |io|
+            @output << "#{io.read.to_s}"
+          end
+        end
+      rescue Exception => e
+        if do_raise
+          raise "Running command \"#{command}\" timed out."
+        end
+      end
+      @output.strip!
+      @output
+    end
+
+    def self.shell_escape(word) #:nodoc:
+      word.to_s.gsub(/[^\w\-\_\.]+/, '') rescue ''
+    end
+
+  end
+
+end
+

data/lib/universal_ruby_whois/server_list.rb

@@ -0,0 +1,269 @@
+# Define whois servers and their corresponding output format in this file.
+# If no regular expressions are given to match states, some reasonable
+# defaults will be used, but more specific is always better  :)
+
+# More generic definitions should appear first, as the more specific definitions
+# will overwrite them in the extension dictionary if they appear later in the file.
+
+Whois::Server.define('ae', 'whois.uaenic.ae')
+Whois::Server.define('ai', 'whois.ainic.ai')
+Whois::Server.define('as', 'whois.nic.as')
+Whois::Server.define('at', 'whois.nic.at')
+Whois::Server.define('bg', 'whois.digsys.bg')
+Whois::Server.define('bi', 'whois.nic.bi')
+Whois::Server.define('bj', 'www.nic.bj')
+Whois::Server.define('bz', 'whois.belizenic.bz')
+Whois::Server.define('cc', 'whois.nic.cc')
+Whois::Server.define('cd', 'whois.nic.cd')
+Whois::Server.define('ck', 'whois.nic.ckcn')
+Whois::Server.define('de', 'whois.denic.de')
+Whois::Server.define('fo', 'whois.ripe.net')
+Whois::Server.define('gg', 'whois.isles.net')
+Whois::Server.define('gl', 'whois.ripe.net')
+Whois::Server.define('gm', 'whois.ripe.net')
+Whois::Server.define('gr', 'whois.grnet.gr')
+Whois::Server.define('gs', 'whois.gs')
+Whois::Server.define('hm', 'webhst1.capital.hm')
+Whois::Server.define('hu', 'whois.nic.hu')
+Whois::Server.define('id', 'whois.idnic.net.id')
+Whois::Server.define('in', 'whois.inregistry.net')
+Whois::Server.define('ir', 'whois.nic.ir')
+Whois::Server.define('kz', 'whois.nic.kz')
+Whois::Server.define('la', 'whois2.afilias-grs.net')
+Whois::Server.define('ly', 'whois.lydomains.com')
+Whois::Server.define('mc', 'whois.ripe.net')
+Whois::Server.define('ms', 'whois.ms')
+Whois::Server.define('mx', 'whois.nic.mx')
+Whois::Server.define('my', 'whois.mynic.net.my')
+Whois::Server.define('nu', 'whois.nic.nu')
+Whois::Server.define('pl', 'whois.dns.pl')
+Whois::Server.define('pm', 'whois.nic.pm')
+Whois::Server.define('pro', 'whois.registrypro.pro')
+Whois::Server.define('pt', 'whois.nic.pt')
+Whois::Server.define('sa', 'saudinic.net.sa')
+Whois::Server.define('sb', 'whois.nic.net.sb')
+Whois::Server.define('se', 'whois.nic-se.se')
+Whois::Server.define('si', 'whois.arnes.si')
+Whois::Server.define('sk', 'whois.sk-nic.sk')
+Whois::Server.define('sm', 'whois.ripe.net')
+Whois::Server.define('st', 'whois.nic.st')
+Whois::Server.define('su', 'whois.ripn.net')
+Whois::Server.define('tc', 'whois.tc')
+Whois::Server.define('th', 'whois.thnic.net')
+Whois::Server.define('to', 'whois.tonic.to')
+Whois::Server.define('tv', 'tvwhois.verisign-grs.com')
+Whois::Server.define('uy', 'www.nic.org.uy')
+Whois::Server.define('uz', 'whois.cctld.uz')
+Whois::Server.define('va', 'whois.ripe.net')
+Whois::Server.define('ve', 'whois.nic.ve')
+Whois::Server.define('vg', 'whois.vg')
+Whois::Server.define('wf', 'whois.nic.wf')
+Whois::Server.define('ws', 'whois.tld.ws')
+Whois::Server.define('yt', 'whois.nic.yt')
+Whois::Server.define('us', 'whois.nic.us')
+Whois::Server.define('at',"whois.nic.at")
+Whois::Server.define('ca',"whois.cira.ca")
+Whois::Server.define('cc',"whois.nic.cc")
+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('gr',"https://grweb.ics.forth.gr/")
+Whois::Server.define('it',"whois.nic.it")
+Whois::Server.define('li',"whois.nic.li")
+Whois::Server.define('lt',"whois.domreg.lt")
+Whois::Server.define('lu',"whois.dns.lu")
+Whois::Server.define('lv',"whois.ripe.net")
+Whois::Server.define('ms',"whois.adamsnames.tc")
+Whois::Server.define('co.nz',"whois.domainz.net.nz")
+Whois::Server.define('nu',"whois.nic.nu")
+Whois::Server.define('pl',"whois.dns.pl")
+Whois::Server.define('ro',"whois.rotld.ro")
+Whois::Server.define('ru',"whois.ripn.net")
+Whois::Server.define('se',"whois.nic-se.se")
+Whois::Server.define('sk',"whois.ripe.net")
+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(
+  [ 'com', 'net', 'edu' ], nil,
+  :registered => /No match for/im.invert!,
+  :free => /No match for/im
+)
+
+Whois::Server.define(
+  'gov', 'whois.nic.gov',
+  :registered => /Status:\s*Active/im,
+  :free => /Status:\s*Active/im.invert!
+)
+
+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!,
+  :error => /BLACKLISTED/m )
+
+Whois::Server.define(
+ %w(hk com.hk net.hk edu.hk org.hk gov.hk idv.hk),
+ 'whois.hkdnr.net.hk',
+  :free => /Domain Not Found/,
+  :registered => /Domain Name\:/im
+)
+Whois::Server.define(
+  %w(co.nz net.nz org.nz geek.nz school.nz gen.nz govt.nz maori.nz ac.nz iwi.nz cri.nz mil.nz parliament.nz),
+  'whois.srs.net.nz',
+  :free => /220 available/im,
+  :registered => /220 available/im.invert!
+)
+Whois::Server.define(
+  %w(eu.com uk.com uk.net us.com la cn.com de.com jpn.com kr.com no.com za.com br.com ar.com ru.com sa.com se.com
+     se.net hu.com gb.com gb.net qc.com uy.com ae.org no.com se.com),
+  'whois.centralnic.net',
+  :free => /available for registration/im,
+  :registered => /Domain Name\:/im
+  )
+Whois::Server.define(
+  'be',
+  'whois.dns.be',
+  :free => /Status:\s+FREE/im,
+  :registered => /Status:\s+REGISTERED/im
+)
+Whois::Server.define(
+  'biz',
+  'whois.neulevel.biz',
+  :free => /Not found:/im,
+  :registered => /Domain Name:/im
+)
+Whois::Server.define(
+  %w(co.uk org.uk me.uk ltd.uk plc.uk net.uk sch.uk),
+  'whois.nic.uk',
+  :registered => /Domain name:/im,
+  :free => /No match for/im,
+  :error => /Error for/im
+)
+Whois::Server.define(
+  'de',
+  'whois.denic.de',
+  :error => /Status:\s+invalid/im,
+  :registered => /Status:\s+connect/im,
+  :free => /Status:\s+free/im
+)
+Whois::Server.define(
+  'dk',
+  'whois.dk-hostmaster.dk',
+  :registered => /Registered:/im,
+  :error => /Your request is not valid./im,
+  :free => /No entries found for the selected source./im
+)
+Whois::Server.define(
+  'eu',
+  'http://www.whois.eu/whois/GetDomainStatus.htm?domainName=%DOMAIN%',
+  :free => /AVAILABLE/im,
+  :registered => /REGISTERED/im,
+  :pending => /APPLICATION PENDING/im,
+  :error => /NOT ALLOWED/im
+)
+Whois::Server.define(
+  'info',
+  'whois.afilias.info',
+  :error => /Not a valid domain search pattern/im,
+  :registered => /Domain Name:/im,
+  :free => /NOT FOUND/im
+)
+Whois::Server.define(
+  'name',
+  'whois.nic.name',
+  :registered => /Not available for registration./im,
+  :preserved => /Not available for second level registration./im,
+  :free => /No match./im
+)
+# Whois::Server.define(
+#   'net',
+#   'whois.verisign-grs.com',
+#   :registered => /Domain Name:/im,
+#   :free => /No match for/im
+# )
+Whois::Server.define(
+  'nl',
+  'whois.domain-registry.nl',
+  :registered => /ims active/im,
+  :free => /ims free/im,
+  :error => /imnvalid name/im,
+  :preserved => /ims excluded/im
+)
+Whois::Server.define(
+  'org',
+  'whois.publicinterestregistry.net',
+  :registered => /Domain Name:/im,
+  :free => /NOT FOUND/im,
+  :error => /Not a valid domain search pattern/im  
+)
+Whois::Server.define(
+  'cc',
+  'whois.nic.cc',
+  :registered => /Domain Name:/im,
+  :free => /No match for/im
+  
+)
+Whois::Server.define(
+  'ru',
+  'whois.ripn.net',
+  :registered => /domain:/im,
+  :free => /No entries found/im
+  
+)
+Whois::Server.define(
+  'cat',
+  'whois.cat',
+  :registered => /Domain Name: /im,
+  :free => /NOT FOUND/im
+  
+)
+Whois::Server.define(
+  %w(travel jobs aero pw tw),
+  'whois.encirca.com',
+  :registered => /Domain Registrar Status:/im,
+  :free => /Not found:/im
+)
+Whois::Server.define(
+  'mobi',
+  'whois.corenic.net',
+  :registered => /Domain ID:/im,
+  :free => /NOT FOUND/m
+)
+Whois::Server.define(
+  'ca',
+  'whois.cira.ca',
+  :registered => /EXIST/im,
+  :free => /AVAIL/im
+)
+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

@@ -0,0 +1,62 @@
+require 'test/unit'
+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
+    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
+    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 = 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    = 'coreymartella'
+
+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/coreymartella/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

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: coreymartella-universal_ruby_whois
+version: !ruby/object:Gem::Version 
+  version: 1.2.1
+platform: ruby
+authors: 
+- Matt Lightner
+autorequire: name
+bindir: bin
+cert_chain: []
+
+date: 2009-01-11 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.4
+    version: 
+description: 
+email: mlightner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- 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
+has_rdoc: true
+homepage: http://github.com/coreymartella/universal_ruby_whois/tree/master
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+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