whois 0.5.2 → 0.5.3

data/CHANGELOG.rdoc

@@ -1,6 +1,13 @@
 = Changelog
 
 
+== Release 0.5.3
+
+FIXED: self.valid_ipv6?(addr) references valid_v4? instead of valid_ipv4? (closes #300)
+
+FIXED: In some rare circumstances the server guessing fails to return the right server but returns an other server instead (closes #260).
+
+
 == Release 0.5.2
 
 * ADDED: Whois::Client.new now accepts a block and yields self.

data/lib/whois/server.rb

@@ -175,7 +175,7 @@ module Whois
 
       def self.find_for_tld(qstring)
         definitions(:tld).each do |definition|
-          return factory(:tld, *definition) if /#{definition.first}$/ =~ qstring
+          return factory(:tld, *definition) if /#{Regexp.escape(definition.first)}$/ =~ qstring
         end
         nil
       end
@@ -193,9 +193,9 @@ module Whois
         return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*)?\Z/ =~ addr
         return true if /\A::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*)?\Z/ =~ addr
         # IPv6 (IPv4 compat)
-        return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:/ =~ addr && valid_v4?($')
-        return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:)?/ =~ addr && valid_v4?($')
-        return true if /\A::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:)?/ =~ addr && valid_v4?($')
+        return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:/ =~ addr && valid_ipv4?($')
+        return true if /\A[\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:)?/ =~ addr && valid_ipv4?($')
+        return true if /\A::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*:)?/ =~ addr && valid_ipv4?($')
         false
       end
 

data/lib/whois/version.rb

@@ -19,7 +19,7 @@ module Whois
   module Version
     MAJOR = 0
     MINOR = 5
-    TINY  = 2
+    TINY  = 3
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/server_test.rb

@@ -1,57 +1,99 @@
 require 'test_helper'
 
 class ServerTest < Test::Unit::TestCase
-  include Whois
+
+  def setup
+    Whois::Server.class_eval { class_variable_set("@@definitions", { :tld => [], :ipv4 =>[], :ipv6 => [] }) }  
+  end
+
 
   def test_guess_should_recognize_email
-    Server.expects(:find_for_email).with("email@example.org").returns(true)
-    assert Server.guess("email@example.org")
+    Whois::Server.expects(:find_for_email).with("email@example.org").returns(true)
+    assert Whois::Server.guess("email@example.org")
   end
 
   def test_guess_should_recognize_tld
-    Server.expects(:find_for_tld).with("google.com").returns(true)
-    assert Server.guess("google.com")
+    Whois::Server.expects(:find_for_tld).with("google.com").returns(true)
+    assert Whois::Server.guess("google.com")
+  end
+
+  def test_guess_should_recognize_ipv4
+    Whois::Server.expects(:find_for_ipv4).with("192.168.1.1").returns(true)
+    assert Whois::Server.guess("192.168.1.1")
+  end
+
+  def test_guess_should_recognize_ipv6
+    Whois::Server.expects(:find_for_ipv6).with("2001:0db8:85a3:0000:0000:8a2e:0370:7334").returns(true)
+    assert Whois::Server.guess("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+  end
+
+  def test_guess_should_recognize_ipv6_with_zeros_group
+    Whois::Server.expects(:find_for_ipv6).with("2002::1").returns(true)
+    assert Whois::Server.guess("2002::1")
   end
 
   def test_guess_should_raise_servernotfound_with_unrecognized_query
-    assert_raise(ServerNotFound){ Server.guess("xyz") }
+    assert_raise(Whois::ServerNotFound){ Whois::Server.guess("xyz") }
+  end
+
+
+  def test_find_for_tld_should_not_consider_dot_as_regexp_instruction
+    Whois::Server.define(:tld, ".no.com", "whois.no.com")
+    Whois::Server.define(:tld, ".com", "whois.com")
+    assert_equal "whois.com", Whois::Server.guess("antoniocangiano.com").host
+  end
+
+  def test_find_for_ipv6_should_factory_ipv6_with_ipv4_compatibility
+    Whois::Server.define(:ipv6, "::192.168.1.1", "whois.foo")
+    Whois::Server.expects(:factory).with(:ipv6, any_parameters).returns(true)
+    assert Whois::Server.guess("::192.168.1.1")
   end
 
 
   def test_definitions
-    assert_instance_of Hash, Server.definitions
+    assert_instance_of Hash, Whois::Server.definitions
   end
 
   def test_definitions_with_key
-    assert_equal nil, Server.definitions(:foo)
-    Server.define(:foo, ".foo", "whois.foo")
-    assert_equal [[".foo", "whois.foo", {}]], Server.definitions(:foo)
+    assert_equal nil, Whois::Server.definitions(:foo)
+    Whois::Server.define(:foo, ".foo", "whois.foo")
+    assert_equal [[".foo", "whois.foo", {}]], Whois::Server.definitions(:foo)
   end
 
 
   def test_define_tld
-    Server.define(:tld, ".foo", "whois.foo")
-    assert_equal [".foo", "whois.foo", {}], Server.definitions[:tld].last
+    Whois::Server.define(:tld, ".foo", "whois.foo")
+    assert_equal [".foo", "whois.foo", {}], Whois::Server.definitions[:tld].last
   end
 
   def test_define_tld_with_options
-    Server.define(:tld, ".foo", "whois.foo", :foo => "bar")
-    assert_equal [".foo", "whois.foo", { :foo => "bar" }], Server.definitions[:tld].last
+    Whois::Server.define(:tld, ".foo", "whois.foo", :foo => "bar")
+    assert_equal [".foo", "whois.foo", { :foo => "bar" }], Whois::Server.definitions[:tld].last
+  end
+
+  def test_define_ipv4
+    Whois::Server.define(:ipv4, ".foo", "whois.foo")
+    assert_equal [".foo", "whois.foo", {}], Whois::Server.definitions[:ipv4].last
+  end
+
+  def test_define_ipv4_with_options
+    Whois::Server.define(:ipv4, ".foo", "whois.foo", :foo => "bar")
+    assert_equal [".foo", "whois.foo", { :foo => "bar" }], Whois::Server.definitions[:ipv4].last
   end
 
 
   def test_factory
-    server = Server.factory(:tld, ".foo", "whois.foo")
-    assert_instance_of Server::Adapters::Standard, server
+    server = Whois::Server.factory(:tld, ".foo", "whois.foo")
+    assert_instance_of Whois::Server::Adapters::Standard, server
   end
 
   def test_factory_with_adapter
-    server = Server.factory(:tld, ".foo", "whois.foo", :adapter => Server::Adapters::None)
-    assert_instance_of Server::Adapters::None, server
+    server = Whois::Server.factory(:tld, ".foo", "whois.foo", :adapter => Whois::Server::Adapters::None)
+    assert_instance_of Whois::Server::Adapters::None, server
   end
 
   def test_factory_with_adapter_should_delete_adapter_option
-    server = Server.factory(:tld, ".foo", "whois.foo", :adapter => Server::Adapters::None, :foo => "bar")
+    server = Whois::Server.factory(:tld, ".foo", "whois.foo", :adapter => Whois::Server::Adapters::None, :foo => "bar")
     assert_equal server.options, { :foo => "bar" } 
   end
 

data/whois.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{whois}
-  s.version = "0.5.2"
+  s.version = "0.5.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Simone Carletti"]
-  s.date = %q{2009-08-20}
+  s.date = %q{2009-09-18}
   s.default_executable = %q{ruby-whois}
   s.description = %q{    Whois is an intelligent WHOIS client written in pure Ruby.     It enables you to query registry data for ipv4, ipv6 and top level domains.
 }
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Whois", "--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{whois}
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.4}
   s.summary = %q{An intelligent pure Ruby WHOIS client.}
   s.test_files = ["test/adapters/afilias_test.rb", "test/adapters/none_test.rb", "test/adapters/not_implemented_test.rb", "test/adapters/pir_test.rb", "test/adapters/standard_test.rb", "test/adapters/verisign_test.rb", "test/adapters/web_test.rb", "test/client_test.rb", "test/deprecated_test.rb", "test/server_test.rb", "test/test_helper.rb", "test/whois_test.rb"]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: whois
 version: !ruby/object:Gem::Version 
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors: 
 - Simone Carletti
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-20 00:00:00 +02:00
+date: 2009-09-18 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -161,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: whois
-rubygems_version: 1.3.5
+rubygems_version: 1.3.4
 signing_key: 
 specification_version: 3
 summary: An intelligent pure Ruby WHOIS client.