whois 0.5.3 → 0.8.0

data/lib/whois/answer/contact.rb

@@ -0,0 +1,55 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/super_struct'
+
+
+module Whois
+  class Answer
+
+    #
+    # = Contacts
+    #
+    # Holds the details of a Contact extracted from the WHOIS answer.
+    #
+    # A Contact is composed by the following attributes:
+    #
+    # <tt>:id</tt>::
+    # <tt>:name</tt>::
+    # <tt>:organization</tt>::
+    # <tt>:address</tt>::
+    # <tt>:city</tt>::
+    # <tt>:zip</tt>::
+    # <tt>:state</tt>::
+    # <tt>:country</tt>::
+    # <tt>:country_code</tt>::
+    # <tt>:phone</tt>::
+    # <tt>:fax</tt>::
+    # <tt>:email</tt>::
+    # <tt>:created_on</tt>::
+    # <tt>:updated_on</tt>::
+    #
+    # Be aware that every WHOIS server can return a different number of details
+    # or no details at all.
+    #
+    class Contact < SuperStruct.new(:id, :name, :organization,
+                                    :address, :city, :zip, :state, :country, :country_code,
+                                    :phone, :fax, :email,
+                                    :created_on, :updated_on)
+    end
+
+  end
+end

data/lib/whois/answer/parser.rb

@@ -0,0 +1,110 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+module Whois
+  class Answer
+
+    #
+    # = Parser
+    #
+    class Parser
+
+      @@registrable_methods = [
+        :disclaimer,
+        :domain, :domain_id,
+        :referral_whois, :referral_url,
+        :status, :registered?, :available?,
+        :created_on, :updated_on, :expires_on,
+        :registrar, :registrant, :admin, :technical,
+        :nameservers,
+      ]
+
+      # Returns an array containing the name of all methods
+      # that can be registered and should be implemented by
+      # server-specific parsers.
+      def self.registrable_methods
+        @@registrable_methods
+      end
+
+      attr_reader :answer
+
+
+      def initialize(answer)
+        @answer = answer
+      end
+
+      def parsers
+        @parsers ||= init_parsers
+      end
+
+
+      protected
+
+        def method_missing(method, *args, &block)
+          if Parser.registrable_methods.include?(method)
+            if parsers.empty?
+              raise ParserError, "Unable to select a parser because the answer is empty"
+            elsif parser = select_parser(method)
+              parser.send(method, *args, &block)
+            else
+              raise PropertyNotSupported, "Unable to find a parser for `#{method}'"
+            end
+          else
+            super
+          end
+        end
+
+        # Loops through all answer parts, for each parts tries to guess
+        # the appropriate Whois::Answer::Parser::<parser> if it exists
+        # and returns the final array of server-specific parsers.
+        def init_parsers
+          answer.parts.map { |part| self.class.parser_for(part) }
+        end
+
+        def select_parser(method)
+          parsers.reverse.each do |parser|
+            return parser if parser.method_registered?(method)
+          end
+          nil
+        end
+
+
+      def self.parser_for(part)
+        parser_klass(part.host).new(part)
+      end
+
+      def self.parser_klass(host)
+        file = "whois/answer/parser/#{host}"
+        require file
+
+        name = host_to_parser(host)
+        Parser.const_get(name)
+
+      rescue LoadError
+        require "whois/answer/parser/blank"
+        Parser::Blank
+      end
+
+      def self.host_to_parser(host)
+        host.to_s.
+          gsub(/\./, '_').
+          gsub(/(?:^|_)(.)/)  { $1.upcase }
+      end
+
+    end
+
+  end
+end

data/lib/whois/answer/parser/README.rdoc

@@ -0,0 +1,21 @@
+disclaimer      String
+
+domain          String
+domain_id       String
+
+status          Enumerator/Array
+available?      Boolean
+registered?     Boolean
+
+created_on      Time
+updated_on      Time
+expires_on      Time
+
+registrar       <Registrar :id, :name, :organization, :url, ...>
+
+
+registrant      <Contact :id, :name, :organization, ...>
+admin           <Contact :id, :name, :organization, ...>
+tech            <Contact :id, :name, :organization, ...>
+
+nameservers     Array

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

@@ -0,0 +1,144 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'strscan'
+require 'time'
+require 'whois/answer/contact'
+require 'whois/answer/registrar'
+
+
+module Whois
+  class Answer
+    class Parser
+
+      #
+      # = Base Answer Parser
+      #
+      # This class is intended to be the base abstract class for all
+      # server-specific parser implementations.
+      #
+      # == Available Methods
+      #
+      # The Base class is for the most part auto-generated via meta programming.
+      # This is the reason why RDoc can't detect and document all available methods.
+      #
+      class Base
+
+        attr_reader :part
+
+
+        def initialize(part)
+          @part = part
+        end
+
+        ::Whois::Answer::Parser.registrable_methods.each do |method|
+          define_method(method) do
+            raise PropertyNotImplemented, "You should overwrite this method."
+          end
+        end
+
+
+        # This is an internal method primaly used as a common access point
+        # to get the content to be parsed as a string.
+        #
+        # The main reason behind this method is because I changed the internal
+        # representation of the data to be parsed more than once
+        # and I always had to rewrite all single parsers in order to reflect these changes.
+        # Now, as far as the parser access the data via the content method,
+        # there's no need to change each single implementation in case the content source changes.
+        #
+        # That said, the only constraints about this method is to return the data to be parsed as string.
+        #
+        def content
+          part.response
+        end
+
+
+        @@method_registry = {}
+
+        #
+        # :call-seq:
+        #   method_registry => hash
+        #   method_registry(:key) => array
+        #
+        # Returns the <tt>@@method_registry</tt> if <tt>key</tt> is nil,
+        # otherwise returns the value in <tt>@@method_registry</tt> for given <tt>key</tt>.
+        #
+        # <tt>@@method_registry</tt> is always a Hash while <tt>@@method_registry[:key]</tt>
+        # is always an array. If <tt>@@method_registry[:key]</tt> doesn't exist, this method
+        # automatically initializes it to an empty array.
+        #
+        def self.method_registry(key = nil)
+          if key.nil?
+            @@method_registry
+          else
+            @@method_registry[key] ||= []
+          end
+        end
+
+        # Returns true if <tt>method</tt> is registered for current class.
+        #
+        #   method_registered?(:disclaimer)
+        #   # => false
+        #
+        #   register_method(:discaimer) {}
+        #   method_registered?(:disclaimer)
+        #   # => true
+        #
+        def self.method_registered?(method)
+          method_registry(self).include?(method)
+        end
+
+        #
+        # :call-seq:
+        #   register_method(:method) { }
+        #   register_method(:method) { |parameter| ... }
+        #   register_method(:method) { |parameter, ...| ... }
+        #
+        # Creates <tt>method</tt> with the content of <tt>block</tt>
+        # and automatically registers <tt>method</tt> for current class.
+        #
+        #   register_method(:discaimer) do
+        #     ...
+        #   end
+        #
+        #   register_method(:changed?) do |other|
+        #     ...
+        #   end
+        #
+        #   method_registered?(:disclaimer)
+        #   # => true
+        #
+        def self.register_method(method, &block)
+          method_registry(self) << method
+          define_method(method, &block)
+        end
+
+        # Instance-level version of <tt>Base.method_registered?</tt>.
+        def method_registered?(method)
+          self.class.method_registered?(method)
+        end
+
+        # Instance-level version of <tt>Base.register_method</tt>.
+        def register_method(method, &block)
+          self.class.register_method(method, &block)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/parser/base'
+
+
+module Whois
+  class Answer
+    class Parser
+
+      #
+      # = Blank parser
+      #
+      # The Blank parser isn't a real parser. It's just a fake parser
+      # that acts as a parser but doesn't provide any special capability.
+      # It doesn't register itself in the parser_registry, it doesn't scan any string,
+      # it only exists to be initialized in case an answer needs to create a parser
+      # for a whois server not supported yet.
+      #
+      class Blank < Base
+
+        ::Whois::Answer::Parser.registrable_methods.each do |method|
+          define_method(method) do
+            raise ParserNotFound, "Unable to find a parser for the server `#{part.host}'"
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+#
+# = Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client.
+#
+#
+# Category::    Net
+# Package::     Whois
+# Author::      Simone Carletti <weppos@weppos.net>
+# License::     MIT License
+#
+#--
+#
+#++
+
+
+require 'whois/answer/parser/base'
+
+
+module Whois
+  class Answer
+    class Parser
+
+      #
+      # = whois.crsnic.net.rb parser
+      #
+      # Parser for the whois.crsnic.net.rb server.
+      #
+      class WhoisCrsnicNet < Base
+
+        register_method :disclaimer do
+          node("Disclaimer")
+        end
+
+
+        register_method :domain do
+          node("Domain Name") { |raw| raw.downcase }
+        end
+
+        register_method :domain_id do
+          nil
+        end
+
+
+        register_method :referral_whois do
+          node("Whois Server")
+        end
+
+        register_method :referral_url do
+          node("Referral URL")
+        end
+
+
+        register_method :status do
+          node("Status")
+        end
+
+        register_method :available? do
+          node("Registrar").nil?
+        end
+
+        register_method :registered? do
+          !available?
+        end
+
+
+        register_method :created_on do
+          node("Creation Date") { |raw| Time.parse(raw) }
+        end
+
+        register_method :updated_on do
+          node("Updated Date") { |raw| Time.parse(raw) }
+        end
+
+        register_method :expires_on do
+          node("Expiration Date") { |raw| Time.parse(raw) }
+        end
+
+
+        register_method :registrar do
+          # Return nil because when the response contains more than one registrar section
+          # the response can be messy. See, for instance, the Verisign response for google.com.
+          nil
+        end
+
+
+        protected
+
+          def ast
+            @ast ||= parse
+          end
+
+          def node(key, &block)
+            if block_given?
+              value = ast[key]
+              value = yield(value) unless value.nil?
+              value
+            else
+              ast[key]
+            end
+          end
+
+          def node?(key)
+            !ast[key].nil?
+          end
+
+          def parse
+            Scanner.new(content.to_s).parse
+          end
+
+
+        class Scanner
+
+          def initialize(content)
+            content = content.to_s.gsub("\r", "")
+            @input = StringScanner.new(content.to_s)
+          end
+
+          def parse
+            @ast = {}
+            while !@input.eos?
+              parse_content
+            end
+            @ast
+          end
+
+          private
+
+            def parse_content
+              trim_newline      ||
+              parse_not_found   ||
+              parse_disclaimer  ||
+              parse_notice      ||
+              parse_pair        ||
+              trim_last_update  ||
+              trim_fuffa        ||
+              error("Unexpected token")
+            end
+
+            def trim_newline
+              @input.scan(/\n/)
+            end
+
+            def trim_last_update
+              @input.scan(/>>>(.*?)<<<\n/)
+            end
+
+            def trim_fuffa
+              @input.scan(/^\w(.*)\n/) ||
+              (@input.scan(/^\w(.*)/) and @input.eos?)
+            end
+
+            def parse_not_found
+              if @input.scan(/No match for "(.*?)"\.\n/)
+                @ast["Domain Name"] = @input[1].strip
+              end
+            end
+
+            # NOTE: parse_notice and parse_disclaimer are similar!
+            def parse_notice
+              if @input.match?(/NOTICE:/)
+                lines = []
+                while !@input.match?(/\n/) && @input.scan(/(.*)\n/)
+                  lines << @input[1].strip
+                end
+                @ast["Notice"] = lines.join(" ")
+              else
+                false
+              end
+            end
+
+            def parse_disclaimer
+              if @input.match?(/TERMS OF USE:/)
+                lines = []
+                while !@input.match?(/\n/) && @input.scan(/(.*)\n/)
+                  lines << @input[1].strip
+                end
+                @ast["Disclaimer"] = lines.join(" ")
+              else
+                false
+              end
+            end
+
+            def parse_pair
+              if @input.scan(/\s+(.*?):(.*?)\n/)
+                key, value = @input[1].strip, @input[2].strip
+                if @ast[key].nil?
+                  @ast[key] = value
+                else
+                  @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