public_suffix 3.1.1

data/test/benchmarks/bm_select_incremental.rb

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

@@ -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/profilers/initialization_profiler.rb

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

@@ -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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "public_suffix"
+
+# This test runs against the current PSL file and ensures
+# the definitions satisfies the test suite.
+class PslTest < Minitest::Test
+
+  ROOT = File.expand_path("..", __dir__)
+
+  # 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")
+      input  = "nil" if input  == "null"
+      output = "nil" if output == "null"
+
+      input  = eval(input)
+      output = eval(output)
+      [input, output]
+    end
+  end
+  # rubocop:enable Security/Eval
+
+
+  def test_valid
+    # Parse the PSL and run the tests
+    data = File.read(PublicSuffix::List::DEFAULT_LIST_PATH)
+    PublicSuffix::List.default = PublicSuffix::List.parse(data)
+
+    failures = []
+    self.class.tests.each do |input, output|
+      # Punycode domains are not supported ATM
+      next if input =~ /xn\-\-/
+
+      domain = PublicSuffix.domain(input) rescue nil
+      failures << [input, output, domain] if output != domain
+    end
+
+    message = "The following #{failures.size} tests fail:\n"
+    failures.each { |i, o, d| message += "Expected %s to be %s, got %s\n" % [i.inspect, o.inspect, d.inspect] }
+    assert_equal 0, failures.size, message
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+if ENV["COVERAGE"]
+  require "simplecov"
+  SimpleCov.start
+
+  require "codecov"
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+require "minitest/autorun"
+require "minitest/reporters"
+require "mocha/setup"
+
+Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new(color: true)
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "public_suffix"

data/test/tests.txt

@@ -0,0 +1,98 @@
+// Any copyright is dedicated to the Public Domain.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+// null input
+null, null
+// Mixed case
+'COM', null
+'example.COM', 'example.com'
+'WwW.example.COM', 'example.com'
+// Leading dot
+'.com', null
+'.example', null
+'.example.com', null
+'.example.example', null
+// Unlisted TLD
+'example', null
+'example.example', 'example.example'
+'b.example.example', 'example.example'
+'a.b.example.example', 'example.example'
+// Listed, but non-Internet, TLD
+//'local', null
+//'example.local', null
+//'b.example.local', null
+//'a.b.example.local', null
+// TLD with only 1 rule
+'biz', null
+'domain.biz', 'domain.biz'
+'b.domain.biz', 'domain.biz'
+'a.b.domain.biz', 'domain.biz'
+// TLD with some 2-level rules
+'com', null
+'example.com', 'example.com'
+'b.example.com', 'example.com'
+'a.b.example.com', 'example.com'
+'uk.com', null
+'example.uk.com', 'example.uk.com'
+'b.example.uk.com', 'example.uk.com'
+'a.b.example.uk.com', 'example.uk.com'
+'test.ac', 'test.ac'
+// TLD with only 1 (wildcard) rule
+'mm', null
+'c.mm', null
+'b.c.mm', 'b.c.mm'
+'a.b.c.mm', 'b.c.mm'
+// More complex TLD
+'jp', null
+'test.jp', 'test.jp'
+'www.test.jp', 'test.jp'
+'ac.jp', null
+'test.ac.jp', 'test.ac.jp'
+'www.test.ac.jp', 'test.ac.jp'
+'kyoto.jp', null
+'test.kyoto.jp', 'test.kyoto.jp'
+'ide.kyoto.jp', null
+'b.ide.kyoto.jp', 'b.ide.kyoto.jp'
+'a.b.ide.kyoto.jp', 'b.ide.kyoto.jp'
+'c.kobe.jp', null
+'b.c.kobe.jp', 'b.c.kobe.jp'
+'a.b.c.kobe.jp', 'b.c.kobe.jp'
+'city.kobe.jp', 'city.kobe.jp'
+'www.city.kobe.jp', 'city.kobe.jp'
+// TLD with a wildcard rule and exceptions
+'ck', null
+'test.ck', null
+'b.test.ck', 'b.test.ck'
+'a.b.test.ck', 'b.test.ck'
+'www.ck', 'www.ck'
+'www.www.ck', 'www.ck'
+// US K12
+'us', null
+'test.us', 'test.us'
+'www.test.us', 'test.us'
+'ak.us', null
+'test.ak.us', 'test.ak.us'
+'www.test.ak.us', 'test.ak.us'
+'k12.ak.us', null
+'test.k12.ak.us', 'test.k12.ak.us'
+'www.test.k12.ak.us', 'test.k12.ak.us'
+// IDN labels
+'食狮.com.cn', '食狮.com.cn'
+'食狮.公司.cn', '食狮.公司.cn'
+'www.食狮.公司.cn', '食狮.公司.cn'
+'shishi.公司.cn', 'shishi.公司.cn'
+'公司.cn', null
+'食狮.中国', '食狮.中国'
+'www.食狮.中国', '食狮.中国'
+'shishi.中国', 'shishi.中国'
+'中国', null
+// Same as above, but punycoded
+'xn--85x722f.com.cn', 'xn--85x722f.com.cn'
+'xn--85x722f.xn--55qx5d.cn', 'xn--85x722f.xn--55qx5d.cn'
+'www.xn--85x722f.xn--55qx5d.cn', 'xn--85x722f.xn--55qx5d.cn'
+'shishi.xn--55qx5d.cn', 'shishi.xn--55qx5d.cn'
+'xn--55qx5d.cn', null
+'xn--85x722f.xn--fiqs8s', 'xn--85x722f.xn--fiqs8s'
+'www.xn--85x722f.xn--fiqs8s', 'xn--85x722f.xn--fiqs8s'
+'shishi.xn--fiqs8s', 'shishi.xn--fiqs8s'
+'xn--fiqs8s', null

data/test/unit/domain_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class PublicSuffix::DomainTest < Minitest::Test
+
+  def setup
+    @klass = PublicSuffix::Domain
+  end
+
+  # Tokenizes given input into labels.
+  def test_self_name_to_labels
+    assert_equal  %w( someone spaces live com ),
+                  PublicSuffix::Domain.name_to_labels("someone.spaces.live.com")
+    assert_equal  %w( leontina23samiko wiki zoho com ),
+                  PublicSuffix::Domain.name_to_labels("leontina23samiko.wiki.zoho.com")
+  end
+
+  # Converts input into String.
+  def test_self_name_to_labels_converts_input_to_string
+    assert_equal  %w( someone spaces live com ),
+                  PublicSuffix::Domain.name_to_labels(:"someone.spaces.live.com")
+  end
+
+
+  def test_initialize_with_tld
+    domain = @klass.new("com")
+    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_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
+  end
+
+
+  def test_to_s
+    assert_equal "com",             @klass.new("com").to_s
+    assert_equal "google.com",      @klass.new("com", "google").to_s
+    assert_equal "www.google.com",  @klass.new("com", "google", "www").to_s
+  end
+
+  def test_to_a
+    assert_equal [nil, nil, "com"],         @klass.new("com").to_a
+    assert_equal [nil, "google", "com"],    @klass.new("com", "google").to_a
+    assert_equal ["www", "google", "com"],  @klass.new("com", "google", "www").to_a
+  end
+
+
+  def test_tld
+    assert_equal "com", @klass.new("com", "google", "www").tld
+  end
+
+  def test_sld
+    assert_equal "google", @klass.new("com", "google", "www").sld
+  end
+
+  def test_trd
+    assert_equal "www", @klass.new("com", "google", "www").trd
+  end
+
+
+  def test_name
+    assert_equal "com",             @klass.new("com").name
+    assert_equal "google.com",      @klass.new("com", "google").name
+    assert_equal "www.google.com",  @klass.new("com", "google", "www").name
+  end
+
+  def test_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
+    assert_equal "google.tldnotlisted", @klass.new("tldnotlisted", "google", "www").domain
+  end
+
+  def test_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
+
+
+  def test_domain_question
+    assert !@klass.new("com").domain?
+    assert  @klass.new("com", "example").domain?
+    assert  @klass.new("com", "example", "www").domain?
+    assert  @klass.new("tldnotlisted", "example").domain?
+  end
+
+end