whois 1.2.2 → 1.3.0

data/CHANGELOG.rdoc

@@ -1,5 +1,28 @@
 = Changelog
 
+== Release 1.3.0
+
+* ADDED: Ability to query IANA for TLD WHOIS information. [aadlani]
+
+    Whois.query(".com")
+    # => IANA WHOIS response for .com TLD
+
+    Whois.query(".invalid")
+    # => IANA WHOIS response for unassigned TLD
+
+
+* ADDED: Ability to compare two Server adapters for equality.
+
+    Whois::Server.factory(:ipv4, "192.168.1.0/10", "whois.foo") == Whois::Server.factory(:ipv4, "192.168.1.0/10", "whois.foo")
+    # => true
+
+    Whois::Server.factory(:ipv4, "192.168.1.0", "whois.foo") == Whois::Server.factory(:ipv4, "192.168.1.0/10", "whois.foo")
+    # => false
+
+* CHANGED: Renamed Scanners::VerisignScanner to Scanners::Verisign.
+
+* CHANGED: Excluded test folder from the packaged .gem file to reduce the size of the final packaged library.
+
 
 == Release 1.2.2
 

data/README.rdoc

@@ -15,7 +15,7 @@ An extensive test suite is available to verify the library correctness but you m
 * Intelligent Ruby client
 * Flexible and extensible configuration with support for user-defined servers
 * Powerful whois response parser
-* Support for IPv6, IPv4 and top level domain whois queries
+* Support for IPv6, IPv4, TLD and domain WHOIS queries
 * Object oriented design
 * Compatible with Ruby 1.8.6 and newer, including Ruby 1.9
 
@@ -48,21 +48,26 @@ Note. This section covers only the essentials for getting started with the Whois
 
 === Querying the Server
 
-Whois provides the ability to get WHOIS information for hostnames, IPv4 and IPv6 addresses. The client is smart enough to guess the best WHOIS server according to given query, send the request and return the response.
+Whois provides the ability to get WHOIS information for TLD, domain names, IPv4 and IPv6 addresses. The client is smart enough to guess the best WHOIS server according to given query, send the request and return the response.
 
 Check out the following examples:
 
-  # Domain Whois
+  # Domain WHOIS
   w = Whois::Client.new
   w.query("google.com")
   # => #<Whois::Answer>
 
-  # IPv4 Whois
+  # TLD WHOIS
+  w = Whois::Client.new
+  w.query(".com")
+  # => #<Whois::Answer>
+
+  # IPv4 WHOIS
   w = Whois::Client.new
   w.query("74.125.67.100")
   # => #<Whois::Answer>
 
-  # IPv6 Whois
+  # IPv6 WHOIS
   w = Whois::Client.new
   w.query("2001:db8::1428:57ab")
   # => #<Whois::Answer>
@@ -71,6 +76,7 @@ The query method is stateless. For this reason, you can safely re-use the same c
 
   w = Whois::Client.new
   w.query("google.com")
+  w.query(".com")
   w.query("74.125.67.100")
   w.query("2001:db8::1428:57ab")
   w.query("google.it")
@@ -80,6 +86,17 @@ If you just need a WHOIS response and you don't care about a full control of the
   Whois.whois("google.com")
   # => #<Whois::Answer>
 
+Did I mention you can even use blocks?
+
+  Whois::Client.new do |w|
+    w.query("google.com")
+    w.query(".com")
+    w.query("74.125.67.100")
+    w.query("2001:db8::1428:57ab")
+    w.query("google.it")
+  end
+
+
 === Consuming the Answer
 
 As of release 0.8, a WHOIS query no longer returns a simple string. Instead, you get a full <tt>Whois::Answer</tt> instance and this is just the beginning of the story.
@@ -166,9 +183,9 @@ Bug reports and Feature suggestions {are welcomed}[http://github.com/weppos/whoi
 
 == More
 
-* {Homepage}[http://ruby-whois.org]
+* {Homepage}[http://www.ruby-whois.org]
 * {GitHub Repository}[http://github.com/weppos/whois]
-* {API Documentation}[http://whois.rubyforge.org]
+* {API Documentation}[http://www.ruby-whois.org/api/]
 * {Discussion Group}[http://groups.google.com/group/ruby-whois]
 
 

data/lib/core_ext.rb

@@ -2,7 +2,6 @@ unless :to_proc.respond_to?(:to_proc)
   class Symbol
     # Turns the symbol into a simple proc, 
     # which is especially useful for enumerations.
-    # Extracted from ActiveSupport.
     #
     # Examples
     #
@@ -12,6 +11,8 @@ unless :to_proc.respond_to?(:to_proc)
     #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
     #   people.select(&:manager?).collect(&:salary)
     #
+    # Extracted from ActiveSupport.
+    #
     # Returns a Proc which incapsulates the method business logic.
     def to_proc
       Proc.new { |*args| args.shift.__send__(self, *args) }
@@ -27,9 +28,9 @@ class DateTime
   # See http://github.com/weppos/whois/issues#issue/24
   unless method_defined?(:to_time)
     # Attempts to convert self to a Ruby Time object; returns self if out of range of Ruby Time class
-    # Extracted from ActiveSupport.
-    #
     # If self has an offset other than 0, self will just be returned unaltered, since there's no clean way to map it to a Time.
+    #
+    # Extracted from ActiveSupport.
     def to_time
       self.offset == 0 ? ::Time.utc(year, month, day, hour, min, sec) : self
     end

data/lib/whois/answer/contact.rb

@@ -58,4 +58,4 @@ module Whois
     end
 
   end
-end
+end

data/lib/whois/answer/nameserver.rb

@@ -0,0 +1,41 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/super_struct'
+
+
+module Whois
+  class Answer
+
+    #
+    # = Nameserver
+    #
+    # Holds the details of the Name Servers extracted from the WHOIS answer.
+    #
+    # A Nameserver is composed by the following attributes:
+    #
+    # * <tt>:name</tt>:
+    # * <tt>:ipv4</tt>:
+    # * <tt>:ipv6</tt>:
+    #
+    # Be aware that every WHOIS server can return a different number of details
+    # or no details at all.
+    #
+    class Nameserver < SuperStruct.new(:name, :ipv4, :ipv6)
+    end
+
+  end
+end

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

@@ -17,6 +17,7 @@
 require 'time'
 require 'whois/answer/contact'
 require 'whois/answer/registrar'
+require 'whois/answer/nameserver'
 require 'whois/answer/parser/ast'
 
 

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

@@ -95,10 +95,10 @@ module Whois
         protected
 
           def parse
-            Scanners::VerisignScanner.new(content_for_scanner).parse
+            Scanners::Verisign.new(content_for_scanner).parse
           end
 
-          # In case of "Response SPAM", the responde include more than one item
+          # In case of "SPAM Response", the response contains more than one item
           # for the same value and the value becomes an Array.
           def last_useful_item(values)
             values.is_a?(Array) ? values.last : values

data/lib/whois/answer/parser/scanners/iana.rb

@@ -0,0 +1,145 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+# 
+#++
+
+
+module Whois
+  class Answer
+    class Parser
+      module Scanners
+        
+        class Iana
+          
+          def initialize(content)
+            @input = StringScanner.new(content)
+          end
+          
+          def parse
+            @ast = {}
+            while !@input.eos?
+              trim_newline  ||
+              parse_content
+            end
+            @ast
+          end
+          
+          private
+          
+            def parse_content
+                parse_disclaimer  ||
+                parse_section     ||
+                error("Unexpected token")
+            end
+            
+            def trim_newline
+              @input.scan(/\n/)
+            end
+            
+            def parse_section
+              if @input.scan(/^(.+):(.+)\n/)
+                                
+                # Adapt the section's name depending on the first line
+                section = case @input[1].strip
+                when 'contact'
+                  @input[2].strip # use the contact type name as identifier
+                when 'created', 'changed'
+                  'dates'
+                when 'nserver'
+                  'nameservers'
+                else
+                  @input[1].strip # Default name is the first label found
+                end
+                
+                content = parse_section_pairs
+                @input.match?(/\n+/) || error("Unexpected end of section")
+                @ast[section] = content
+              else
+                false
+              end
+            end
+            
+            def parse_section_pairs
+              # Sets by default the firsts values found in the section parsing bellow
+              section_name, section_value = @input[1].strip, @input[2].strip
+              #contents = {section_name =>  section_value} 
+              
+              contents = {}
+              
+              while content = parse_section_pair
+                contents.merge!(content)
+              end
+              
+              if contents.has_key? section_name
+                contents[section_name].insert(0, "#{section_value}\n") 
+              else
+                contents[section_name] = section_value
+              end
+              
+              if !contents.empty?
+                contents
+              else
+                false
+              end
+            end
+            
+            
+            def parse_section_pair
+              if @input.scan(/^(.+):\s*(.+)\n/)
+                key     =  @input[1].strip
+                values  = [@input[2].strip]
+                
+                while value = parse_section_pair_newlinevalue(key)
+                  values << value
+                end
+                { key => values.join("\n") }
+              else
+                false
+              end
+            end
+            
+            
+            def parse_section_pair_newlinevalue(key)
+              if @input.scan(/^#{key}:\s*(.+)\n/)
+                @input[1].strip
+              else
+                false
+              end
+            end
+            
+            def parse_disclaimer
+              if @input.match?(/^\%(.*?)\n/)
+                disclaimer = []
+                while @input.scan(/\%(.*?)\n/)
+                  matched = @input[1].strip
+                  disclaimer << matched if matched =~ /\w+/
+                end
+                @ast["Disclaimer"] = disclaimer.join(" ")
+              else
+                false
+              end
+            end
+
+            def error(message)
+              if @input.eos?
+                raise "Unexpected end of input."
+              else                
+                raise "#{message}: #{@input.peek(@input.string.length)}"
+              end
+            end
+            
+        end
+      end
+    end
+  end
+end

data/lib/whois/answer/parser/scanners/verisign.rb

@@ -19,7 +19,7 @@ module Whois
     class Parser
       module Scanners
         
-        class VerisignScanner
+        class Verisign
 
           def initialize(content)
             @input = StringScanner.new(content)
@@ -36,7 +36,7 @@ module Whois
           private
 
             def parse_content
-              trim_newline      ||
+              trim_empty_line   ||
               parse_not_found   ||
               parse_disclaimer  ||
               parse_notice      ||
@@ -44,13 +44,23 @@ module Whois
               skip_iana_service ||
               trim_last_update  ||
               trim_fuffa        ||
+
               error("Unexpected token")
             end
 
-            def trim_newline
-              @input.scan(/\n/)
+            def trim_empty_line
+              @input.skip(/^\n/)
             end
 
+            def error(message)
+              if @input.eos?
+                raise "Unexpected end of input."
+              else
+                raise "#{message}: `#{@input.peek(@input.string.length)}'"
+              end
+            end
+
+
             def trim_last_update
               @input.scan(/>>>(.*?)<<<\n/)
             end
@@ -81,8 +91,6 @@ module Whois
                   lines << @input[1].strip
                 end
                 @ast["Notice"] = lines.join(" ")
-              else
-                false
               end
             end
 
@@ -93,8 +101,6 @@ module Whois
                   lines << @input[1].strip
                 end
                 @ast["Disclaimer"] = lines.join(" ")
-              else
-                false
               end
             end
 
@@ -107,18 +113,12 @@ module Whois
                   @ast[key].is_a?(Array) || @ast[key] = [@ast[key]]
                   @ast[key] << value
                 end
-              else
-                false
               end
             end
 
-            def error(message)
-              raise "#{message}: #{@input.peek(@input.string.length)}"
-            end
-
         end
         
       end
     end
   end
-end
+end

data/lib/whois/answer/parser/whois.crsnic.net.rb

@@ -100,10 +100,10 @@ module Whois
         protected
 
           def parse
-            Scanners::VerisignScanner.new(content_for_scanner).parse
+            Scanners::Verisign.new(content_for_scanner).parse
           end
 
-          # In case of "Response SPAM", the responde include more than one item
+          # In case of "SPAM Response", the response contains more than one item
           # for the same value and the value becomes an Array.
           def last_useful_item(values)
             values.is_a?(Array) ? values.last : values