public_suffix 5.0.0 → 5.1.1

data/test/acceptance_test.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class AcceptanceTest < Minitest::Test
-
-  VALID_CASES = [
-    ["example.com",             "example.com", [nil, "example", "com"]],
-    ["foo.example.com",         "example.com",        ["foo", "example", "com"]],
-
-    ["verybritish.co.uk",       "verybritish.co.uk",  [nil, "verybritish", "co.uk"]],
-    ["foo.verybritish.co.uk",   "verybritish.co.uk",  ["foo", "verybritish", "co.uk"]],
-
-    ["parliament.uk",           "parliament.uk",      [nil, "parliament", "uk"]],
-    ["foo.parliament.uk",       "parliament.uk",      ["foo", "parliament", "uk"]],
-  ].freeze
-
-  def test_valid
-    VALID_CASES.each do |input, domain, results|
-      parsed = PublicSuffix.parse(input)
-      trd, sld, tld = results
-      assert_equal tld, parsed.tld, "Invalid tld for `#{name}`"
-      assert_equal sld, parsed.sld, "Invalid sld for `#{name}`"
-      if trd.nil?
-        assert_nil parsed.trd, "Invalid trd for `#{name}`"
-      else
-        assert_equal trd, parsed.trd, "Invalid trd for `#{name}`"
-      end
-
-      assert_equal domain, PublicSuffix.domain(input)
-      assert PublicSuffix.valid?(input)
-    end
-  end
-
-
-  INVALID_CASES = [
-    ["nic.bd", PublicSuffix::DomainNotAllowed],
-    [nil,                       PublicSuffix::DomainInvalid],
-    ["",                        PublicSuffix::DomainInvalid],
-    ["  ",                      PublicSuffix::DomainInvalid],
-  ].freeze
-
-  def test_invalid
-    INVALID_CASES.each do |(name, error)|
-      assert_raises(error) { PublicSuffix.parse(name) }
-      assert !PublicSuffix.valid?(name)
-    end
-  end
-
-
-  REJECTED_CASES = [
-    ["www. .com", true],
-    ["foo.co..uk",          true],
-    ["goo,gle.com",         true],
-    ["-google.com",         true],
-    ["google-.com",         true],
-
-    # This case was covered in GH-15.
-    # I decided to cover this case because it's not easily reproducible with URI.parse
-    # and can lead to several false positives.
-    ["http://google.com",   false],
-  ].freeze
-
-  def test_rejected
-    REJECTED_CASES.each do |name, expected|
-      assert_equal expected, PublicSuffix.valid?(name),
-                   format("Expected %s to be %s", name.inspect, expected.inspect)
-      assert !valid_domain?(name),
-             "#{name} expected to be invalid"
-    end
-  end
-
-
-  CASE_CASES = [
-    ["Www.google.com", %w[www google com]],
-    ["www.Google.com", %w[www google com]],
-    ["www.google.Com", %w[www google com]],
-  ].freeze
-
-  def test_ignore_case
-    CASE_CASES.each do |name, results|
-      domain = PublicSuffix.parse(name)
-      trd, sld, tld = results
-      assert_equal tld, domain.tld, "Invalid tld for `#{name}'"
-      assert_equal sld, domain.sld, "Invalid sld for `#{name}'"
-      assert_equal trd, domain.trd, "Invalid trd for `#{name}'"
-      assert PublicSuffix.valid?(name)
-    end
-  end
-
-
-  INCLUDE_PRIVATE_CASES = [
-    ["blogspot.com", true, "blogspot.com"],
-    ["blogspot.com", false, nil],
-    ["subdomain.blogspot.com", true, "blogspot.com"],
-    ["subdomain.blogspot.com", false, "subdomain.blogspot.com"],
-  ].freeze
-
-  # rubocop:disable Style/CombinableLoops
-  def test_ignore_private
-    # test domain and parse
-    INCLUDE_PRIVATE_CASES.each do |given, ignore_private, expected|
-      if expected.nil?
-        assert_nil PublicSuffix.domain(given, ignore_private: ignore_private)
-      else
-        assert_equal expected, PublicSuffix.domain(given, ignore_private: ignore_private)
-      end
-    end
-    # test valid?
-    INCLUDE_PRIVATE_CASES.each do |given, ignore_private, expected|
-      assert_equal !expected.nil?, PublicSuffix.valid?(given, ignore_private: ignore_private)
-    end
-  end
-  # rubocop:enable Style/CombinableLoops
-
-
-  def valid_uri?(name)
-    uri = URI.parse(name)
-    !uri.host.nil?
-  rescue StandardError
-    false
-  end
-
-  def valid_domain?(name)
-    uri = URI.parse(name)
-    !uri.host.nil? && uri.scheme.nil?
-  rescue StandardError
-    false
-  end
-
-end

data/test/benchmarks/bm_find.rb

@@ -1,66 +0,0 @@
-require 'benchmark'
-require_relative "../../lib/public_suffix"
-
-NAME_SHORT  = "example.de"
-NAME_MEDIUM = "www.subdomain.example.de"
-NAME_LONG   = "one.two.three.four.five.example.de"
-NAME_WILD   = "one.two.three.four.five.example.bd"
-NAME_EXCP   = "one.two.three.four.five.www.ck"
-
-IAAA = "www.example.ac"
-IZZZ = "www.example.zone"
-
-PAAA = "one.two.three.four.five.example.beep.pl"
-PZZZ = "one.two.three.four.five.example.now.sh"
-
-JP   = "www.yokoshibahikari.chiba.jp"
-IT   = "www.example.it"
-COM  = "www.example.com"
-
-TIMES = (ARGV.first || 50_000).to_i
-
-# Initialize
-PublicSuffixList = PublicSuffix::List.default
-PublicSuffixList.find("example.com")
-
-Benchmark.bmbm(25) do |x|
-  x.report("NAME_SHORT") do
-    TIMES.times { PublicSuffixList.find(NAME_SHORT) != nil }
-  end
-  x.report("NAME_MEDIUM") do
-    TIMES.times { PublicSuffixList.find(NAME_MEDIUM) != nil }
-  end
-  x.report("NAME_LONG") do
-    TIMES.times { PublicSuffixList.find(NAME_LONG) != nil }
-  end
-  x.report("NAME_WILD") do
-    TIMES.times { PublicSuffixList.find(NAME_WILD) != nil }
-  end
-  x.report("NAME_EXCP") do
-    TIMES.times { PublicSuffixList.find(NAME_EXCP) != nil }
-  end
-
-  x.report("IAAA") do
-    TIMES.times { PublicSuffixList.find(IAAA) != nil }
-  end
-  x.report("IZZZ") do
-    TIMES.times { PublicSuffixList.find(IZZZ) != nil }
-  end
-
-  x.report("PAAA") do
-    TIMES.times { PublicSuffixList.find(PAAA) != nil }
-  end
-  x.report("PZZZ") do
-    TIMES.times { PublicSuffixList.find(PZZZ) != nil }
-  end
-
-  x.report("JP") do
-    TIMES.times { PublicSuffixList.find(JP) != nil }
-  end
-  x.report("IT") do
-    TIMES.times { PublicSuffixList.find(IT) != nil }
-  end
-  x.report("COM") do
-    TIMES.times { PublicSuffixList.find(COM) != nil }
-  end
-end

data/test/benchmarks/bm_find_all.rb

@@ -1,102 +0,0 @@
-require 'benchmark'
-require_relative "../../lib/public_suffix"
-
-NAME_SHORT  = "example.de"
-NAME_MEDIUM = "www.subdomain.example.de"
-NAME_LONG   = "one.two.three.four.five.example.de"
-NAME_WILD   = "one.two.three.four.five.example.bd"
-NAME_EXCP   = "one.two.three.four.five.www.ck"
-
-IAAA = "www.example.ac"
-IZZZ = "www.example.zone"
-
-PAAA = "one.two.three.four.five.example.beep.pl"
-PZZZ = "one.two.three.four.five.example.now.sh"
-
-JP   = "www.yokoshibahikari.chiba.jp"
-IT   = "www.example.it"
-COM  = "www.example.com"
-
-TIMES = (ARGV.first || 50_000).to_i
-
-# Initialize
-PublicSuffixList = PublicSuffix::List.default
-PublicSuffixList.find("example.com")
-
-Benchmark.bmbm(25) do |x|
-  x.report("NAME_SHORT") do
-    TIMES.times { PublicSuffixList.find(NAME_SHORT) != nil }
-  end
-  x.report("NAME_SHORT (noprivate)") do
-    TIMES.times { PublicSuffixList.find(NAME_SHORT, ignore_private: true) != nil }
-  end
-  x.report("NAME_MEDIUM") do
-    TIMES.times { PublicSuffixList.find(NAME_MEDIUM) != nil }
-  end
-  x.report("NAME_MEDIUM (noprivate)") do
-    TIMES.times { PublicSuffixList.find(NAME_MEDIUM, ignore_private: true) != nil }
-  end
-  x.report("NAME_LONG") do
-    TIMES.times { PublicSuffixList.find(NAME_LONG) != nil }
-  end
-  x.report("NAME_LONG (noprivate)") do
-    TIMES.times { PublicSuffixList.find(NAME_LONG, ignore_private: true) != nil }
-  end
-  x.report("NAME_WILD") do
-    TIMES.times { PublicSuffixList.find(NAME_WILD) != nil }
-  end
-  x.report("NAME_WILD (noprivate)") do
-    TIMES.times { PublicSuffixList.find(NAME_WILD, ignore_private: true) != nil }
-  end
-  x.report("NAME_EXCP") do
-    TIMES.times { PublicSuffixList.find(NAME_EXCP) != nil }
-  end
-  x.report("NAME_EXCP (noprivate)") do
-    TIMES.times { PublicSuffixList.find(NAME_EXCP, ignore_private: true) != nil }
-  end
-
-  x.report("IAAA") do
-    TIMES.times { PublicSuffixList.find(IAAA) != nil }
-  end
-  x.report("IAAA (noprivate)") do
-    TIMES.times { PublicSuffixList.find(IAAA, ignore_private: true) != nil }
-  end
-  x.report("IZZZ") do
-    TIMES.times { PublicSuffixList.find(IZZZ) != nil }
-  end
-  x.report("IZZZ (noprivate)") do
-    TIMES.times { PublicSuffixList.find(IZZZ, ignore_private: true) != nil }
-  end
-
-  x.report("PAAA") do
-    TIMES.times { PublicSuffixList.find(PAAA) != nil }
-  end
-  x.report("PAAA (noprivate)") do
-    TIMES.times { PublicSuffixList.find(PAAA, ignore_private: true) != nil }
-  end
-  x.report("PZZZ") do
-    TIMES.times { PublicSuffixList.find(PZZZ) != nil }
-  end
-  x.report("PZZZ (noprivate)") do
-    TIMES.times { PublicSuffixList.find(PZZZ, ignore_private: true) != nil }
-  end
-
-  x.report("JP") do
-    TIMES.times { PublicSuffixList.find(JP) != nil }
-  end
-  x.report("JP (noprivate)") do
-    TIMES.times { PublicSuffixList.find(JP, ignore_private: true) != nil }
-  end
-  x.report("IT") do
-    TIMES.times { PublicSuffixList.find(IT) != nil }
-  end
-  x.report("IT (noprivate)") do
-    TIMES.times { PublicSuffixList.find(IT, ignore_private: true) != nil }
-  end
-  x.report("COM") do
-    TIMES.times { PublicSuffixList.find(COM) != nil }
-  end
-  x.report("COM (noprivate)") do
-    TIMES.times { PublicSuffixList.find(COM, ignore_private: true) != nil }
-  end
-end

data/test/benchmarks/bm_names.rb

@@ -1,91 +0,0 @@
-require 'benchmark/ips'
-
-STRING = "www.subdomain.example.com"
-ARRAY  = %w(
-  com
-  example.com
-  subdomain.example.com
-  www.subdomain.example.com
-)
-
-def tokenizer1(string)
-  parts = string.split(".").reverse!
-  index = 0
-  query = parts[index]
-  names = []
-
-  loop do
-    names << query
-
-    index += 1
-    break if index >= parts.size
-    query = parts[index] + "." + query
-  end
-  names
-end
-
-def tokenizer2(string)
-  parts = string.split(".")
-  index = parts.size - 1
-  query = parts[index]
-  names = []
-
-  loop do
-    names << query
-
-    index -= 1
-    break if index < 0
-    query = parts[index] + "." + query
-  end
-  names
-end
-
-def tokenizer3(string)
-  isx = string.size
-  idx = string.size - 1
-  names = []
-
-  loop do
-    isx = string.rindex(".", isx - 1) || -1
-    names << string[isx + 1, idx - isx]
-
-    break if isx <= 0
-  end
-  names
-end
-
-def tokenizer4(string)
-  isx = string.size
-  idx = string.size - 1
-  names = []
-
-  loop do
-    isx = string.rindex(".", isx - 1) || -1
-    names << string[(isx+1)..idx]
-
-    break if isx <= 0
-  end
-  names
-end
-
-(x = tokenizer1(STRING)) == ARRAY or fail("tokenizer1 failed: #{x.inspect}")
-(x = tokenizer2(STRING)) == ARRAY or fail("tokenizer2 failed: #{x.inspect}")
-(x = tokenizer3(STRING)) == ARRAY or fail("tokenizer3 failed: #{x.inspect}")
-(x = tokenizer4(STRING)) == ARRAY or fail("tokenizer4 failed: #{x.inspect}")
-
-Benchmark.ips do |x|
-  x.report("tokenizer1") do
-    tokenizer1(STRING).is_a?(Array)
-  end
-  x.report("tokenizer2") do
-    tokenizer2(STRING).is_a?(Array)
-  end
-  x.report("tokenizer3") do
-    tokenizer3(STRING).is_a?(Array)
-  end
-  x.report("tokenizer4") do
-    tokenizer4(STRING).is_a?(Array)
-  end
-
-  x.compare!
-end

data/test/benchmarks/bm_select.rb

@@ -1,26 +0,0 @@
-require 'benchmark'
-require_relative "../../lib/public_suffix"
-
-JP   = "www.yokoshibahikari.chiba.jp"
-
-TIMES = (ARGV.first || 50_000).to_i
-
-# Initialize
-class PublicSuffix::List
-  public :select
-end
-PublicSuffixList = PublicSuffix::List.default
-PublicSuffixList.select("example.jp")
-PublicSuffixList.find("example.jp")
-
-Benchmark.bmbm(25) do |x|
-  x.report("JP select") do
-    TIMES.times { PublicSuffixList.select(JP) }
-  end
-  x.report("JP find") do
-    TIMES.times { PublicSuffixList.find(JP) }
-  end
-  # x.report("JP (noprivate)") do
-  #   TIMES.times { PublicSuffixList.find(JP, ignore_private: true) != nil }
-  # end
-end

data/test/benchmarks/bm_select_incremental.rb

@@ -1,25 +0,0 @@
-require 'benchmark'
-require_relative "../../lib/public_suffix"
-
-JP   = "www.yokoshibahikari.chiba.jp"
-
-TIMES = (ARGV.first || 50_000).to_i
-
-# Initialize
-class PublicSuffix::List
-  public :select
-end
-PublicSuffixList = PublicSuffix::List.default
-PublicSuffixList.select("example.jp")
-
-Benchmark.bmbm(25) do |x|
-  x.report("select jp") do
-    TIMES.times { PublicSuffixList.select("jp") }
-  end
-  x.report("select example.jp") do
-    TIMES.times { PublicSuffixList.select("example.jp") }
-  end
-  x.report("select www.example.jp") do
-    TIMES.times { PublicSuffixList.select("www.example.jp") }
-  end
-end

data/test/benchmarks/bm_valid.rb

@@ -1,101 +0,0 @@
-require 'benchmark'
-require_relative "../../lib/public_suffix"
-
-NAME_SHORT  = "example.de"
-NAME_MEDIUM = "www.subdomain.example.de"
-NAME_LONG   = "one.two.three.four.five.example.de"
-NAME_WILD   = "one.two.three.four.five.example.bd"
-NAME_EXCP   = "one.two.three.four.five.www.ck"
-
-IAAA = "www.example.ac"
-IZZZ = "www.example.zone"
-
-PAAA = "one.two.three.four.five.example.beep.pl"
-PZZZ = "one.two.three.four.five.example.now.sh"
-
-JP   = "www.yokoshibahikari.chiba.jp"
-IT   = "www.example.it"
-COM  = "www.example.com"
-
-TIMES = (ARGV.first || 50_000).to_i
-
-# Initialize
-PublicSuffix.valid?("example.com")
-
-Benchmark.bmbm(25) do |x|
-  x.report("NAME_SHORT") do
-    TIMES.times { PublicSuffix.valid?(NAME_SHORT) == true }
-  end
-  x.report("NAME_SHORT (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(NAME_SHORT, ignore_private: true) == true }
-  end
-  x.report("NAME_MEDIUM") do
-    TIMES.times { PublicSuffix.valid?(NAME_MEDIUM) == true }
-  end
-  x.report("NAME_MEDIUM (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(NAME_MEDIUM, ignore_private: true) == true }
-  end
-  x.report("NAME_LONG") do
-    TIMES.times { PublicSuffix.valid?(NAME_LONG) == true }
-  end
-  x.report("NAME_LONG (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(NAME_LONG, ignore_private: true) == true }
-  end
-  x.report("NAME_WILD") do
-    TIMES.times { PublicSuffix.valid?(NAME_WILD) == true }
-  end
-  x.report("NAME_WILD (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(NAME_WILD, ignore_private: true) == true }
-  end
-  x.report("NAME_EXCP") do
-    TIMES.times { PublicSuffix.valid?(NAME_EXCP) == true }
-  end
-  x.report("NAME_EXCP (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(NAME_EXCP, ignore_private: true) == true }
-  end
-
-  x.report("IAAA") do
-    TIMES.times { PublicSuffix.valid?(IAAA) == true }
-  end
-  x.report("IAAA (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(IAAA, ignore_private: true) == true }
-  end
-  x.report("IZZZ") do
-    TIMES.times { PublicSuffix.valid?(IZZZ) == true }
-  end
-  x.report("IZZZ (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(IZZZ, ignore_private: true) == true }
-  end
-
-  x.report("PAAA") do
-    TIMES.times { PublicSuffix.valid?(PAAA) == true }
-  end
-  x.report("PAAA (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(PAAA, ignore_private: true) == true }
-  end
-  x.report("PZZZ") do
-    TIMES.times { PublicSuffix.valid?(PZZZ) == true }
-  end
-  x.report("PZZZ (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(PZZZ, ignore_private: true) == true }
-  end
-
-  x.report("JP") do
-    TIMES.times { PublicSuffix.valid?(JP) == true }
-  end
-  x.report("JP (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(JP, ignore_private: true) == true }
-  end
-  x.report("IT") do
-    TIMES.times { PublicSuffix.valid?(IT) == true }
-  end
-  x.report("IT (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(IT, ignore_private: true) == true }
-  end
-  x.report("COM") do
-    TIMES.times { PublicSuffix.valid?(COM) == true }
-  end
-  x.report("COM (noprivate)") do
-    TIMES.times { PublicSuffix.valid?(COM, ignore_private: true) == true }
-  end
-end

data/test/profilers/domain_profiler.rb

@@ -1,12 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
-
-require "memory_profiler"
-require "public_suffix"
-
-PublicSuffix::List.default
-
-report = MemoryProfiler.report do
-  PublicSuffix.domain("www.example.com")
-end
-
-report.pretty_print

data/test/profilers/find_profiler.rb

@@ -1,12 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
-
-require "memory_profiler"
-require "public_suffix"
-
-PublicSuffix::List.default
-
-report = MemoryProfiler.report do
-  PublicSuffix::List.default.find("www.example.com")
-end
-
-report.pretty_print

data/test/profilers/find_profiler_jp.rb

@@ -1,12 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
-
-require "memory_profiler"
-require "public_suffix"
-
-PublicSuffix::List.default
-
-report = MemoryProfiler.report do
-  PublicSuffix::List.default.find("a.b.ide.kyoto.jp")
-end
-
-report.pretty_print

data/test/profilers/initialization_profiler.rb

@@ -1,11 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
-
-require "memory_profiler"
-require "public_suffix"
-
-report = MemoryProfiler.report do
-  PublicSuffix::List.default
-end
-
-report.pretty_print
-# report.pretty_print(to_file: 'profiler-%s-%d.txt' % [ARGV[0], Time.now.to_i])

data/test/profilers/list_profsize.rb

@@ -1,11 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
-
-require_relative "object_binsize"
-require "public_suffix"
-
-list = PublicSuffix::List.default
-puts "#{list.size} rules:"
-
-prof = ObjectBinsize.new
-prof.report(PublicSuffix::List.default, label: "PublicSuffix::List size")
-prof.report(PublicSuffix::List.default.instance_variable_get(:@rules), label: "Size of rules")

data/test/profilers/object_binsize.rb

@@ -1,57 +0,0 @@
-require 'tempfile'
-
-# A very simple memory profiles that checks the full size of a variable
-# by serializing into a binary file.
-#
-# Yes, I know this is very rough, but there are cases where ObjectSpace.memsize_of
-# doesn't cooperate, and this is one of the possible workarounds.
-#
-# For certain cases, it works (TM).
-class ObjectBinsize
-
-  def measure(var, label: nil)
-    dump(var, label: label)
-  end
-
-  def report(var, label: nil, padding: 10)
-    file = measure(var, label: label)
-
-    size = format_integer(file.size)
-    name = label || File.basename(file.path)
-    printf("%#{padding}s   %s\n", size, name)
-  end
-
-  private
-
-  def dump(var, **args)
-    file = Tempfile.new(args[:label].to_s)
-    file.write(Marshal.dump(var))
-    file
-  ensure
-    file.close
-  end
-
-  def format_integer(int)
-    int.to_s.reverse.gsub(/...(?=.)/, '\&,').reverse
-  end
-
-end
-
-if __FILE__ == $0
-  prof = ObjectBinsize.new
-
-  prof.report(nil, label: "nil")
-  prof.report(false, label: "false")
-  prof.report(true, label: "true")
-  prof.report(0, label: "integer")
-  prof.report("", label: "empty string")
-  prof.report({}, label: "empty hash")
-  prof.report({}, label: "empty array")
-
-  prof.report({ foo: "1" }, label: "hash 1 item (symbol)")
-  prof.report({ foo: "1", bar: 2 }, label: "hash 2 items (symbol)")
-  prof.report({ "foo" => "1" }, label: "hash 1 item (string)")
-  prof.report({ "foo" => "1", "bar" => 2 }, label: "hash 2 items (string)")
-
-  prof.report("big string" * 200, label: "big string * 200")
-end