whois 3.6.5 → 4.0.0.pre.beta1

data/lib/whois/record/nameserver.rb

@@ -1,48 +0,0 @@
-#--
-# Ruby Whois
-#
-# An intelligent pure Ruby WHOIS client and parser.
-#
-# Copyright (c) 2009-2015 Simone Carletti <weppos@weppos.net>
-#++
-
-
-require 'whois/record/super_struct'
-
-
-module Whois
-  class Record
-
-    # Holds the details of the Name Servers extracted from the WHOIS response.
-    #
-    # A name server is composed by the several attributes,
-    # accessible through corresponding getter / setter methods.
-    #
-    # Please note that a response is not required to provide
-    # all the attributes. When an attribute is not available,
-    # the corresponding value is set to nil.
-    #
-    # @attr [String] name
-    # @attr [String] ipv4
-    # @attr [String] ipv6
-    #
-    class Nameserver < SuperStruct.new(:name, :ipv4, :ipv6)
-
-      # Returns a string representation of this object
-      # composed by the host +name+.
-      #
-      # @example
-      #   Nameserver.new(:name => "ns.example.com").to_s
-      #   # => "ns.example.com"
-      #   Nameserver.new.to_s
-      #   # => ""
-      #
-      # @return [String] The string representation.
-      def to_s
-        name.to_s
-      end
-
-    end
-
-  end
-end

data/lib/whois/record/parser.rb

@@ -1,398 +0,0 @@
-#--
-# Ruby Whois
-#
-# An intelligent pure Ruby WHOIS client and parser.
-#
-# Copyright (c) 2009-2015 Simone Carletti <weppos@weppos.net>
-#++
-
-
-module Whois
-  class Record
-
-    # 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::Record::Parser::METHODS}
-    # * {Whois::Record::Parser::PROPERTIES}
-    #
-    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::Record::Parser::Base]
-      #         An instance of the specific parser for given part.
-      #         The instance is expected to be a child of {Whois::Record::Parser::Base}.
-      #
-      # @example
-      #
-      #   # Parser for a known host
-      #   Parser.parser_for("whois.example.com")
-      #   # => #<Whois::Record::Parser::WhoisExampleCom>
-      #
-      #   # Parser for an unknown host
-      #   Parser.parser_for("missing.example.com")
-      #   # => #<Whois::Record::Parser::Blank>
-      #
-      def self.parser_for(part)
-        parser_klass(part.host).new(part)
-      rescue LoadError
-        Parser.const_defined?("Blank") || autoload("blank")
-        Parser::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::Record::Parser::Blank} {Class}.
-      #         The {Class} is expected to be a child of {Whois::Record::Parser::Base}.
-      # @raises LoadError If the class is not found.
-      #
-      # @example
-      #
-      #   Parser.parser_klass("whois.example.com")
-      #   # => Whois::Record::Parser::WhoisExampleCom
-      #
-      def self.parser_klass(host)
-        name = host_to_parser(host)
-        Parser.const_defined?(name) || autoload(host)
-        Parser.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/record/parser/#{name}</tt>.
-      #
-      # @param  [String] name The file name to load.
-      #
-      # @return [void]
-      #
-      def self.autoload(name)
-        require "whois/record/parser/#{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::Record::Parser::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::Record::Parser::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::Record::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::Record::Parser::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::Record::Parser] other The other parser instance to compare.
-      # @return [Boolean]
-      #
-      # @see Whois::Record#changed?
-      # @see Whois::Record::Parser::Base#changed?
-      #
-      def changed?(other)
-        !unchanged?(other)
-      end
-
-      # The opposite of {#changed?}.
-      #
-      # @param  [Whois::Record::Parser] other The other parser instance to compare.
-      # @return [Boolean]
-      #
-      # @see Whois::Record#unchanged?
-      # @see Whois::Record::Parser::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::Record::Parser::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::Record::Parser::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::Record::Parser::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)
-        Parser::PROPERTIES.include?(symbol) || Parser::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::Record::Parser::Base}.
-      #
-      # @example
-      #
-      #   parser.parts
-      #   # => [whois.foo.com, whois.bar.com]
-      #
-      #   parser.parsers
-      #   # => [Whois::Record::Parser::WhoisBarCom, Whois::Record::Parser::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::Record::Parser::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::Record::Parser::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
-end

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

@@ -1,399 +0,0 @@
-#--
-# Ruby Whois
-#
-# An intelligent pure Ruby WHOIS client and parser.
-#
-# Copyright (c) 2009-2015 Simone Carletti <weppos@weppos.net>
-#++
-
-
-require 'time'
-require 'whois/record/contact'
-require 'whois/record/registrar'
-require 'whois/record/nameserver'
-require 'whois/record/scanners/scannable'
-
-
-module Whois
-  class Record
-    class Parser
-
-      # Represents the abstract base parser class for all
-      # server-specific parser implementations.
-      #
-      # NOTE. This 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.
-      #
-      # @abstract
-      #
-      class Base
-
-        class_attribute :_properties
-        self._properties = {}
-
-        # Returns the status for the +property+ passed as symbol.
-        #
-        # @param  [Symbol] property
-        # @return [Symbol, nil]
-        #
-        # @example Undefined property
-        #   property_state(:disclaimer)
-        #   # => nil
-        #
-        # @example Defined property
-        #   property_register(:disclaimer, Whois::Record::Parser::PROPERTY_STATE_SUPPORTED) {}
-        #   property_state(:disclaimer)
-        #   # => :supported
-        #
-        def self.property_state(property)
-          self._properties[property]
-        end
-
-        # Check if the +property+ passed as symbol
-        # is registered in the registry for current parser.
-        #
-        # @param  [Symbol] property
-        # @param  [Symbol] status
-        # @return [Boolean]
-        #
-        # @example Not-registered property
-        #   property_state?(:disclaimer)
-        #   # => false
-        #
-        # @example Registered property
-        #   property_register(:disclaimer) {}
-        #   property_state?(:disclaimer)
-        #   # => true
-        #
-        def self.property_state?(property, status = :any)
-          if status == :any
-            self._properties.key?(property)
-          else
-            self._properties[property] == status
-          end
-        end
-
-        # Registers a <tt>property</tt> in the registry.
-        #
-        # @param  [Symbol] property
-        # @param  [Symbol] status
-        #
-        # @return [void]
-        #
-        def self.property_register(property, status)
-          self._properties = self._properties.merge({ property => status })
-        end
-
-
-        # Registers a <tt>property</tt> as "not implemented"
-        # and defines the corresponding private _property_PROPERTY method.
-        #
-        # A "not implemented" property always raises a <tt>AttributeNotImplemented</tt> error
-        # when the property method is called.
-        #
-        # @param  [Symbol] property
-        # @return [void]
-        #
-        # @example Defining a not implemented property
-        #   # Defines a not implemented property called :disclaimer.
-        #   property_not_implemented(:disclaimer)
-        #
-        def self.property_not_implemented(property)
-          property_register(property, Whois::Record::Parser::PROPERTY_STATE_NOT_IMPLEMENTED)
-
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def _property_#{property}(*args)
-              raise AttributeNotImplemented
-            end
-
-            private :_property_#{property}
-          RUBY
-        end
-
-        # Registers a <tt>property</tt> as "not supported"
-        # and defines the corresponding private _property_PROPERTY method.
-        #
-        # A "not supported" property always raises a <tt>AttributeNotSupported</tt> error
-        # when the property method is called.
-        #
-        # @param  [Symbol] property
-        # @return [void]
-        #
-        # @example Defining an unsupported property
-        #   # Defines an unsupported property called :disclaimer.
-        #   property_not_supported(:disclaimer)
-        #
-        def self.property_not_supported(property)
-          property_register(property, Whois::Record::Parser::PROPERTY_STATE_NOT_SUPPORTED)
-
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def _property_#{property}(*args)
-              raise AttributeNotSupported
-            end
-
-            private :_property_#{property}
-          RUBY
-        end
-
-        # Registers a <tt>property</tt> as "supported"
-        # and defines the corresponding private _property_PROPERTY method.
-        #
-        # @param  [Symbol] property
-        # @return [void]
-        #
-        # @example Defining a supported property
-        #   # Defines a supported property called :disclaimer.
-        #   property_supported(:disclaimer) do
-        #     ...
-        #   end
-        #
-        def self.property_supported(property, &block)
-          property_register(property, Whois::Record::Parser::PROPERTY_STATE_SUPPORTED)
-
-          define_method("_property_#{property}", &block)
-          private :"_property_#{property}"
-        end
-
-        # Checks if the <tt>property</tt> passed as symbol
-        # is supported by the current parser.
-        #
-        # @param  [Symbol] property The name of the property to check.
-        # @return [Boolean]
-        #
-        def property_supported?(property)
-          self.class.property_state?(property, Whois::Record::Parser::PROPERTY_STATE_SUPPORTED)
-        end
-
-
-
-        # @return [Whois::Record::Part] The part referenced by this parser.
-        attr_reader :part
-
-        # Initializes a new parser with given +part+.
-        #
-        # @param  [Whois::Record::Part] part
-        #
-        def initialize(part)
-          @part = part
-          @cached_properties = {}
-        end
-
-
-        # This is an internal method primary used as a common access point
-        # to get the content to be parsed as a string.
-        #
-        # The main reason behind this method is because, in the past,
-        # the internal representation of the data to be parsed changed
-        # several times, 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.
-        #
-        # @return [String] The part body.
-        def content
-          part.body
-        end
-
-        # Check if the parser respond to +symbol+
-        # and calls the method if defined.
-        # The method referenced by the +symbol+
-        # is supposed to be a question? method and to return a boolean.
-        #
-        # @param  [Symbol] symbol
-        # @return [Boolean]
-        #
-        # @example
-        #   is(:response_throttled?)
-        #   # => true
-        #
-        # @api private
-        def is(symbol)
-          respond_to?(symbol) && send(symbol)
-        end
-
-        # @api private
-        def validate!
-          raise ResponseIsThrottled   if is(:response_throttled?)
-          raise ResponseIsUnavailable if is(:response_unavailable?)
-        end
-
-
-        # @!group Properties
-
-        Whois::Record::Parser::PROPERTIES.each do |property|
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def #{property}(*args)
-              handle_property(:#{property}, *args)
-            end
-          RUBY
-
-          property_not_implemented(property)
-        end
-
-        # @!endgroup
-
-
-        # @!group Methods
-
-        # Collects and returns all the available contacts.
-        #
-        # @return [Array<Whois::Record::Contact>]
-        #
-        # @see Whois::Record#contacts
-        # @see Whois::Record::Parser#contacts
-        #
-        def contacts
-          [:registrant_contacts, :admin_contacts, :technical_contacts].inject([]) do |contacts, property|
-            contacts += send(property) if property_supported?(property)
-            contacts
-          end
-        end
-
-        # @!endgroup
-
-
-        # @!group Response
-
-        # Checks whether the content of this part is different than +other+.
-        #
-        # Comparing a WHOIS response 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+.
-        #
-        # @param  [Base] other The other parser instance to compare.
-        # @return [Boolean]
-        #
-        # @see Whois::Record#changed?
-        # @see Whois::Record::Parser#changed?
-        #
-        def changed?(other)
-          !unchanged?(other)
-        end
-
-        # The opposite of {#changed?}.
-        #
-        # @param  [Base] other The other parser instance to compare.
-        # @return [Boolean]
-        #
-        # @see Whois::Record#unchanged?
-        # @see Whois::Record::Parser#unchanged?
-        #
-        def unchanged?(other)
-          unless other.is_a?(self.class)
-            raise(ArgumentError, "Can't compare `#{self.class}' with `#{other.class}'")
-          end
-
-          equal?(other) ||
-          content_for_scanner == other.content_for_scanner
-        end
-
-
-        # Checks whether this is an incomplete response.
-        #
-        # @return [Boolean]
-        #
-        # @abstract This method is just a stub.
-        #           Define it in your parser class.
-        #
-        # @see Whois::Record#response_incomplete?
-        # @see Whois::Record::Parser#response_incomplete?
-        #
-        def response_incomplete?
-        end
-
-        # Checks whether this is a throttle response.
-        #
-        # @return [Boolean]
-        #
-        # @abstract This method is just a stub.
-        #           Define it in your parser class.
-        #
-        # @see Whois::Record#response_throttled?
-        # @see Whois::Record::Parser#response_throttled?
-        #
-        def response_throttled?
-        end
-
-        # Checks whether this response contains a message
-        # that can be reconducted to a "WHOIS Server Unavailable" status.
-        #
-        # Some WHOIS servers returns error messages
-        # when they are experiencing failures.
-        #
-        # @return [Boolean]
-        #
-        # @abstract This method is just a stub.
-        #           Define it in your parser class.
-        #
-        # @see Whois::Record#response_unavailable?
-        # @see Whois::Record::Parser#response_unavailable?
-        #
-        def response_unavailable?
-        end
-
-        # Let them be documented
-        undef response_incomplete?
-        undef response_throttled?
-        undef response_unavailable?
-
-        # @!endgroup
-
-
-        protected
-
-        def content_for_scanner
-          @content_for_scanner ||= content.to_s.gsub(/\r\n/, "\n")
-        end
-
-        def cached_properties_fetch(key)
-          if !@cached_properties.key?(key)
-            @cached_properties[key] = yield
-          end
-          @cached_properties[key]
-        end
-
-
-        private
-
-        def typecast(value, type)
-          if Array == type
-            Array.wrap(value)
-          else
-            value
-          end
-        end
-
-        def handle_property(property, *args)
-          unless property_supported?(property)
-            return send(:"_property_#{property}", *args)
-          end
-
-          cached_properties_fetch(property) do
-            validate!
-            value = send(:"_property_#{property}", *args)
-
-            case property.to_s
-            when /_contacts$/, "nameservers"
-              typecast(value, Array)
-            else
-              value
-            end
-          end
-        end
-
-      end
-
-    end
-  end
-end