whois 0.9.0 → 1.0.0

data/test/answer/parser/whois.za.net_test.rb

@@ -42,10 +42,8 @@ class AnswerParserWhoisZaNetTest < Whois::Answer::Parser::TestCase
   end
 
   def test_expires_on
-    assert_equal  nil,
-                  @klass.new(load_part('/registered.txt')).expires_on
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).expires_on
+    assert_raise(Whois::PropertyNotSupported) { @klass.new(load_part('/registered.txt')).expires_on }
+    assert_raise(Whois::PropertyNotSupported) { @klass.new(load_part('/available.txt')).expires_on }
   end
 
 end

data/test/answer/parser/whois.za.org_test.rb

@@ -42,10 +42,8 @@ class AnswerParserWhoisZaOrgTest < Whois::Answer::Parser::TestCase
   end
 
   def test_expires_on
-    assert_equal  nil,
-                  @klass.new(load_part('/registered.txt')).expires_on
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).expires_on
+    assert_raise(Whois::PropertyNotSupported) { @klass.new(load_part('/registered.txt')).expires_on }
+    assert_raise(Whois::PropertyNotSupported) { @klass.new(load_part('/available.txt')).expires_on }
   end
 
 end

data/test/answer/parser_test.rb

@@ -50,85 +50,98 @@ class AnswerParserTest < Test::Unit::TestCase
   end
 
 
-  # DEPRECATED
-  def test_supported_with_zero_parts
+  def test_property_supported_with_zero_parts
     answer = Whois::Answer.new(nil, [])
     parser = @klass.new(answer)
-    assert !parser.supported?(:disclaimer)
+    assert !parser.property_supported?(:disclaimer)
   end
 
-  # DEPRECATED
-  def test_supported_with_one_part_supported
+  def test_property_supported_with_one_part_supported
     answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.nic.it")])
     parser = @klass.new(answer)
-    assert  parser.supported?(:disclaimer)
+    assert  parser.property_supported?(:disclaimer)
   end
 
-  # DEPRECATED
-  def test_supported_with_one_part_unsupported
+  def test_property_supported_with_one_part_unsupported
     answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "invalid.nic.it")])
     parser = @klass.new(answer)
-    assert !parser.supported?(:disclaimer)
+    assert !parser.property_supported?(:disclaimer)
   end
 
-  # DEPRECATED
-  def test_supported_with_two_parts
+  def test_property_supported_with_two_parts
     answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.crsnic.net"), Whois::Answer::Part.new(nil, "whois.nic.it")])
     parser = @klass.new(answer)
     assert  parser.property_supported?(:disclaimer)
   end
 
-  def test_property_supported_with_zero_parts
-    answer = Whois::Answer.new(nil, [])
-    parser = @klass.new(answer)
-    assert !parser.property_supported?(:disclaimer)
+
+  class Whois::Answer::Parser::TestParserSupported < Whois::Answer::Parser::Base
+    property_supported :status do
+      :status_supported
+    end
+    property_supported :created_on do
+      :created_on_supported
+    end
+    property_supported :updated_on do
+      :updated_on_supported
+    end
+    property_supported :expires_on do
+      :expires_on_supported
+    end
+  end
+  class Whois::Answer::Parser::TestParserUndefined < Whois::Answer::Parser::Base
+    property_supported :status do
+      :status_undefined
+    end
+    # not defined          :created_on
+    # not defined          :updated_on
+    # not defined          :expires_on
+  end
+  class Whois::Answer::Parser::TestParserUnsupported < Whois::Answer::Parser::Base
+    property_not_supported :status
+    property_not_supported :created_on
+    property_not_supported :updated_on
+    property_not_supported :expires_on
   end
 
-  def test_property_supported_with_one_part_supported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.nic.it")])
+  def test_delegate_property_to_parsers_should_delegate_to_first_with_all_supported
+    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.supported"), Whois::Answer::Part.new("", "test.parser.undefined")])
     parser = @klass.new(answer)
-    assert  parser.property_supported?(:disclaimer)
-  end
+    assert_equal :status_undefined, parser.status
 
-  def test_property_supported_with_one_part_unsupported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "invalid.nic.it")])
+    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.undefined"), Whois::Answer::Part.new("", "test.parser.supported")])
     parser = @klass.new(answer)
-    assert !parser.property_supported?(:disclaimer)
+    assert_equal :status_supported, parser.status
   end
 
-  def test_property_supported_with_two_parts
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.crsnic.net"), Whois::Answer::Part.new(nil, "whois.nic.it")])
+  def test_delegate_property_to_parsers_should_delegate_to_first_with_one_supported
+    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.supported"), Whois::Answer::Part.new("", "test.parser.undefined")])
     parser = @klass.new(answer)
-    assert  parser.property_supported?(:disclaimer)
+    assert_equal :created_on_supported, parser.created_on
+    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.supported"), Whois::Answer::Part.new("", "test.parser.unsupported")])
+    parser = @klass.new(answer)
+    assert_equal :created_on_supported, parser.created_on
   end
 
-
-  (Whois::Answer::Parser.properties - [:referral_url, :referral_whois]).each do |method|
-    define_method "test_should_delegate_#{method}_to_parsers_first_parser_if_supported" do
-      answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
-      parser = @klass.new(answer)
-      parser.parsers.first.expects(method).returns(:value)
-      assert_equal :value, parser.send(method)
-    end
+  def test_delegate_property_to_parsers_should_raise_unless_supported
+    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.unsupported"), Whois::Answer::Part.new("", "test.parser.unsupported")])
+    parser = @klass.new(answer)
+    assert_raise(Whois::PropertyNotSupported) { parser.created_on }
   end
 
-  [:referral_url, :referral_whois].each do |method|
-    define_method "test_should_delegate_#{method}_to_parsers_raise_unless_supported" do
-      answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
-      parser = @klass.new(answer)
-      assert_raise(Whois::PropertyNotSupported) { parser.send(method) }
-    end
+  def test_delegate_property_to_parsers_should_raise_unless_available
+    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.undefined"), Whois::Answer::Part.new("", "test.parser.undefined")])
+    parser = @klass.new(answer)
+    assert_raise(Whois::PropertyNotAvailable) { parser.created_on }
   end
 
-  Whois::Answer::Parser.properties.each do |method|
-    define_method "test_should_delegate_#{method}_to_parser_raise_with_no_zero_parts" do
-      answer = Whois::Answer.new(nil, [])
-      parser = @klass.new(answer)
-      assert_raise(Whois::ParserError) { parser.send(method) }
-    end
+  def test_delegate_property_to_parsers_should_raise_with_zero_parts
+    answer = Whois::Answer.new(nil, [])
+    parser = @klass.new(answer)
+    assert_raise(Whois::ParserError) { parser.created_on }
   end
 
-  def test_should_not_delegate_unallowed_method_to_parser
+  def test_delegate_property_to_parser_should_not_delegate_unallowed_methods
     answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
     parser = @klass.new(answer)
     parser.parsers.expects("unallowed_method").never
@@ -136,11 +149,11 @@ class AnswerParserTest < Test::Unit::TestCase
   end
 
 
-  def test_parser_klass
+  def test_self_parser_klass
     assert_equal "Whois::Answer::Parser::WhoisNicIt", @klass.parser_klass("whois.nic.it").name
   end
 
-  def test_parser_klass_with_preloaded_class
+  def test_self_parser_klass_with_preloaded_class
     @klass.class_eval <<-RUBY
       class WhoisFooBar
       end
@@ -148,4 +161,14 @@ class AnswerParserTest < Test::Unit::TestCase
     assert_equal "Whois::Answer::Parser::WhoisFooBar", @klass.parser_klass("whois.foo.bar").name
   end
 
+  def test_self_parser_klass_should_return_blank_class_if_parser_doesnt_exist
+    assert_equal "Whois::Answer::Parser::Blank", @klass.parser_klass("whois.missing").name
+  end
+
+  def test_self_host_to_parser
+    assert_equal "WhoisIt", @klass.host_to_parser("whois.it")
+    assert_equal "WhoisNicIt", @klass.host_to_parser("whois.nic.it")
+    assert_equal "WhoisDomainRegistryNl", @klass.host_to_parser("whois.domain-registry.nl")
+  end
+
 end

data/test/answer_test.rb

@@ -85,34 +85,70 @@ class AnswerTest < Test::Unit::TestCase
     assert_instance_of Whois::Answer::Parser, answer.parser
   end
 
+
+  class Whois::Answer::Parser::WhoisParserFake < Whois::Answer::Parser::Base
+    property_supported :status do
+      nil
+    end
+    property_supported :created_on do
+      Date.parse("2010-10-20")
+    end
+    property_not_supported :updated_on
+    # property_not_defined :expires_on
+  end
+
+  def test_property_supported?
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
+    assert  answer.property_supported?(:status)
+    assert  answer.property_supported?(:created_on)
+    assert !answer.property_supported?(:updated_on)
+    assert !answer.property_supported?(:expires_on)
+  end
+
   def test_properties
-    answer = @klass.new(nil, [])
-    answer.parser.expects(:property_supported?).with(:domain).returns(true)
-    answer.parser.expects(:property_supported?).with(:domain_id).returns(true)
-    answer.parser.expects(:property_supported?).with(Not(any_of(:domain, :domain_id))).at_least(1).returns(false)
-    answer.parser.expects(:domain).returns("foo.com")
-    answer.parser.expects(:domain_id).returns(27)
-    
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
     properties = answer.properties
-    assert_equal 2, properties.keys.length
-    assert_equal "foo.com", properties[:domain]
-    assert_equal 27, properties[:domain_id]
+
+    assert_equal Whois::Answer::Parser.properties.size, properties.keys.size
+    assert_equal nil,                       properties[:status]
+    assert_equal Date.parse("2010-10-20"),  properties[:created_on]
+    assert_equal nil,                       properties[:updated_on]
+    assert_equal nil,                       properties[:expires_on]
   end
 
-  def test_property_supported?
-    answer = @klass.new(nil, [])
-    answer.parser.expects(:property_supported?).with(:disclaimer).returns(:value)
-    assert_equal :value, answer.property_supported?(:disclaimer)
+  def test_should_return_value_with_supported_property_getter
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
+    assert_equal Date.parse("2010-10-20"), answer.created_on
   end
 
+  def test_should_return_nil_with_not_supported_property_getter
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
+    assert_equal nil, answer.updated_on
+  end
 
-  Whois::Answer::Parser.properties.each do |method|
-    define_method "test_should_delegate_#{method}_to_parser" do
-      answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
-      parser = answer.parser
-      parser.expects(method).returns(:value)
-      assert_equal :value, answer.send(method)
-    end
+  def test_should_return_nil_with_not_implemented_property
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
+    assert_equal nil, answer.expires_on
+  end
+
+  def test_should_return_false_with_supported_property_getter_and_not_value
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
+    assert !answer.status?
+  end
+
+  def test_should_return_true_with_supported_property_getter_and_value
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
+    assert  answer.created_on?
+  end
+
+  def test_should_return_false_with_not_supported_property_exists
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
+    assert !answer.updated_on?
+  end
+
+  def test_should_return_false_with_not_implemented_property_exists
+    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
+    assert !answer.expires_on?
   end
 
 end

data/test/client_test.rb

@@ -26,8 +26,11 @@ class ClientTest < Test::Unit::TestCase
 
   def test_query_should_cast_qstring_to_string
     server = Object.new
-    server.expects(:query).with("google.com")
-    Whois::Server.expects(:guess).with("google.com").returns(server)
+    # I can't use the String because Array#to_s behaves differentl
+    # on Ruby 1.8.7 and Ruby 1.9.1
+    # http://redmine.ruby-lang.org/issues/show/2617
+    server.expects(:query).with(instance_of(String))
+    Whois::Server.expects(:guess).with(instance_of(String)).returns(server)
     @client.query(["google", ".", "com"])
   end
 

data/test/errors_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class WebInterfaceErrorTest < Test::Unit::TestCase
+
+  def setup
+    @klass = Whois::WebInterfaceError
+  end
+
+  def test_url
+    assert_raise(ArgumentError) { @klass.new }
+  end
+
+  def test_url
+    error = @klass.new("http://example.com")
+    assert_equal "http://example.com", error.url
+  end
+
+  def test_message
+    error = @klass.new("http://example.com")
+    assert_match %r{http://example.com}, error.message
+  end
+
+end

data/test/list_tld

@@ -29,25 +29,25 @@ edu;whois.educause.edu;google.edu;u34jedzcq.edu
 gov;whois.nic.gov;gsa.gov;u34jedzcq.gov
 int;whois.iana.org;nato.int;u34jedzcq.int
 mil;;;
-#Whois::Server.define :tld, ".e164.arpa", "whois.ripe.net"
-#Whois::Server.define :tld, ".in-addr.arpa", nil
+#.e164.arpa;;;
+#.in-addr.arpa;;;
 arpa;whois.iana.org;ip6.arpa;u34jedzcq.arpa
 aero;whois.aero;srilankan.aero;u34jedzcq.aero
 asia;whois.nic.asia;srilankan.aero;u34jedzcq.asia
-#Whois::Server.define :tld, ".biz", "whois.nic.biz"
-#Whois::Server.define :tld, ".cat", "whois.cat", {:adapter=>Whois::Server::Adapters::Formatted, :format => "-C US-ASCII ace %s"}
-#Whois::Server.define :tld, ".coop", "whois.nic.coop"
+biz;whois.biz;google.biz;u34jedzcq.biz
+cat;whois.cat;gencat.cat;u34jedzcq.cat
+coop;whois.nic.coop;calgary.coop;u34jedzcq.coop
 info;whois.afilias.info;google.info;u34jedzcq.info
-#Whois::Server.define :tld, ".jobs", "jobswhois.verisign-grs.com", {:adapter=>Whois::Server::Adapters::Verisign}
-#Whois::Server.define :tld, ".mobi", "whois.dotmobiregistry.net"
-#Whois::Server.define :tld, ".museum", "whois.museum"
+jobs;jobswhois.verisign-grs.com;goto.jobs;u34jedzcq.jobs
+mobi;whois.dotmobiregistry.net;google.mobi;u34jedzcq.mobi
+museum;whois.museum;musedoma.museum;u34jedzcq.museum
 name;whois.nicc.name;carletti.name;u34jedzcq.name
-#Whois::Server.define :tld, ".pro", "whois.registrypro.pro"
-#Whois::Server.define :tld, ".tel", "whois.nic.tel"
-#Whois::Server.define :tld, ".travel", "whois.nic.travel"
-#Whois::Server.define :tld, ".ac", "whois.nic.ac"
+pro;whois.registrypro.pro;registry.pro;u34jedzcq.pro
+tel;whois.nic.tel;weppos.tel;u34jedzcq.tel
+travel;whois.nic.travel;travel.travel;u34jedzcq.travel
+ac;whois.nic.ac;google.ac;u34jedzcq.ac
 ad;;;
-#Whois::Server.define :tld, ".ae", "whois.aeda.net.ae"
+ae;whois.aeda.net.ae;google.ae;u34jedzcq.ae
 #Whois::Server.define :tld, ".af", "whois.nic.af"
 #Whois::Server.define :tld, ".ag", "whois.nic.ag"
 #Whois::Server.define :tld, ".ai", "whois.ai"
@@ -58,24 +58,24 @@ ao;;;
 aq;;;
 ar;;;
 #Whois::Server.define :tld, ".as", "whois.nic.as"
-#Whois::Server.define :tld, ".at", "whois.nic.at"
+at;whois.nic.at;google.at;u34jedzcq.at
 #Whois::Server.define :tld, ".au", "whois.ausregistry.net.au"
 aw;;;
 ax;;;
 az;;;
 ba;;;
 bb;;;
-#Whois::Server.define :tld, ".bd", "www.whois.com.bd"
-#Whois::Server.define :tld, ".be", "whois.dns.be"
+bd;;;
+be;whois.dns.be;google.be;u34jedzcq.be
 bf;;;
-#Whois::Server.define :tld, ".bg", "whois.register.bg"
+bg;whois.register.bg;google.bg;u34jedzcq.bg
 bh;;;
 bi;;;
 #Whois::Server.define :tld, ".bj", "whois.nic.bj"
 bm;;;
 bn;;;
 bo;;;
-#Whois::Server.define :tld, ".br", "whois.nic.br"
+br;whois.registro.br;registro.br;u34jedzcq.br
 bs;;;
 bt;;;
 bv;;;
@@ -83,12 +83,12 @@ by;;;
 bw;;;
 bz;whois.afilias-grs.info;google.bz;u34jedzcq.bz
 #Whois::Server.define :tld, ".co.ca", "whois.co.ca"
-#Whois::Server.define :tld, ".ca", "whois.cira.ca"
-#Whois::Server.define :tld, ".cc", "whois.nic.cc", {:adapter=>Whois::Server::Adapters::Verisign}
-#Whois::Server.define :tld, ".cd", "whois.nic.cd"
+ca;whois.cira.ca;google.ca;u34jedzcq.ca
+cc;whois.nic.cc;google.cc;u34jedzcq.cc
+cd;whois.nic.cd;google.cd;u34jedzcq.cd
 cf;;;
 cg;;;
-#Whois::Server.define :tld, ".ch", "whois.nic.ch"
+ch;whois.nic.ch;google.ch;u34jedzcq.ch
 #Whois::Server.define :tld, ".ci", "www.nic.ci"
 #Whois::Server.define :tld, ".ck", "whois.nic.ck"
 #Whois::Server.define :tld, ".cl", "whois.nic.cl"
@@ -105,7 +105,7 @@ cy;;;
 #Whois::Server.define :tld, ".cz", "whois.nic.cz"
 de;whois.denic.de;google.de;u34jedzcq.de
 #Whois::Server.define :tld, ".dj", "whois.domain.dj"
-#Whois::Server.define :tld, ".dk", "whois.dk-hostmaster.dk"
+dk;whois.dk-hostmaster.dk;google.dk;u34jedzcq.dk
 #Whois::Server.define :tld, ".dm", "whois.nic.dm"
 do;;;
 dz;;;
@@ -115,23 +115,23 @@ eg;;;
 er;;;
 es;;;
 et;;;
-#Whois::Server.define :tld, ".eu", "whois.eu"
+eu;whois.eu;google.eu;u34jedzcq.eu
 #Whois::Server.define :tld, ".fi", "whois.ficora.fi"
 #Whois::Server.define :tld, ".fj", "whois.usp.ac.fj"
 fk;;;
 fm;;;
-#Whois::Server.define :tld, ".fo", "whois.ripe.net"
+fo;whois.ripe.net;nic.fo;u34jedzcq.fo
 fr;whois.nic.fr;google.fr;u34jedzcq.fr
 ga;;;
 gb;;;
-#Whois::Server.define :tld, ".gd", "whois.adamsnames.tc"
+gd;whois.adamsnames.tc;google.gd;u34jedzcq.gd
 ge;;;
-#Whois::Server.define :tld, ".gf", "whois.nplus.gf"
+gf;;;
 #Whois::Server.define :tld, ".gg", "whois.gg"
 gh;;;
 gi;whois.afilias-grs.info;sapphire.gi;u34jedzcq.gi
-#Whois::Server.define :tld, ".gl", "whois.nic.gl"
-#Whois::Server.define :tld, ".gm", "whois.ripe.net"
+gl;whois.nic.gl;google.gl;u34jedzcq.gl
+gm;whois.ripe.net;nic.gm;u34jedzcq.gm
 gn;;;
 #Whois::Server.define :tld, ".gp", "whois.nic.gp"
 gq;;;
@@ -147,15 +147,15 @@ hn;whois.afilias-grs.info;google.hn;u34jedzcq.hn
 hr;;;
 #Whois::Server.define :tld, ".ht", "whois.nic.ht"
 hu;whois.nic.hu;google.hu;u34jedzcq.hu
-#Whois::Server.define :tld, ".id", "whois.idnic.net.id"
+#Whois::Server.define :tld, ".id", "whois.pandi.or.id"
 ie;whois.domainregistry.ie;google.ie;u34jedzcq.ie
 #Whois::Server.define :tld, ".il", "whois.isoc.org.il"
-#Whois::Server.define :tld, ".im", "whois.nic.im"
+im;whois.nic.im;google.im;u34jedzcq.im
 #Whois::Server.define :tld, ".in", "whois.registry.in"
-#Whois::Server.define :tld, ".io", "whois.nic.io"
+io;whois.nic.io;drop.io;u34jedzcq.io
 iq;;;
 #Whois::Server.define :tld, ".ir", "whois.nic.ir"
-#Whois::Server.define :tld, ".is", "whois.isnet.is"
+is;whois.isnic.is;google.is;u34jedzcq.is
 it;whois.nic.it;google.it;u34jedzcq.it
 #Whois::Server.define :tld, ".je", "whois.je"
 jm;;;
@@ -164,7 +164,7 @@ jo;;;
 #Whois::Server.define :tld, ".ke", "whois.kenic.or.ke"
 #Whois::Server.define :tld, ".kg", "whois.domain.kg"
 kh;;;
-#Whois::Server.define :tld, ".ki", nil, {:web=>"http://www.ki/dns/", :adapter=>Whois::Server::Adapters::Web}
+ki;whois.nic.mu;google.ki;u34jedzcq.ki
 km;;;
 kn;;;
 #Whois::Server.define :tld, ".kp", "whois.kcce.kp"
@@ -175,7 +175,6 @@ ky;;;
 #Whois::Server.define :tld, ".la", "whois.nic.la"
 lb;;;
 lc;whois.afilias-grs.info;nic.lc;u34jedzcq.lc
-#Whois::Server.define :tld, ".lc", "whois.afilias-grs.info"
 #Whois::Server.define :tld, ".li", "whois.nic.li"
 #Whois::Server.define :tld, ".lk", "whois.nic.lk"
 lr;;;
@@ -183,28 +182,28 @@ ls;;;
 #Whois::Server.define :tld, ".lt", "whois.domreg.lt"
 #Whois::Server.define :tld, ".lu", "whois.dns.lu"
 #Whois::Server.define :tld, ".lv", "whois.nic.lv"
-#Whois::Server.define :tld, ".ly", "whois.nic.ly"
+ly;whois.nic.ly;google.ly;u34jedzcq.ly
 #Whois::Server.define :tld, ".ma", "whois.iam.net.ma"
-#Whois::Server.define :tld, ".mc", "whois.ripe.net"
+mc;whois.ripe.net;nic.mc;u34jedzcq.mc
 #Whois::Server.define :tld, ".md", "whois.nic.md"
-#Whois::Server.define :tld, ".me", "whois.meregistry.net"
+me;whois.meregistry.net;google.me;u34jedzcq.me
 #Whois::Server.define :tld, ".mg", "whois.nic.mg"
 mh;;;
 mk;;;
 ml;;;
-#Whois::Server.define :tld, ".mm", "whois.nic.mm"
+mm;;;
 mn;whois.afilias-grs.info;google.mn;u34jedzcq.mn
 mo;;;
-#Whois::Server.define :tld, ".mp", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".mq", "whois.nic.mq"
+mp;;;
+mq;;;
 mr;;;
 #Whois::Server.define :tld, ".ms", "whois.nic.ms"
 mt;;;
-#Whois::Server.define :tld, ".mu", "whois.nic.mu"
+mu;whois.nic.mu;google.mu;u34jedzcq.mu
 mv;;;
 mw;;;
 #Whois::Server.define :tld, ".mx", "whois.nic.mx"
-#Whois::Server.define :tld, ".my", "whois.mynic.net.my"
+#Whois::Server.define :tld, ".my", "whois.domainregistry.my"
 mz;;;
 #Whois::Server.define :tld, ".na", "whois.na-nic.com.na"
 #Whois::Server.define :tld, ".nc", "whois.cctld.nc"
@@ -212,11 +211,11 @@ ne;;;
 #Whois::Server.define :tld, ".nf", "whois.nic.nf"
 #Whois::Server.define :tld, ".ng", "whois.register.net.ng"
 ni;;;
-#Whois::Server.define :tld, ".nl", "whois.domain-registry.nl"
-#Whois::Server.define :tld, ".no", "whois.norid.no"
+nl;whois.domain-registry.nl;google.nl;u34jedzcq.nl
+no;whois.norid.no;google.no;u34jedzcq.no
 np;;;
 nr;;;
-#Whois::Server.define :tld, ".nu", "whois.nic.nu"
+nu;whois.nic.nu;google.nu;u34jedzcq.nu
 #Whois::Server.define :tld, ".nz", "whois.srs.net.nz"
 om;;;
 pa;;;
@@ -232,18 +231,17 @@ pn;;;
 #Whois::Server.define :tld, ".pr", "whois.nic.pr"
 ps;;;
 #Whois::Server.define :tld, ".pt", "whois.dns.pt"
-#Whois::Server.define :tld, ".pw", "whois.nic.pw"
+pw;;;
 py;;;
 qa;;;
 re;whois.nic.fr;nic.re;u34jedzcq.re
-#Whois::Server.define :tld, ".ro", "whois.rotld.ro"
+ro;whois.rotld.ro;google.ro;u34jedzcq.ro
 rs;;;
 #Whois::Server.define :tld, ".edu.ru", "whois.informika.ru"
-#Whois::Server.define :tld, ".ru", "whois.ripn.net"
+ru;whois.ripn.net;google.ru;u34jedzcq.ru
 rw;;;
 #Whois::Server.define :tld, ".sa", "saudinic.net.sa"
-#Whois::Server.define :tld, ".sb", "whois.nic.net.sb"
-#Whois::Server.define :tld, ".sc", "whois.afilias-grs.info"
+#Whois::Server.define :tld, ".sb", "whois.coccaregistry.net"
 sc;whois.afilias-grs.info;google.sc;u34jedzcq.sc
 sd;;;
 #Whois::Server.define :tld, ".se", "whois.nic-se.se"
@@ -253,28 +251,28 @@ sd;;;
 sj;;;
 #Whois::Server.define :tld, ".sk", "whois.sk-nic.sk"
 #Whois::Server.define :tld, ".sl", "whois.nic.sl"
-#Whois::Server.define :tld, ".sm", "whois.ripe.net"
+sm;whois.ripe.net;google.sm;u34jedzcq.sm
 #Whois::Server.define :tld, ".sn", "whois.nic.sn"
-#Whois::Server.define :tld, ".so", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".sr", "whois.register.sr"
+so;;;
+sr;;;
 #Whois::Server.define :tld, ".st", "whois.nic.st"
-#Whois::Server.define :tld, ".su", "whois.ripn.net"
+su;whois.ripn.net;google.su;u34jedzcq.su
 sv;;;
 sy;;;
 sz;;;
-#Whois::Server.define :tld, ".tc", "whois.adamsnames.tc"
+tc;whois.adamsnames.tc;google.tc;u34jedzcq.tc
 td;;;
 #Whois::Server.define :tld, ".tf", "whois.nic.tf"
 tg;;;
 #Whois::Server.define :tld, ".th", "whois.thnic.net"
-#Whois::Server.define :tld, ".tj", "whois.nic.tj"
+tj;;;
 #Whois::Server.define :tld, ".tk", "whois.dot.tk"
-#Whois::Server.define :tld, ".tl", "whois.nic.tl"
+tl;whois.nic.tl;thinkcode.tl;u34jedzcq.tl
 #Whois::Server.define :tld, ".tm", "whois.nic.tm"
 tn;;;
 #Whois::Server.define :tld, ".to", "whois.tonic.to"
-#Whois::Server.define :tld, ".tp", "whois.nic.tp"
-#Whois::Server.define :tld, ".tr", "whois.metu.edu.tr"
+tp;;;
+#Whois::Server.define :tld, ".tr", "whois.nic.tr"
 tt;;;
 tv;whois.nic.tv;thinkcode.tv;u34jedzcq.tv
 #Whois::Server.define :tld, ".tw", "whois.twnic.net"
@@ -282,33 +280,33 @@ tz;;;
 #Whois::Server.define :tld, ".ua", "whois.net.ua"
 #Whois::Server.define :tld, ".ug", "www.registry.co.ug"
 #Whois::Server.define :tld, ".ac.uk", "whois.ja.net"
-#Whois::Server.define :tld, ".bl.uk", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".british-library.uk", nil, {:adapter=>Whois::Server::Adapters::None}
+.bl.uk;;;
+.british-library.uk;;;
 #Whois::Server.define :tld, ".gov.uk", "whois.ja.net"
-#Whois::Server.define :tld, ".icnet.uk", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".jet.uk", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".mod.uk", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".nhs.uk", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".nls.uk", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".parliament.uk", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".police.uk", nil, {:adapter=>Whois::Server::Adapters::None}
-#Whois::Server.define :tld, ".uk", "whois.nic.uk"
+.icnet.uk;;;
+.jet.uk;;;
+.mod.uk;;;
+.nhs.uk;;;
+.nls.uk;;;
+.parliament.uk;;;
+.police.uk;;;
+uk;whois.nic.uk;google.co.uk;u34jedzcq.co.uk
 #Whois::Server.define :tld, ".fed.us", "whois.nic.gov"
-#Whois::Server.define :tld, ".us", "whois.nic.us"
+us;whois.nic.us;google.us;u34jedzcq.us
 #Whois::Server.define :tld, ".com.uy", nil, {:web=>"https://nic.anteldata.com.uy/dns/", :adapter=>Whois::Server::Adapters::Web}
 #Whois::Server.define :tld, ".uy", "whois.nic.org.uy"
 #Whois::Server.define :tld, ".uz", "whois.cctld.uz"
-#Whois::Server.define :tld, ".va", "whois.ripe.net"
+va;whois.ripe.net;vatican.va;u34jedzcq.va
 vc;whois.afilias-grs.info;google.vc;u34jedzcq.vc
 #Whois::Server.define :tld, ".ve", "whois.nic.ve"
-#Whois::Server.define :tld, ".vg", "whois.adamsnames.tc"
+vg;whois.adamsnames.tc;google.vg;u34jedzcq.vg
 vi;;;
 vn;;;
 vu;;;
-#Whois::Server.define :tld, ".wf", "whois.nic.wf"
-#Whois::Server.define :tld, ".ws", "whois.samoanic.ws"
+wf;whois.nic.fr;nic.wf;u34jedzcq.wf
+ws;whois.samoanic.ws;google.ws;u34jedzcq.ws
 ye;;;
-#Whois::Server.define :tld, ".yt", "whois.nic.yt"
+yt;whois.nic.fr;nic.yt;u34jedzcq.yt
 yu;;;
 #Whois::Server.define :tld, ".ac.za", "whois.ac.za"
 #Whois::Server.define :tld, ".co.za", "whois.coza.net.za"