whois 5.0.1 → 5.1.1

data/spec/whois/server_spec.rb

@@ -1,41 +1,43 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server do
   describe ".load_json" do
     it "loads a definition from a JSON file" do
-      expect(File).to receive(:read).with("tld.json").and_return(<<-JSON)
-{
-  "ae.org": {
-    "host": "whois.centralnic.com"
-  },
-  "ar.com": {
-    "host": "whois.centralnic.com"
-  }
-}
+      expect(File).to receive(:read).with("tld.json").and_return(<<~JSON)
+        {
+          "ae.org": {
+            "host": "whois.centralnic.com"
+          },
+          "ar.com": {
+            "host": "whois.centralnic.com"
+          }
+        }
       JSON
       with_definitions do
         described_class.load_json("tld.json")
         expect(described_class.definitions(:tld)).to eq([
-          ["ae.org", "whois.centralnic.com", {}],
-          ["ar.com", "whois.centralnic.com", {}],
-        ])
+                                                          ["ae.org", "whois.centralnic.com", {}],
+                                                          ["ar.com", "whois.centralnic.com", {}],
+                                                        ])
       end
     end
 
     it "convert option keys to Symbol" do
-      expect(File).to receive(:read).with("tld.json").and_return(<<-JSON)
-{
-  "com": {
-    "host": "whois.crsnic.net",
-    "adapter": "verisign"
-  }
-}
+      expect(File).to receive(:read).with("tld.json").and_return(<<~JSON)
+        {
+          "com": {
+            "host": "whois.crsnic.net",
+            "adapter": "verisign"
+          }
+        }
       JSON
       with_definitions do
         described_class.load_json("tld.json")
         expect(described_class.definitions(:tld)).to eq([
-          ["com", "whois.crsnic.net", adapter: "verisign"],
-        ])
+                                                          ["com", "whois.crsnic.net", { adapter: "verisign" }],
+                                                        ])
       end
     end
   end
@@ -70,7 +72,7 @@ describe Whois::Server do
     it "accepts a hash of options" do
       with_definitions do
         Whois::Server.define(Whois::Server::TYPE_TLD, "foo", "whois.foo", foo: "bar")
-        expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", { :foo => "bar" }]])
+        expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", { foo: "bar" }]])
       end
     end
   end
@@ -81,7 +83,7 @@ describe Whois::Server do
       expect(server.type).to eq(:tld)
       expect(server.allocation).to eq("test")
       expect(server.host).to eq("whois.test")
-      expect(server.options).to eq(Hash.new)
+      expect(server.options).to eq({})
     end
 
     it "returns a standard adapter by default" do
@@ -92,25 +94,26 @@ describe Whois::Server do
     it "accepts an :adapter option as Class and returns an instance of given adapter" do
       a = Class.new do
         attr_reader :args
+
         def initialize(*args)
           @args = args
         end
       end
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => a)
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: a)
       expect(server).to be_a(a)
       expect(server.args).to eq([:tld, "test", "whois.test", {}])
     end
 
     it "accepts an :adapter option as Symbol or String, load Class and returns an instance of given adapter" do
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => :none)
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: :none)
       expect(server).to be_a(Whois::Server::Adapters::None)
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => "none")
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: "none")
       expect(server).to be_a(Whois::Server::Adapters::None)
     end
 
     it "deletes the adapter option" do
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => Whois::Server::Adapters::None, :foo => "bar")
-      expect(server.options).to eq({ :foo => "bar" })
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: Whois::Server::Adapters::None, foo: "bar")
+      expect(server.options).to eq({ foo: "bar" })
     end
   end
 
@@ -296,5 +299,4 @@ describe Whois::Server do
       end
     end
   end
-
 end

data/spec/whois/{errors_spec.rb → web_interface_error_spec.rb}

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::WebInterfaceError do
-
   describe "#initialize" do
     it "sets the URL" do
       expect(described_class.new("http://example.com").url).to eq("http://example.com")
     end
 
     it "requires the URL argument" do
-      expect {
+      expect do
         described_class.new
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -19,5 +20,4 @@ describe Whois::WebInterfaceError do
       expect(described_class.new("http://example.com").message).to match(%r{http://example.com})
     end
   end
-
 end

data/spec/whois/whois_spec.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois do
-
   describe ".lookup" do
     it "delegates the lookup to a new client" do
-      client = double()
+      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/whois.gemspec

@@ -1,18 +1,18 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
-require 'whois/version'
+$:.push File.expand_path("../lib", __FILE__)
+require "whois/version"
 
 Gem::Specification.new do |s|
-  s.name        = 'whois'
+  s.name        = "whois"
   s.version     = Whois::VERSION
-  s.authors     = ['Simone Carletti']
-  s.email       = ['weppos@weppos.net']
-  s.homepage    = 'https://whoisrb.org/'
-  s.summary     = 'An intelligent pure Ruby WHOIS client and parser.'
-  s.description = 'Whois is an intelligent WHOIS client and parser written in pure Ruby. It can query registry data for IPv4, IPv6 and top level domains, and parse the responses into easy-to-use Ruby objects via the whois-parser library.'
-  s.license     = 'MIT'
+  s.authors     = ["Simone Carletti"]
+  s.email       = ["weppos@weppos.net"]
+  s.homepage    = "https://whoisrb.org/"
+  s.summary     = "An intelligent pure Ruby WHOIS client and parser."
+  s.description = "Whois is an intelligent WHOIS client and parser written in pure Ruby. It can query registry data for IPv4, IPv6 and top level domains, and parse the responses into easy-to-use Ruby objects via the whois-parser library."
+  s.license     = "MIT"
 
-  s.required_ruby_version = '>= 2.4'
+  s.required_ruby_version = ">= 2.4"
 
   s.require_paths    = %w( lib )
   s.executables      =%w( whoisrb )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: whois
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.1.1
 platform: ruby
 authors:
 - Simone Carletti
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-29 00:00:00.000000000 Z
+date: 2023-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -65,10 +65,17 @@ extra_rdoc_files:
 - ".yardopts"
 files:
 - ".github/FUNDING.yml"
+- ".github/dependabot.yml"
+- ".github/workflows/codeql-analysis.yml"
+- ".github/workflows/release.yml"
+- ".github/workflows/tests.yml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
+- ".rubocop_opinionated.yml"
+- ".rubocop_todo.yml"
 - ".simplecov"
-- ".travis.yml"
+- ".tool-versions"
 - ".yardopts"
 - 4.0-Upgrade.md
 - CHANGELOG.md
@@ -78,7 +85,6 @@ files:
 - README.md
 - Rakefile
 - bin/console
-- bin/setup
 - bin/whoisrb
 - data/asn16.json
 - data/asn32.json
@@ -118,7 +124,6 @@ files:
 - spec/support/helpers/connectivity_helper.rb
 - spec/support/helpers/spec_helper.rb
 - spec/whois/client_spec.rb
-- spec/whois/errors_spec.rb
 - spec/whois/record/part_spec.rb
 - spec/whois/record_spec.rb
 - spec/whois/server/adapters/afilias_spec.rb
@@ -133,8 +138,8 @@ files:
 - spec/whois/server/adapters/web_spec.rb
 - spec/whois/server/socket_handler_spec.rb
 - spec/whois/server_spec.rb
+- spec/whois/web_interface_error_spec.rb
 - spec/whois/whois_spec.rb
-- tasks/spec.rake
 - utils/compare-whois.rb
 - utils/deftld.rb
 - utils/defutils.rb
@@ -146,7 +151,7 @@ homepage: https://whoisrb.org/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -161,8 +166,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.4.21
+signing_key:
 specification_version: 4
 summary: An intelligent pure Ruby WHOIS client and parser.
 test_files:
@@ -181,7 +186,6 @@ test_files:
 - spec/support/helpers/connectivity_helper.rb
 - spec/support/helpers/spec_helper.rb
 - spec/whois/client_spec.rb
-- spec/whois/errors_spec.rb
 - spec/whois/record/part_spec.rb
 - spec/whois/record_spec.rb
 - spec/whois/server/adapters/afilias_spec.rb
@@ -196,4 +200,5 @@ test_files:
 - spec/whois/server/adapters/web_spec.rb
 - spec/whois/server/socket_handler_spec.rb
 - spec/whois/server_spec.rb
+- spec/whois/web_interface_error_spec.rb
 - spec/whois/whois_spec.rb

data/.travis.yml

@@ -1,18 +0,0 @@
-language: ruby
-
-rvm:
-  - "2.4"
-  - "2.5"
-  - "2.6"
-  - "2.7"
-  - ruby-head
-
-cache:
-  - bundler
-
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-
-before_install:
-  - gem install bundler

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/tasks/spec.rake

@@ -1,199 +0,0 @@
-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