whois 4.0.8 → 4.1.0

data/spec/whois/whois_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Whois do
+
+  describe ".lookup" do
+    it "delegates the lookup to a new client" do
+      client = double()
+      expect(client).to receive(:lookup).with("example.com").and_return(:result)
+      expect(Whois::Client).to receive(:new).and_return(client)
+
+      expect(described_class.lookup("example.com")).to eq(:result)
+    end
+  end
+
+end

data/tasks/spec.rake

@@ -0,0 +1,199 @@
+require 'fileutils'
+
+namespace :spec do
+
+  ROOT_DIR      = File.expand_path("../../", __FILE__)
+  TARGET_DIR    = File.join(ROOT_DIR, %w( spec whois record parser responses ))
+
+  SOURCE_DIR    = File.join(ROOT_DIR, %w( spec fixtures responses ))
+  SOURCE_PARTS  = SOURCE_DIR.split("/")
+
+
+  TPL_DESCRIBE = <<-RUBY.chomp!
+# encoding: utf-8
+
+# This file is autogenerated. Do not edit it manually.
+# If you want change the content of this file, edit
+#
+#   %{sfile}
+#
+# and regenerate the tests with the following rake task
+#
+#   $ rake spec:generate
+#
+
+require 'spec_helper'
+require 'whois/record/parser/%{khost}.rb'
+
+describe %{described_class}, "%{descr}" do
+
+  subject do
+    file = fixture("responses", "%{fixture}")
+    part = Whois::Record::Part.new(body: File.read(file))
+    described_class.new(part)
+  end
+
+%{contexts}
+end
+  RUBY
+
+  TPL_CONTEXT  = <<-RUBY.chomp!
+  describe "#%{descr}" do
+    it do
+%{examples}
+    end
+  end
+  RUBY
+
+  TPL_MATCH = <<-RUBY.chomp!
+      expect(subject.%{attribute}).to %{match}
+  RUBY
+
+  TPL_MATCH_SIZE = <<-RUBY.chomp!
+      expect(subject.%{attribute}.size).to eq(%{size})
+  RUBY
+
+  TPL_MATCH_RAISE = <<-RUBY.chomp!
+      expect { subject.%{attribute} }.to %{match}
+  RUBY
+
+  def relativize(path)
+    path.gsub(ROOT_DIR, "")
+  end
+
+
+  task :generate => :generate_parsers
+
+  task :generate_parsers do
+    Dir["#{SOURCE_DIR}/**/*.expected"].each do |source_path|
+
+      # Generate the filename and described_class name from the test file.
+      parts = (source_path.split("/") - SOURCE_PARTS)
+      khost = parts.first
+      kfile = parts.last
+      described_class = Whois::Record::Parser.parser_klass(khost)
+
+      target_path = File.join(TARGET_DIR, *parts).gsub(".expected", "_spec.rb")
+
+      # Extract the tests from the test file
+      # and generates a Hash.
+      #
+      #   {
+      #     "domain" => [
+      #       ["%s", "== \"google.biz\""]
+      #     ],
+      #     "created_on" => [
+      #       ["%s", "be_a(Time)"],
+      #       ["%s", "== Time.parse(\"2002-03-27 00:01:00 UTC\")"]
+      #     ]
+      #   }
+      #
+      tests = {}
+      match = nil
+      lines = File.open(source_path, "r:UTF-8")
+      lines.each do |line|
+        line.chomp!
+        case line
+        when ""
+          # skip empty line
+        when /^\s*$/, /^\s*\/\//
+          # skip comment line
+        when /^#([^\s]+)/
+          tests[match = $1] = []
+        when /^\s+(.+?) (.+)/
+          tests[match] << _parse_assertion($1, $2)
+        else
+          raise "Invalid Line `#{line}' in `#{source_path}'"
+        end
+      end
+
+      # Generate the RSpec content and
+      # write one file for every test.
+      contexts = tests.map do |attr, specs|
+        matches = specs.map do |method, condition|
+          attribute = method % attr
+          case condition
+          when /raise_error/
+            TPL_MATCH_RAISE % { attribute: attribute, match: condition }
+          when /^%SIZE\{(\d+)\}$/
+            TPL_MATCH_SIZE % { attribute: attribute, size: $1 }
+          else
+            TPL_MATCH % { attribute: attribute, match: condition }
+          end
+        end.join("\n")
+        TPL_CONTEXT % { descr: attr, examples: matches }
+      end.join("\n")
+
+      describe = <<-RUBY
+#{TPL_DESCRIBE % {
+  :described_class    => described_class,
+  :khost    => khost,
+  :descr    => kfile,
+  :sfile    => relativize(source_path),
+  :fixture  => parts.join("/").gsub(".expected", ".txt"),
+  :contexts => contexts
+}}
+      RUBY
+
+      print "Generating #{relativize(target_path)}... "
+      File.dirname(target_path).tap { |d| File.exists?(d) || FileUtils.mkdir_p(d) }
+      File.open(target_path, "w+") { |f| f.write(describe) }
+      print "done!\n"
+    end
+
+  end
+
+
+  def _parse_assertion(method, condition)
+    m = method
+    c = condition.strip
+
+    case
+
+    # %s %CLASS{time} -> %s be_a(time)
+    when c =~ /^%CLASS\{(.+)\}$/
+      c = "be_a(#{_build_condition_typeof($1)})"
+
+    # %s %TIME{...} -> %s Time.parse(...)
+    when c =~ /^%TIME\{(.+)\}$/
+      c = "eq(Time.parse(\"#{$1}\"))"
+
+    # %s %ERROR{...} -> %s raise_error(...)
+    when c =~ /^%ERROR\{(.+)\}$/
+      c = "raise_error(Whois::#{$1})"
+
+    # %s =~ "foo"
+    when c =~ /^%MATCH\{(.+)\}$/
+      c = "match(/#{$1}/)"
+
+    # %s == "foo"
+    when c =~ /^== (.+)$/
+      c = "eq(#{$1})"
+
+    end
+
+    [m, c]
+  end
+
+  def _build_condition_typeof(described_class)
+    case described_class
+    when "array"      then "Array"
+    when "time"       then "Time"
+    when "contact"    then "Whois::Record::Contact"
+    when "registrar"  then "Whois::Record::Registrar"
+    when "nameserver" then "Whois::Record::Nameserver"
+    else
+      raise "Unknown class `#{described_class}'"
+    end
+  end
+
+  def _build_condition_typecast(described_class, value)
+    case described_class
+    when "time"
+      %Q{Time.parse("#{value}")}
+    else
+      raise "Unknown class `#{described_class}'"
+    end
+  end
+
+end

data/utils/compare-whois.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby -wKU
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'whois'
+
+IANAWHOIS_DIR = "~/Code/ianawhois"
+
+servers     = {}
+definitions = Whois::Server.definitions(:tld).inject({}) do |hash, item|
+  hash.merge(item[0] => item[1])
+end
+
+Dir.glob("#{File.expand_path(IANAWHOIS_DIR)}/*").each do |entry|
+  basename = File.basename(entry)
+  next unless basename =~ /^[A-Z]+$/
+  content = File.read(entry)
+  server  = content =~ /^whois:\s+(.+)\n$/ && $1
+  servers[".#{basename.downcase}"] = server
+end
+
+diffs = []
+servers.each do |host, server|
+  iana, whois = server, definitions[host]
+  if iana != whois
+    diffs << "#{host}: #{whois.inspect} -> #{iana.inspect}"
+  end
+end
+
+puts diffs.join("\n")

data/utils/deftld.rb

@@ -0,0 +1,231 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'pathname'
+require 'json'
+
+class TldDefs
+
+  KEY_SCHEMA = "_".freeze
+
+  # The current schema version for the definition file
+  #
+  # @return [String] version
+  SCHEMA_VERSION = "2".freeze
+
+
+  class ChangeError < StandardError
+  end
+
+  class TldDef
+    attr_accessor :name
+
+    attr_accessor :host
+    attr_accessor :adapter
+    attr_accessor :format
+    attr_accessor :url
+
+    attr_accessor :type
+    attr_accessor :group
+    attr_accessor :note
+
+    ATTRIBUTES = {
+        host: :host,
+        adapter: :adapter,
+        format: :format,
+        url: :url,
+
+        group: :_group,
+        note: :_note,
+        type: :_type,
+    }
+
+
+    # Normalizes the TLD name by appending the dot, if missing.
+    #
+    # @return [String] the normalized TLD name
+    def self.name(string)
+      string = string.to_str.downcase
+      string.start_with?(".") ? string[1..-1] : string
+    end
+
+    def initialize(name, attributes = {})
+      @name = self.class.name(name)
+      @attributes = {}
+
+      update(attributes)
+    end
+
+    def load(attributes = {})
+      validate(ATTRIBUTES.values, attributes)
+
+      attributes.each do |key, value|
+        @attributes[key.to_sym] = value
+      end
+
+      self
+    end
+
+    # Updates the definition attributes.
+    #
+    # @param  attributes [Hash]
+    # @return [void]
+    def update(attributes = {})
+      validate(ATTRIBUTES.keys, attributes)
+
+      attributes.each do |key, value|
+        @attributes[ATTRIBUTES[key.to_sym]] = value
+      end
+
+      self
+    end
+
+    # Validates the definitions to make sure there are no unknown attributes.
+    #
+    # @param  allowed [Array]
+    # @param  attributes [Hash]
+    # @return [void]
+    # @raise  [ArgumentError] when a definition attribute is unknown
+    def validate(allowed, attributes)
+      attributes.each do |key, _|
+        allowed.include?(key.to_sym) or
+            raise ArgumentError, "Invalid attribute `#{key}`"
+      end
+    end
+
+    # Dump the definition object into a serializable Hash.
+    #
+    # Private attributes (starting by _) are added on top.
+    # Keys are sorted alphabetically.
+    #
+    # @return [Hash] the serializable hash
+    def dump
+      Hash[@attributes.reject { |_, value| value.nil? }.sort]
+    end
+  end
+
+
+  # @param  file_path [String] path to the TLD definition file
+  # @param  ignore_missing [Boolean] set to true to silently skip missing TLDs on update.
+  #         When set to false, an error will be raised.
+  def initialize(file_path, ignore_missing: true)
+    @path = Pathname.new(file_path)
+    @settings = {
+        ignore_missing: ignore_missing
+    }
+  end
+
+  def read
+    JSON.load(@path)
+  end
+
+  def write(data)
+    data[KEY_SCHEMA] = schema_attributes
+    data = Hash[data.sort_by { |tld, _| tld.split(".").reverse.join(".") }]
+    File.write(@path, JSON.pretty_generate(data))
+  end
+
+  def count
+    read.count
+  end
+
+  def tlds_add(*tlds, **attributes)
+    update do |defs|
+      tlds.each do |tld|
+        tld = TldDef.name(tld)
+        tlddef = TldDef.new(tld, attributes)
+        defs[tld] = tlddef.dump
+      end
+    end
+  end
+
+  def tlds_update(*tlds, **attributes)
+    update do |defs|
+      tlds.each do |tld|
+        tld = TldDef.name(tld)
+        # puts(tld) if !defs.key?(tld)
+        next if !defs.key?(tld) && @settings[:ignore_missing]
+        raise ChangeError, "error updating `#{tld}`, tld is missing" if !defs.key?(tld) && !@settings[:ignore_missing]
+
+        tlddef = TldDef.new(tld).load(defs[tld]).update(attributes)
+        defs[tld] = tlddef.dump
+      end
+    end
+  end
+
+  def update
+    data = read
+    puts "#{data.count} definitions read"
+    yield data if block_given?
+    write(data)
+    puts "#{data.count} definitions written"
+    data
+  end
+
+  def validate
+    read.each do |tld, data|
+      TldDef.new(tld, data)
+    end; nil
+  end
+
+  private
+
+  def schema_attributes
+    {
+        "schema" => SCHEMA_VERSION,
+        "updated" => Time.now.utc,
+    }
+  end
+
+end
+
+
+defs = TldDefs.new(File.expand_path("../../data/tld.json", __FILE__))
+
+args = ARGV
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: deftld command [options]"
+  opts.separator <<~EOS
+
+Commands:
+\tadd
+\tupdate
+\tvalidate
+\tfmt
+
+Options:
+  EOS
+
+  TldDefs::TldDef::ATTRIBUTES.each do |key, _|
+    opts.on("--#{key} [VALUE]", String, "set the #{key}") do |value|
+      options[key] = value
+    end
+  end
+
+  begin
+    opts.parse!
+  rescue OptionParser::ParseError
+    puts opts
+    exit 1
+  end
+
+  if args.size.zero?
+    puts opts
+    exit 1
+  end
+end
+
+case command = args.shift
+when "validate"
+  defs.validate
+when "fmt"
+  defs.update
+when "add"
+  defs.tlds_add(*args, options)
+when "update"
+  defs.tlds_update(*args, options)
+else
+  puts "Unknown command `#{command}`"
+  exit 1
+end