public_suffix 2.0.5 → 3.0.0

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

@@ -7,7 +7,7 @@ class PslTest < Minitest::Test
 
   ROOT = File.expand_path("../../", __FILE__)
 
-  # 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

data/test/test_helper.rb

@@ -11,11 +11,3 @@ Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new(color: true)
 
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 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

@@ -23,23 +23,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 +76,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 +85,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/list_test.rb

@@ -7,7 +7,7 @@ class PublicSuffix::ListTest < Minitest::Test
   end
 
   def teardown
-    PublicSuffix::List.clear
+    PublicSuffix::List.default = nil
   end
 
 
@@ -16,10 +16,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 +27,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(<<EOS)
+alpha
+beta
+EOS
+
+    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(<<EOS)
+alpha
+beta
+EOS
+
+    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 +68,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(""))
@@ -129,13 +143,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,39 +157,32 @@ 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
@@ -206,40 +213,13 @@ EOS
     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
 

data/test/unit/public_suffix_test.rb

@@ -13,7 +13,7 @@ class PublicSuffixTest < Minitest::Test
     domain = PublicSuffix.parse("www.example.blogspot.com")
     assert_equal "com", domain.tld
   ensure
-    PublicSuffix::List.clear
+    PublicSuffix::List.default = nil
   end
 
 
@@ -22,13 +22,13 @@ class PublicSuffixTest < Minitest::Test
     assert_instance_of PublicSuffix::Domain, domain
     assert_equal "com",     domain.tld
     assert_equal "example", domain.sld
-    assert_equal nil,       domain.trd
+    assert_nil              domain.trd
 
     domain = PublicSuffix.parse("example.co.uk")
     assert_instance_of PublicSuffix::Domain, domain
     assert_equal "co.uk",   domain.tld
     assert_equal "example", domain.sld
-    assert_equal nil,       domain.trd
+    assert_nil              domain.trd
   end
 
   def test_self_parse_a_domain_with_tld_and_sld_and_trd
@@ -83,7 +83,7 @@ class PublicSuffixTest < Minitest::Test
     assert_instance_of PublicSuffix::Domain, domain
     assert_equal "tldnotlisted",    domain.tld
     assert_equal "example",         domain.sld
-    assert_equal nil,               domain.trd
+    assert_nil                      domain.trd
   end
 
   def test_self_parse_with_unallowed_domain
@@ -169,7 +169,7 @@ class PublicSuffixTest < Minitest::Test
     ].each do |input, _|
       error = PublicSuffix.normalize(input)
       assert_instance_of PublicSuffix::DomainInvalid, error
-      assert_match /scheme/, error.message
+      assert_match(/scheme/, error.message)
     end
   end
 

data/test/unit/rule_test.rb

@@ -26,7 +26,7 @@ class PublicSuffix::RuleTest < Minitest::Test
 
   def test_default_returns_default_wildcard
     default = PublicSuffix::Rule.default
-    assert_equal PublicSuffix::Rule::Wildcard.new("*"), default
+    assert_equal PublicSuffix::Rule::Wildcard.build("*"), default
     assert_equal %w( example tldnotlisted ), default.decompose("example.tldnotlisted")
     assert_equal %w( www.example tldnotlisted ), default.decompose("www.example.tldnotlisted")
   end
@@ -45,24 +45,24 @@ class PublicSuffix::RuleBaseTest < Minitest::Test
 
 
   def test_initialize
-    rule = @klass.new("verona.it")
-    assert_instance_of @klass,          rule
-    assert_equal "verona.it",           rule.value
+    rule = @klass.new(value: "verona.it")
+    assert_instance_of @klass,  rule
+    assert_equal "verona.it",   rule.value
   end
 
 
   def test_equality_with_self
-    rule = PublicSuffix::Rule::Base.new("foo")
+    rule = PublicSuffix::Rule::Base.new(value: "foo")
     assert_equal rule, rule
   end
 
   # rubocop:disable Style/SingleLineMethods
   def test_equality_with_internals
-    assert_equal      @klass.new("foo"), @klass.new("foo")
-    assert_not_equal  @klass.new("foo"), @klass.new("bar")
-    assert_not_equal  @klass.new("foo"), PublicSuffix::Rule::Test.new("foo")
-    assert_not_equal  @klass.new("foo"), PublicSuffix::Rule::Test.new("bar")
-    assert_not_equal  @klass.new("foo"), Class.new { def name; foo; end }.new
+    assert_equal @klass.new(value: "foo"), @klass.new(value: "foo")
+    refute_equal @klass.new(value: "foo"), @klass.new(value: "bar")
+    refute_equal @klass.new(value: "foo"), PublicSuffix::Rule::Test.new(value: "foo")
+    refute_equal @klass.new(value: "foo"), PublicSuffix::Rule::Test.new(value: "bar")
+    refute_equal @klass.new(value: "foo"), Class.new { def name; foo; end }.new
   end
   # rubocop:enable Style/SingleLineMethods
 
@@ -105,16 +105,12 @@ class PublicSuffix::RuleBaseTest < Minitest::Test
   end
 
 
-  def test_length
-    assert_raises(NotImplementedError) { @klass.new("com").length }
-  end
-
   def test_parts
-    assert_raises(NotImplementedError) { @klass.new("com").parts }
+    assert_raises(NotImplementedError) { @klass.new(value: "com").parts }
   end
 
   def test_decompose
-    assert_raises(NotImplementedError) { @klass.new("com").decompose("google.com") }
+    assert_raises(NotImplementedError) { @klass.new(value: "com").decompose("google.com") }
   end
 
 end
@@ -127,8 +123,8 @@ class PublicSuffix::RuleNormalTest < Minitest::Test
   end
 
 
-  def test_initialize
-    rule = @klass.new("verona.it")
+  def test_build
+    rule = @klass.build("verona.it")
     assert_instance_of @klass,              rule
     assert_equal "verona.it",               rule.value
     assert_equal "verona.it",               rule.rule
@@ -136,21 +132,21 @@ class PublicSuffix::RuleNormalTest < Minitest::Test
 
 
   def test_length
-    assert_equal 1, @klass.new("com").length
-    assert_equal 2, @klass.new("co.com").length
-    assert_equal 3, @klass.new("mx.co.com").length
+    assert_equal 1, @klass.build("com").length
+    assert_equal 2, @klass.build("co.com").length
+    assert_equal 3, @klass.build("mx.co.com").length
   end
 
   def test_parts
-    assert_equal %w(com), @klass.new("com").parts
-    assert_equal %w(co com), @klass.new("co.com").parts
-    assert_equal %w(mx co com), @klass.new("mx.co.com").parts
+    assert_equal %w(com), @klass.build("com").parts
+    assert_equal %w(co com), @klass.build("co.com").parts
+    assert_equal %w(mx co com), @klass.build("mx.co.com").parts
   end
 
   def test_decompose
-    assert_equal [nil, nil], @klass.new("com").decompose("com")
-    assert_equal %w( example com ), @klass.new("com").decompose("example.com")
-    assert_equal %w( foo.example com ), @klass.new("com").decompose("foo.example.com")
+    assert_equal [nil, nil], @klass.build("com").decompose("com")
+    assert_equal %w( example com ), @klass.build("com").decompose("example.com")
+    assert_equal %w( foo.example com ), @klass.build("com").decompose("foo.example.com")
   end
 
 end
@@ -164,27 +160,27 @@ class PublicSuffix::RuleExceptionTest < Minitest::Test
 
 
   def test_initialize
-    rule = @klass.new("!british-library.uk")
-    assert_instance_of @klass,                    rule
-    assert_equal "british-library.uk",            rule.value
-    assert_equal "!british-library.uk",           rule.rule
+    rule = @klass.build("!british-library.uk")
+    assert_instance_of @klass, rule
+    assert_equal "british-library.uk", rule.value
+    assert_equal "!british-library.uk", rule.rule
   end
 
 
   def test_length
-    assert_equal 1, @klass.new("!british-library.uk").length
-    assert_equal 2, @klass.new("!foo.british-library.uk").length
+    assert_equal 2, @klass.build("!british-library.uk").length
+    assert_equal 3, @klass.build("!foo.british-library.uk").length
   end
 
   def test_parts
-    assert_equal %w( uk ), @klass.new("!british-library.uk").parts
-    assert_equal %w( tokyo jp ), @klass.new("!metro.tokyo.jp").parts
+    assert_equal %w( uk ), @klass.build("!british-library.uk").parts
+    assert_equal %w( tokyo jp ), @klass.build("!metro.tokyo.jp").parts
   end
 
   def test_decompose
-    assert_equal [nil, nil], @klass.new("!british-library.uk").decompose("uk")
-    assert_equal %w( british-library uk ), @klass.new("!british-library.uk").decompose("british-library.uk")
-    assert_equal %w( foo.british-library uk ), @klass.new("!british-library.uk").decompose("foo.british-library.uk")
+    assert_equal [nil, nil], @klass.build("!british-library.uk").decompose("uk")
+    assert_equal %w( british-library uk ), @klass.build("!british-library.uk").decompose("british-library.uk")
+    assert_equal %w( foo.british-library uk ), @klass.build("!british-library.uk").decompose("foo.british-library.uk")
   end
 
 end
@@ -198,27 +194,27 @@ class PublicSuffix::RuleWildcardTest < Minitest::Test
 
 
   def test_initialize
-    rule = @klass.new("*.aichi.jp")
-    assert_instance_of @klass,              rule
-    assert_equal "aichi.jp",                rule.value
-    assert_equal "*.aichi.jp",              rule.rule
+    rule = @klass.build("*.aichi.jp")
+    assert_instance_of @klass, rule
+    assert_equal "aichi.jp", rule.value
+    assert_equal "*.aichi.jp", rule.rule
   end
 
 
   def test_length
-    assert_equal 2, @klass.new("*.uk").length
-    assert_equal 3, @klass.new("*.co.uk").length
+    assert_equal 2, @klass.build("*.uk").length
+    assert_equal 3, @klass.build("*.co.uk").length
   end
 
   def test_parts
-    assert_equal %w( uk ), @klass.new("*.uk").parts
-    assert_equal %w( co uk ), @klass.new("*.co.uk").parts
+    assert_equal %w( uk ), @klass.build("*.uk").parts
+    assert_equal %w( co uk ), @klass.build("*.co.uk").parts
   end
 
   def test_decompose
-    assert_equal [nil, nil], @klass.new("*.do").decompose("nic.do")
-    assert_equal %w( google co.uk ), @klass.new("*.uk").decompose("google.co.uk")
-    assert_equal %w( foo.google co.uk ), @klass.new("*.uk").decompose("foo.google.co.uk")
+    assert_equal [nil, nil], @klass.build("*.do").decompose("nic.do")
+    assert_equal %w( google co.uk ), @klass.build("*.uk").decompose("google.co.uk")
+    assert_equal %w( foo.google co.uk ), @klass.build("*.uk").decompose("foo.google.co.uk")
   end
 
 end