public_suffix 3.1.1 → 5.0.4

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

data/test/psl_test.rb

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

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

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

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

data/test/unit/errors_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class ErrorsTest < Minitest::Test
-
-  # Inherits from StandardError
-  def test_error_inheritance
-    assert_kind_of  StandardError,
-                    PublicSuffix::Error.new
-  end
-
-  # Inherits from PublicSuffix::Error
-  def test_domain_invalid_inheritance
-    assert_kind_of  PublicSuffix::Error,
-                    PublicSuffix::DomainInvalid.new
-  end
-
-  # Inherits from PublicSuffix::DomainInvalid
-  def test_domain_not_allowed_inheritance
-    assert_kind_of  PublicSuffix::DomainInvalid,
-                    PublicSuffix::DomainNotAllowed.new
-  end
-
-end

data/test/unit/list_test.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class PublicSuffix::ListTest < Minitest::Test
-
-  def setup
-    @list = PublicSuffix::List.new
-  end
-
-  def teardown
-    PublicSuffix::List.default = nil
-  end
-
-
-  def test_initialize
-    assert_instance_of PublicSuffix::List, @list
-    assert_equal 0, @list.size
-  end
-
-
-  def test_equality_with_self
-    list = PublicSuffix::List.new
-    assert_equal list, list
-  end
-
-  def test_equality_with_internals
-    rule = PublicSuffix::Rule.factory("com")
-    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("foo"))
-    assert_equal @list, @list <<  PublicSuffix::Rule.factory("bar")
-    assert_equal 2, @list.size
-  end
-
-  def test_add_should_recreate_index
-    @list = PublicSuffix::List.parse("com")
-    assert_equal PublicSuffix::Rule.factory("com"), @list.find("google.com")
-    assert_equal @list.default_rule, @list.find("google.net")
-
-    @list << PublicSuffix::Rule.factory("net")
-    assert_equal PublicSuffix::Rule.factory("com"), @list.find("google.com")
-    assert_equal PublicSuffix::Rule.factory("net"), @list.find("google.net")
-  end
-
-  def test_empty?
-    assert @list.empty?
-    @list.add(PublicSuffix::Rule.factory(""))
-    assert !@list.empty?
-  end
-
-  def test_size
-    assert_equal 0, @list.size
-    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
-    assert_equal 1, @list.size
-  end
-
-  def test_clear
-    assert_equal 0, @list.size
-    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
-    assert_equal 1, @list.size
-    assert_equal @list, @list.clear
-    assert_equal 0, @list.size
-  end
-
-
-  def test_find
-    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/.
-
-// ===BEGIN ICANN DOMAINS===
-
-// com
-com
-
-// uk
-*.uk
-*.sch.uk
-!bl.uk
-!british-library.uk
-
-// io
-io
-
-// ===END ICANN DOMAINS===
-// ===BEGIN PRIVATE DOMAINS===
-
-// Google, Inc.
-blogspot.com
-
-// ===END PRIVATE DOMAINS===
-LIST
-
-    # match IANA
-    assert_equal PublicSuffix::Rule.factory("com"), list.find("example.com")
-    assert_equal PublicSuffix::Rule.factory("com"), list.find("foo.example.com")
-
-    # match wildcard
-    assert_equal PublicSuffix::Rule.factory("*.uk"), list.find("example.uk")
-    assert_equal PublicSuffix::Rule.factory("*.uk"), list.find("example.co.uk")
-    assert_equal PublicSuffix::Rule.factory("*.uk"), list.find("foo.example.co.uk")
-
-    # match exception
-    assert_equal PublicSuffix::Rule.factory("!british-library.uk"), list.find("british-library.uk")
-    assert_equal PublicSuffix::Rule.factory("!british-library.uk"), list.find("foo.british-library.uk")
-
-    # match default rule
-    assert_equal PublicSuffix::Rule.factory("*"), list.find("test")
-    assert_equal PublicSuffix::Rule.factory("*"), list.find("example.test")
-    assert_equal PublicSuffix::Rule.factory("*"), list.find("foo.example.test")
-
-    # match private
-    assert_equal PublicSuffix::Rule.factory("blogspot.com", private: true), list.find("blogspot.com")
-    assert_equal PublicSuffix::Rule.factory("blogspot.com", private: true), list.find("foo.blogspot.com")
-  end
-
-
-  def test_select
-    assert_equal 2, list.send(:select, "british-library.uk").size
-  end
-
-  def test_select_name_blank
-    assert_equal [], list.send(:select, nil)
-    assert_equal [], list.send(:select, "")
-    assert_equal [], list.send(:select, " ")
-  end
-
-  def test_select_ignore_private
-    list = PublicSuffix::List.new
-    list.add r1 = PublicSuffix::Rule.factory("io")
-    list.add r2 = PublicSuffix::Rule.factory("example.io", private: true)
-
-    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.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.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 })
-    PublicSuffix::List.default
-    refute_nil(PublicSuffix::List.class_eval { @default })
-  end
-
-  def test_self_default_setter
-    PublicSuffix::List.default
-    refute_nil(PublicSuffix::List.class_eval { @default })
-    PublicSuffix::List.default = nil
-    assert_nil(PublicSuffix::List.class_eval { @default })
-  end
-
-  def test_self_parse
-    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/.
-
-// ===BEGIN ICANN DOMAINS===
-
-// com
-com
-
-// uk
-*.uk
-!british-library.uk
-
-// ===END ICANN DOMAINS===
-// ===BEGIN PRIVATE DOMAINS===
-
-// Google, Inc.
-blogspot.com
-
-// ===END PRIVATE DOMAINS===
-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.each.to_a
-
-    # private domains
-    assert_equal false, list.find("com").private
-    assert_equal true,  list.find("blogspot.com").private
-  end
-
-
-  private
-
-  def list
-    @_list ||= PublicSuffix::List.parse(<<LIST)
-// com : http://en.wikipedia.org/wiki/.com
-com
-
-// uk : http://en.wikipedia.org/wiki/.uk
-*.uk
-*.sch.uk
-!bl.uk
-!british-library.uk
-LIST
-  end
-
-end