public_suffix 2.0.5 → 4.0.7

data/test/benchmarks/bm_valid.rb

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

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

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

@@ -0,0 +1,12 @@
+$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/{initialization_profiler.rb → profilers/initialization_profiler.rb}

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
 
 require "memory_profiler"
 require "public_suffix"

data/test/profilers/list_profsize.rb

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

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

data/test/psl_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "public_suffix"
 
@@ -5,14 +7,15 @@ require "public_suffix"
 # the definitions satisfies the test suite.
 class PslTest < Minitest::Test
 
-  ROOT = File.expand_path("../../", __FILE__)
+  ROOT = File.expand_path("..", __dir__)
 
-  # rubocop:disable Lint/Eval
+  # rubocop:disable Security/Eval
   def self.tests
     File.readlines(File.join(ROOT, "test/tests.txt")).map do |line|
       line = line.strip
       next if line.empty?
       next if line.start_with?("//")
+
       input, output = line.split(", ")
 
       # handle the case of eval("null"), it must be eval("nil")
@@ -24,7 +27,7 @@ class PslTest < Minitest::Test
       [input, output]
     end
   end
-  # rubocop:enable
+  # rubocop:enable Security/Eval
 
 
   def test_valid
@@ -35,7 +38,7 @@ class PslTest < Minitest::Test
     failures = []
     self.class.tests.each do |input, output|
       # Punycode domains are not supported ATM
-      next if input =~ /xn\-\-/
+      next if input =~ /xn--/
 
       domain = PublicSuffix.domain(input) rescue nil
       failures << [input, output, domain] if output != domain

data/test/test_helper.rb

@@ -1,21 +1,10 @@
-if ENV["COVERALL"]
-  require "coveralls"
-  Coveralls.wear!
-end
+# frozen_string_literal: true
 
 require "minitest/autorun"
 require "minitest/reporters"
-require "mocha/setup"
+require "mocha/minitest"
 
 Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new(color: true)
 
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "public_suffix"
-
-Minitest::Test.class_eval do
-  unless method_exists?(:assert_not_equal)
-    def assert_not_equal(exp, act, msg = nil)
-      assert_operator(exp, :!=, act, msg)
-    end
-  end
-end

data/test/unit/domain_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class PublicSuffix::DomainTest < Minitest::Test
@@ -23,23 +25,23 @@ class PublicSuffix::DomainTest < Minitest::Test
 
   def test_initialize_with_tld
     domain = @klass.new("com")
-    assert_equal "com",     domain.tld
-    assert_equal nil,       domain.sld
-    assert_equal nil,       domain.trd
+    assert_equal "com", domain.tld
+    assert_nil domain.sld
+    assert_nil domain.trd
   end
 
   def test_initialize_with_tld_and_sld
     domain = @klass.new("com", "google")
-    assert_equal "com",     domain.tld
-    assert_equal "google",  domain.sld
-    assert_equal nil,       domain.trd
+    assert_equal "com", domain.tld
+    assert_equal "google", domain.sld
+    assert_nil domain.trd
   end
 
   def test_initialize_with_tld_and_sld_and_trd
     domain = @klass.new("com", "google", "www")
-    assert_equal "com",     domain.tld
-    assert_equal "google",  domain.sld
-    assert_equal "www",     domain.trd
+    assert_equal "com", domain.tld
+    assert_equal "google", domain.sld
+    assert_equal "www", domain.trd
   end
 
 
@@ -76,8 +78,8 @@ class PublicSuffix::DomainTest < Minitest::Test
   end
 
   def test_domain
-    assert_equal nil, @klass.new("com").domain
-    assert_equal nil, @klass.new("tldnotlisted").domain
+    assert_nil @klass.new("com").domain
+    assert_nil @klass.new("tldnotlisted").domain
     assert_equal "google.com", @klass.new("com", "google").domain
     assert_equal "google.tldnotlisted", @klass.new("tldnotlisted", "google").domain
     assert_equal "google.com", @klass.new("com", "google", "www").domain
@@ -85,10 +87,10 @@ class PublicSuffix::DomainTest < Minitest::Test
   end
 
   def test_subdomain
-    assert_equal nil, @klass.new("com").subdomain
-    assert_equal nil, @klass.new("tldnotlisted").subdomain
-    assert_equal nil, @klass.new("com", "google").subdomain
-    assert_equal nil, @klass.new("tldnotlisted", "google").subdomain
+    assert_nil @klass.new("com").subdomain
+    assert_nil @klass.new("tldnotlisted").subdomain
+    assert_nil @klass.new("com", "google").subdomain
+    assert_nil @klass.new("tldnotlisted", "google").subdomain
     assert_equal "www.google.com", @klass.new("com", "google", "www").subdomain
     assert_equal "www.google.tldnotlisted", @klass.new("tldnotlisted", "google", "www").subdomain
   end

data/test/unit/errors_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class ErrorsTest < Minitest::Test

data/test/unit/list_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class PublicSuffix::ListTest < Minitest::Test
@@ -7,7 +9,7 @@ class PublicSuffix::ListTest < Minitest::Test
   end
 
   def teardown
-    PublicSuffix::List.clear
+    PublicSuffix::List.default = nil
   end
 
 
@@ -16,10 +18,6 @@ class PublicSuffix::ListTest < Minitest::Test
     assert_equal 0, @list.size
   end
 
-  def test_initialize_indexes
-    assert_equal({}, @list.indexes)
-  end
-
 
   def test_equality_with_self
     list = PublicSuffix::List.new
@@ -31,9 +29,34 @@ class PublicSuffix::ListTest < Minitest::Test
     assert_equal PublicSuffix::List.new.add(rule), PublicSuffix::List.new.add(rule)
   end
 
+  def test_each_without_block
+    list = PublicSuffix::List.parse(<<LIST)
+alpha
+beta
+LIST
+
+    assert_kind_of Enumerator, list.each
+    assert_equal 2, list.each.count
+    assert_equal PublicSuffix::Rule.factory("alpha"), list.each.first
+  end
+
+  def test_each_with_block
+    list = PublicSuffix::List.parse(<<LIST)
+alpha
+beta
+LIST
+
+    entries = []
+    list.each { |r| entries << r }
+
+    assert_equal 2, entries.count
+    assert_equal PublicSuffix::Rule.factory("alpha"), entries.first
+  end
+
+
   def test_add
-    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
-    assert_equal @list, @list <<  PublicSuffix::Rule.factory("")
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory("foo"))
+    assert_equal @list, @list <<  PublicSuffix::Rule.factory("bar")
     assert_equal 2, @list.size
   end
 
@@ -47,13 +70,6 @@ class PublicSuffix::ListTest < Minitest::Test
     assert_equal PublicSuffix::Rule.factory("net"), @list.find("google.net")
   end
 
-  def test_add_should_not_duplicate_indices
-    @list = PublicSuffix::List.parse("com")
-    @list.add(PublicSuffix::Rule.factory("net"))
-
-    assert_equal @list.indexes["com"], [0]
-  end
-
   def test_empty?
     assert @list.empty?
     @list.add(PublicSuffix::Rule.factory(""))
@@ -76,7 +92,7 @@ class PublicSuffix::ListTest < Minitest::Test
 
 
   def test_find
-    list = PublicSuffix::List.parse(<<EOS)
+    list = PublicSuffix::List.parse(<<LIST)
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
@@ -102,7 +118,7 @@ io
 blogspot.com
 
 // ===END PRIVATE DOMAINS===
-EOS
+LIST
 
     # match IANA
     assert_equal PublicSuffix::Rule.factory("com"), list.find("example.com")
@@ -129,13 +145,13 @@ EOS
 
 
   def test_select
-    assert_equal 2, list.select("british-library.uk").size
+    assert_equal 2, list.send(:select, "british-library.uk").size
   end
 
   def test_select_name_blank
-    assert_equal [], list.select(nil)
-    assert_equal [], list.select("")
-    assert_equal [], list.select(" ")
+    assert_equal [], list.send(:select, nil)
+    assert_equal [], list.send(:select, "")
+    assert_equal [], list.send(:select, " ")
   end
 
   def test_select_ignore_private
@@ -143,43 +159,36 @@ EOS
     list.add r1 = PublicSuffix::Rule.factory("io")
     list.add r2 = PublicSuffix::Rule.factory("example.io", private: true)
 
-    assert_equal list.select("foo.io"), [r1]
-    assert_equal list.select("example.io"), [r1, r2]
-    assert_equal list.select("foo.example.io"), [r1, r2]
+    assert_equal list.send(:select, "foo.io"), [r1]
+    assert_equal list.send(:select, "example.io"), [r1, r2]
+    assert_equal list.send(:select, "foo.example.io"), [r1, r2]
 
-    assert_equal list.select("foo.io", ignore_private: false), [r1]
-    assert_equal list.select("example.io", ignore_private: false), [r1, r2]
-    assert_equal list.select("foo.example.io", ignore_private: false), [r1, r2]
+    assert_equal list.send(:select, "foo.io", ignore_private: false), [r1]
+    assert_equal list.send(:select, "example.io", ignore_private: false), [r1, r2]
+    assert_equal list.send(:select, "foo.example.io", ignore_private: false), [r1, r2]
 
-    assert_equal list.select("foo.io", ignore_private: true), [r1]
-    assert_equal list.select("example.io", ignore_private: true), [r1]
-    assert_equal list.select("foo.example.io", ignore_private: true), [r1]
+    assert_equal list.send(:select, "foo.io", ignore_private: true), [r1]
+    assert_equal list.send(:select, "example.io", ignore_private: true), [r1]
+    assert_equal list.send(:select, "foo.example.io", ignore_private: true), [r1]
   end
 
 
   def test_self_default_getter
     PublicSuffix::List.default = nil
-    assert_nil PublicSuffix::List.class_eval { @default }
+    assert_nil(PublicSuffix::List.class_eval { @default })
     PublicSuffix::List.default
-    assert_not_equal nil, PublicSuffix::List.class_eval { @default }
+    refute_nil(PublicSuffix::List.class_eval { @default })
   end
 
   def test_self_default_setter
     PublicSuffix::List.default
-    assert_not_equal nil, PublicSuffix::List.class_eval { @default }
+    refute_nil(PublicSuffix::List.class_eval { @default })
     PublicSuffix::List.default = nil
-    assert_equal nil, PublicSuffix::List.class_eval { @default }
-  end
-
-  def test_self_clear
-    PublicSuffix::List.default
-    assert_not_equal nil, PublicSuffix::List.class_eval { @default }
-    PublicSuffix::List.clear
-    assert_equal nil, PublicSuffix::List.class_eval { @default }
+    assert_nil(PublicSuffix::List.class_eval { @default })
   end
 
   def test_self_parse
-    list = PublicSuffix::List.parse(<<EOS)
+    list = PublicSuffix::List.parse(<<LIST)
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
@@ -200,51 +209,24 @@ com
 blogspot.com
 
 // ===END PRIVATE DOMAINS===
-EOS
+LIST
 
     assert_instance_of PublicSuffix::List, list
     assert_equal 4, list.size
 
     rules = %w( com *.uk !british-library.uk blogspot.com ).map { |name| PublicSuffix::Rule.factory(name) }
-    assert_equal rules, list.to_a
+    assert_equal rules, list.each.to_a
 
     # private domains
     assert_equal false, list.find("com").private
     assert_equal true,  list.find("blogspot.com").private
   end
 
-  def test_self_parse_indexes
-    list = PublicSuffix::List.parse(<<EOS)
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-// ===BEGIN ICANN DOMAINS===
-
-// com
-com
-
-// uk
-*.uk
-!british-library.uk
-
-// ===END ICANN DOMAINS===
-// ===BEGIN PRIVATE DOMAINS===
-
-// Google, Inc.
-blogspot.com
-
-// ===END PRIVATE DOMAINS===
-EOS
-
-    assert_equal({ "com" => [0, 3], "uk" => [1, 2] }, list.indexes)
-  end
-
 
   private
 
   def list
-    @_list ||= PublicSuffix::List.parse(<<EOS)
+    @_list ||= PublicSuffix::List.parse(<<LIST)
 // com : http://en.wikipedia.org/wiki/.com
 com
 
@@ -253,7 +235,7 @@ com
 *.sch.uk
 !bl.uk
 !british-library.uk
-EOS
+LIST
   end
 
 end