whois-parser 0.0.1 → 1.0.0.pre.beta1

data/lib/whois/parser.rb

@@ -1,7 +1,411 @@
-require "whois/parser/version"
+#--
+# Ruby Whois
+#
+# An intelligent pure Ruby WHOIS client and parser.
+#
+# Copyright (c) 2009-2015 Simone Carletti <weppos@weppos.net>
+#++
 
+
+require 'whois'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/time/calculations'
+require_relative 'parser/version'
+require_relative 'parser/errors'
+require_relative 'parsers'
+
+
+# The parsing controller that stays behind the {Whois::Record}.
+#
+# It provides object-oriented access to a WHOIS response.
+# The list of properties and methods is available
+# in the following constants:
+#
+# * {Whois::Parser::METHODS}
+# * {Whois::Parser::PROPERTIES}
+#
 module Whois
-  module Parser
-    # Your code goes here...
+  class Parser
+
+    METHODS = [
+      :contacts,
+      :changed?, :unchanged?,
+      # :response_incomplete?, :response_throttled?, :response_unavailable?,
+      # :referral_whois, :referral_url,
+    ]
+
+    PROPERTIES = [
+      :disclaimer,
+      :domain, :domain_id,
+      :status, :available?, :registered?,
+      :created_on, :updated_on, :expires_on,
+      :registrar,
+      :registrant_contacts, :admin_contacts, :technical_contacts,
+      :nameservers,
+    ]
+
+    PROPERTY_STATE_NOT_IMPLEMENTED = :not_implemented
+    PROPERTY_STATE_NOT_SUPPORTED = :not_supported
+    PROPERTY_STATE_SUPPORTED = :supported
+
+
+    # Returns the proper parser instance for given <tt>part</tt>.
+    # The parser class is selected according to the
+    # value of the <tt>#host</tt> attribute for given <tt>part</tt>.
+    #
+    # @param  [Whois::Record::Part] part The part to get the parser for.
+    #
+    # @return [Whois::Parsers::Base]
+    #         An instance of the specific parser for given part.
+    #         The instance is expected to be a child of {Whois::Parsers::Base}.
+    #
+    # @example
+    #
+    #   # Parser for a known host
+    #   Parser.parser_for("whois.example.com")
+    #   # => #<Whois::Parsers::WhoisExampleCom>
+    #
+    #   # Parser for an unknown host
+    #   Parser.parser_for("missing.example.com")
+    #   # => #<Whois::Parsers::Blank>
+    #
+    def self.parser_for(part)
+      parser_klass(part.host).new(part)
+    rescue LoadError
+      Parsers.const_defined?("Blank") || autoload("blank")
+      Parsers::Blank.new(part)
+    end
+
+    # Detects the proper parser class according to given <tt>host</tt>
+    # and returns the class constant.
+    #
+    # This method autoloads missing parser classes. If you want to define
+    # a custom parser, simple make sure the class is loaded in the Ruby
+    # environment before this method is called.
+    #
+    # @param  [String] host The server host.
+    #
+    # @return [Class] The instance of Class representing the parser Class
+    #         corresponding to <tt>host</tt>. If <tt>host</tt> doesn't have
+    #         a specific parser implementation, then returns
+    #         the {Whois::Parsers::Blank} {Class}.
+    #         The {Class} is expected to be a child of {Whois::Parsers::Base}.
+    # @raises LoadError If the class is not found.
+    #
+    # @example
+    #
+    #   Parser.parser_klass("whois.example.com")
+    #   # => Whois::Parsers::WhoisExampleCom
+    #
+    def self.parser_klass(host)
+      name = host_to_parser(host)
+      Parsers.const_defined?(name) || autoload(host)
+      Parsers.const_get(name)
+    end
+
+    # Converts <tt>host</tt> to the corresponding parser class name.
+    #
+    # @param  [String] host The server host.
+    # @return [String] The class name.
+    #
+    # @example
+    #
+    #   Parser.host_to_parser("whois.nic.it")
+    #   # => "WhoisNicIt"
+    #
+    #   Parser.host_to_parser("whois.nic-info.it")
+    #   # => "WhoisNicInfoIt"
+    #
+    def self.host_to_parser(host)
+      host.to_s.downcase.
+        gsub(/[.-]/, '_').
+        gsub(/(?:^|_)(.)/) { $1.upcase }.
+        gsub(/\A(\d+)\z/)  { "Host#{$1}" }
+    end
+
+    # Requires the file at <tt>whois/parsers/#{name}</tt>.
+    #
+    # @param  [String] name The file name to load.
+    #
+    # @return [void]
+    #
+    def self.autoload(name)
+      require "whois/parsers/#{name}"
+    end
+
+
+    # @return [Whois::Record] The record referenced by this parser.
+    attr_reader :record
+
+
+    # Initializes and return a new parser from +record+.
+    #
+    # @param  [Whois::Record] record
+    #
+    def initialize(record)
+      @record = record
+    end
+
+    # Checks if this class respond to given method.
+    #
+    # Overrides the default implementation to add support
+    # for {PROPERTIES} and {METHODS}.
+    #
+    # @return [Boolean]
+    def respond_to?(symbol, include_private = false)
+      respond_to_parser_method?(symbol) || super
+    end
+
+
+    # Returns an array with all host-specific parsers initialized for the parts
+    # contained into this parser.
+    # The array is lazy-initialized.
+    #
+    # @return [Array<Whois::Parsers::Base>]
+    #
+    def parsers
+      @parsers ||= init_parsers
+    end
+
+    # Checks if the <tt>property</tt> passed as symbol
+    # is supported in any of the parsers.
+    #
+    # @return [Boolean]
+    #
+    # @see Whois::Parsers::Base.property_supported?
+    #
+    def property_any_supported?(property)
+      parsers.any? { |parser| parser.property_supported?(property) }
+    end
+
+    # Checks if the <tt>property</tt> passed as symbol
+    # is "not implemented" in any of the parsers.
+    #
+    # @return [Boolean]
+    #
+    def property_any_not_implemented?(property)
+      parsers.any? { |parser| parser.class.property_state?(property, Whois::Parser::PROPERTY_STATE_NOT_IMPLEMENTED) }
+    end
+
+
+    # @!group Methods
+
+    # Collects and returns all the contacts from all the record parts.
+    #
+    # @return [Array<Whois::Record::Contact>]
+    #
+    # @see Whois::Record#contacts
+    # @see Whois::Parsers::Base#contacts
+    #
+    def contacts
+      parsers.map(&:contacts).flatten
+    end
+
+    # @!endgroup
+
+
+    # @!group Response
+
+    # Loop through all the record parts to check
+    # if at least one part changed.
+    #
+    # @param  [Whois::Parser] other The other parser instance to compare.
+    # @return [Boolean]
+    #
+    # @see Whois::Record#changed?
+    # @see Whois::Parsers::Base#changed?
+    #
+    def changed?(other)
+      !unchanged?(other)
+    end
+
+    # The opposite of {#changed?}.
+    #
+    # @param  [Whois::Parser] other The other parser instance to compare.
+    # @return [Boolean]
+    #
+    # @see Whois::Record#unchanged?
+    # @see Whois::Parsers::Base#unchanged?
+    #
+    def unchanged?(other)
+      unless other.is_a?(self.class)
+        raise(ArgumentError, "Can't compare `#{self.class}' with `#{other.class}'")
+      end
+
+      equal?(other) ||
+      parsers.size == other.parsers.size && all_in_parallel?(parsers, other.parsers) { |one, two| one.unchanged?(two) }
+    end
+
+
+    # Loop through all the parts to check if at least
+    # one part is an incomplete response.
+    #
+    # @return [Boolean]
+    #
+    # @see Whois::Record#response_incomplete?
+    # @see Whois::Parsers::Base#response_incomplete?
+    #
+    def response_incomplete?
+      any_is?(parsers, :response_incomplete?)
+    end
+
+    # Loop through all the parts to check if at least
+    # one part is a throttle response.
+    #
+    # @return [Boolean]
+    #
+    # @see Whois::Record#response_throttled?
+    # @see Whois::Parsers::Base#response_throttled?
+    #
+    def response_throttled?
+      any_is?(parsers, :response_throttled?)
+    end
+
+    # Loop through all the parts to check if at least
+    # one part is an unavailable response.
+    #
+    # @return [Boolean]
+    #
+    # @see Whois::Record#response_unavailable?
+    # @see Whois::Parsers::Base#response_unavailable?
+    #
+    def response_unavailable?
+      any_is?(parsers, :response_unavailable?)
+    end
+
+    # @!endgroup
+
+
+    private
+
+    # @api private
+    def self.define_property_method(method)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, &block)
+          delegate_property_to_parsers(:#{method}, *args, &block)
+        end
+      RUBY
+    end
+
+    # @api private
+    def self.define_method_method(method)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, &block)
+          delegate_method_to_parsers(:#{method}, *args, &block)
+        end
+      RUBY
+    end
+
+    def respond_to_parser_method?(symbol)
+      PROPERTIES.include?(symbol) || METHODS.include?(symbol)
+    end
+
+    def method_missing(method, *args, &block)
+      if PROPERTIES.include?(method)
+        self.class.define_property_method(method)
+        send(method, *args, &block)
+      elsif METHODS.include?(method)
+        self.class.define_method_method(method)
+        send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def delegate_property_to_parsers(method, *args, &block)
+      if parsers.empty?
+        raise ParserError, "Unable to select a parser because the Record is empty"
+      elsif (parser = select_parser { |p| p.class.property_state?(method, PROPERTY_STATE_SUPPORTED) })
+        parser.send(method, *args, &block)
+      elsif (parser = select_parser { |p| p.class.property_state?(method, PROPERTY_STATE_NOT_SUPPORTED) })
+        parser.send(method, *args, &block)
+      else
+        raise AttributeNotImplemented, "Unable to find a parser for property `#{method}'"
+      end
+    end
+
+    def delegate_method_to_parsers(method, *args, &block)
+      if parsers.empty?
+        raise ParserError, "Unable to select a parser because the Record is empty"
+      elsif (parser = select_parser { |p| p.respond_to?(method) })
+        parser.send(method, *args, &block)
+      else
+        nil
+      end
+    end
+
+    # Loops through all record parts, for each part
+    # tries to guess the appropriate parser object whenever available,
+    # and returns the final array of server-specific parsers.
+    #
+    # Parsers are initialized in reverse order for performance reason.
+    #
+    # @return [Array<Class>] An array of Class,
+    #         where each item is the parts reverse-N specific parser {Class}.
+    #         Each {Class} is expected to be a child of {Whois::Parsers::Base}.
+    #
+    # @example
+    #
+    #   parser.parts
+    #   # => [whois.foo.com, whois.bar.com]
+    #
+    #   parser.parsers
+    #   # => [Whois::Parsers::WhoisBarCom, Whois::Parsers::WhoisFooCom]
+    #
+    # @api private
+    def init_parsers
+      record.parts.reverse.map { |part| self.class.parser_for(part) }
+    end
+
+    # Selects the first parser in {#parsers} where blocks evaluates to true.
+    #
+    # @return [Whois::Parsers::Base]
+    #         The parser for which the block returns true.
+    # @return [nil]
+    #         If the parser wasn't found.
+    #
+    # @yield  [parser]
+    #
+    # @example
+    #
+    #   select_parser { |parser| parser.class.property_state?(:nameserver, :any) }
+    #   # => #<Whois::Parsers::WhoisExampleCom>
+    #   select_parser { |parser| parser.class.property_state?(:nameservers, PROPERTY_STATE_SUPPORTED) }
+    #   # => nil
+    #
+    # @api private
+    def select_parser(&block)
+      parsers.each do |parser|
+        return parser if block.call(parser)
+      end
+      nil
+    end
+
+    # @api private
+    def all_in_parallel?(*args)
+      count = args.first.size
+      index = 0
+
+      while index < count
+        return false unless yield(*args.map { |arg| arg[index] })
+        index += 1
+      end
+      true
+    end
+
+    # @api private
+    def any_is?(collection, symbol)
+      collection.any? { |item| item.is(symbol) }
+    end
+
   end
 end
+
+require_relative 'parsers'
+require_relative 'parsers/base'
+require_relative 'parser_extensions'
+

data/lib/whois/parser_extensions/whois.rb

@@ -0,0 +1,78 @@
+require 'whois'
+
+
+module Whois
+  class ParserExtensions
+
+    module Whois
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # Checks whether the object represented by <tt>object</tt> is available.
+        #
+        # Warning: this method is only available if a Whois parser exists
+        # for the top level domain of <tt>object</tt>.
+        # If no parser exists for <tt>object</tt>, you'll receive a
+        # warning message and the method will return <tt>nil</tt>.
+        # This is a technical limitation. Browse the lib/whois/record/parsers
+        # folder to view all available parsers.
+        #
+        # @param  [String] object The string to be sent as query parameter.
+        #         It is intended to be a domain name, otherwise this method
+        #         may return unexpected responses.
+        # @return [Boolean]
+        #
+        # @example
+        #   Whois.available?("google.com")
+        #   # => false
+        #
+        # @example
+        #   Whois.available?("google-is-not-available-try-again-later.com")
+        #   # => true
+        #
+        def available?(object)
+          result = lookup(object).available?
+          if result.nil?
+            warn  "This method is not supported for this kind of object.\n" +
+                  "Use Whois.lookup('#{object}') instead."
+          end
+          result
+        end
+
+        # Checks whether the object represented by <tt>object</tt> is registered.
+        #
+        # Warning: this method is only available if a Whois parser exists
+        # for the top level domain of <tt>object</tt>.
+        # If no parser exists for <tt>object</tt>, you'll receive a warning message
+        # and the method will return <tt>nil</tt>.
+        # This is a technical limitation. Browse the lib/whois/record/parsers folder
+        # to view all available parsers.
+        #
+        # @param  [String] object The string to be sent as query parameter.
+        #         It is intended to be a domain name, otherwise this method
+        #         may return unexpected responses.
+        # @return [Boolean]
+        #
+        # @example
+        #   Whois.registered?("google.com")
+        #   # => true
+        #
+        # @example
+        #   Whois.registered?("google-is-not-available-try-again-later.com")
+        #   # => false
+        #
+        def registered?(object)
+          result = lookup(object).registered?
+          if result.nil?
+            warn  "This method is not supported for this kind of object.\n" +
+                  "Use Whois.lookup('#{object}') instead."
+          end
+          result
+        end
+      end
+    end
+
+  end
+end

data/lib/whois/parser_extensions/whois_record.rb

@@ -0,0 +1,222 @@
+require 'whois'
+
+
+module Whois
+  class ParserExtensions
+
+    module WhoisRecord
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Checks if this class respond to given method.
+      #
+      # Overrides the default implementation to add support
+      # for {Parser::PROPERTIES} and {Parser::METHODS}.
+      #
+      # @return [Boolean]
+      def respond_to?(symbol, include_private = false)
+        respond_to_parser_method?(symbol) || super
+      end
+
+
+      # Lazy-loads and returns the parser proxy for current record.
+      #
+      # @return [Whois::Record::Parser]
+      def parser
+        @parser ||= Parser.new(self)
+      end
+
+      # Returns a Hash containing all supported properties for this record
+      # along with corresponding values.
+      #
+      # @return [{ Symbol => Object }]
+      # @raise  [Whois::AttributeNotSupported, Whois::AttributeNotImplemented]
+      def properties
+        warn("#{self.class}#properties is deprecated")
+        hash = {}
+        Parser::PROPERTIES.each { |property| hash[property] = send(property) }
+        hash
+      end
+
+      # Shortcut for <tt>#registrant_contacts.first</tt>.
+      #
+      # @see Whois::Record#registrant_contacts
+      #
+      # @return [Whois::Record::Contact]
+      #         If the property is supported and a contact exists.
+      # @return [nil]
+      #         If the the contact doesn't exist.
+      # @raise  [Whois::AttributeNotSupported, Whois::AttributeNotImplemented]
+      def registrant_contact
+        parser.registrant_contacts.first
+      end
+
+      # Shortcut for <tt>#admin_contacts.first</tt>.
+      #
+      # @see Whois::Record#admin_contacts
+      #
+      # @return [Whois::Record::Contact]
+      #         If the property is supported and a contact exists.
+      # @return [nil]
+      #         If the contact doesn't exist.
+      # @raise  [Whois::AttributeNotSupported, Whois::AttributeNotImplemented]
+      def admin_contact
+        parser.admin_contacts.first
+      end
+
+      # Shortcut for <tt>#technical_contacts.first</tt>.
+      #
+      # @see Whois::Record#technical_contacts
+      #
+      # @return [Whois::Record::Contact]
+      #         If the property is supported and a contact exists.
+      # @return [nil]
+      #         If the contact doesn't exist.
+      # @raise  [Whois::AttributeNotSupported, Whois::AttributeNotImplemented]
+      def technical_contact
+        parser.technical_contacts.first
+      end
+
+      # Collects and returns all the contacts.
+      #
+      # @see Whois::Parser#contacts
+      #
+      # @return [Array<Whois::Record::Contact>]
+      def contacts
+        warn("#{self.class}#contacts is deprecated")
+        parser.contacts
+      end
+
+
+      # Checks whether this {Whois::Record} is different than +other+.
+      #
+      # Comparing the {Whois::Record} content is not as trivial as you may think.
+      # WHOIS servers can inject into the WHOIS response strings that changes at every request,
+      # such as the timestamp the request was generated or the number of requests left
+      # for your current IP.
+      #
+      # These strings causes a simple equal comparison to fail even if
+      # the registry data is the same.
+      #
+      # This method should provide a bulletproof way to detect whether this record
+      # changed compared with +other+.
+      #
+      # @see Whois::Parser#changed?
+      #
+      # @param  [Whois::Record] other The other record instance to compare.
+      # @return [Boolean]
+      def changed?(other)
+        !unchanged?(other)
+      end
+
+      # The opposite of {#changed?}.
+      #
+      # @see Whois::Parser#unchanged?
+      #
+      # @param  [Whois::Record] other The other record instance to compare.
+      # @return [Boolean]
+      def unchanged?(other)
+        unless other.is_a?(self.class)
+          raise(ArgumentError, "Can't compare `#{self.class}' with `#{other.class}'")
+        end
+
+        equal?(other) || parser.unchanged?(other.parser)
+      end
+
+      # Checks whether this is an incomplete response.
+      #
+      # @deprecated
+      # @see Whois::Parser#response_incomplete?
+      #
+      # @return [Boolean]
+      def response_incomplete?
+        warn("#{self.class}#response_incomplete? is deprecated. Use parser.response_incomplete?")
+        parser.response_incomplete?
+      end
+
+      # Checks whether this is a throttle response.
+      #
+      # @deprecated
+      # @see Whois::Parser#response_throttled?
+      #
+      # @return [Boolean]
+      def response_throttled?
+        warn("#{self.class}#response_throttled? is deprecated. Use parser.response_throttled?")
+        parser.response_throttled?
+      end
+
+      # Checks whether this is an unavailable response.
+      #
+      # @deprecated
+      # @see Whois::Parser#response_unavailable?
+      #
+      # @return [Boolean]
+      def response_unavailable?
+        warn("#{self.class}#response_unavailable? is deprecated. Use parser.response_unavailable?")
+        parser.response_unavailable?
+      end
+
+
+      # @deprecated
+      def property_any_supported?(property)
+        warn("#{self.class}#property_any_supported? is deprecated and has no effect. Use Whois::Parser.property_any_supported? if you need it.")
+      end
+
+
+      private
+
+      # @api private
+      def respond_to_parser_method?(symbol)
+        name = symbol.to_s =~ /\?$/ ? symbol.to_s[0..-2] : symbol
+        Parser::PROPERTIES.include?(name.to_sym) || Parser::METHODS.include?(name.to_sym)
+      end
+
+      # Delegates all method calls to the internal parser.
+      def method_missing(method, *args, &block)
+        if Parser::PROPERTIES.include?(method)
+          self.class.define_property_method(method)
+          send(method, *args, &block)
+        elsif Parser::METHODS.include?(method)
+          self.class.define_method_method(method)
+          send(method, *args, &block)
+        elsif method.to_s =~ /([a-z_]+)\?/ and (Parser::PROPERTIES + Parser::METHODS).include?($1.to_sym)
+          self.class.define_question_method($1)
+          send(method)
+        else
+          super
+        end
+      end
+
+      module ClassMethods
+        # @api private
+        def define_property_method(method)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args, &block)
+              parser.#{method}(*args, &block)
+            end
+          RUBY
+        end
+
+        # @api private
+        def define_method_method(method)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args, &block)
+              parser.#{method}(*args, &block)
+            end
+          RUBY
+        end
+
+        # @api private
+        def define_question_method(method)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}?
+              !#{method}.nil?
+            end
+          RUBY
+        end
+      end
+    end
+
+  end
+end