public_suffix 3.1.1

data/lib/public_suffix/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+#
+# = Public Suffix
+#
+# Domain name parser based on the Public Suffix List.
+#
+# Copyright (c) 2009-2019 Simone Carletti <weppos@weppos.net>
+
+module PublicSuffix
+  # The current library version.
+  VERSION = "3.1.1"
+end

data/public_suffix.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "public_suffix/version"
+
+Gem::Specification.new do |s|
+  s.name        = "public_suffix"
+  s.version     = PublicSuffix::VERSION
+  s.authors     = ["Simone Carletti"]
+  s.email       = ["weppos@weppos.net"]
+  s.homepage    = "https://simonecarletti.com/code/publicsuffix-ruby"
+  s.summary     = "Domain name parser based on the Public Suffix List."
+  s.description = "PublicSuffix can parse and decompose a domain name into top level domain, domain and subdomains."
+  s.licenses    = ["MIT"]
+
+  s.required_ruby_version = ">= 2.1"
+
+  s.require_paths    = ["lib"]
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.extra_rdoc_files = %w( LICENSE.txt )
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "yard"
+end

data/test/.empty

@@ -0,0 +1,2 @@
+# This is an empty file I use to force a non-empty commit when I only need to store notes
+..

data/test/acceptance_test.rb

@@ -0,0 +1,129 @@
+# 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),
+                   "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
+
+  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
+
+
+  def valid_uri?(name)
+    uri = URI.parse(name)
+    !uri.host.nil?
+  rescue
+    false
+  end
+
+  def valid_domain?(name)
+    uri = URI.parse(name)
+    !uri.host.nil? && uri.scheme.nil?
+  rescue
+    false
+  end
+
+end

data/test/benchmarks/bm_find.rb

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

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

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

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