public_suffix 3.1.1 → 5.0.4

data/.travis.yml

@@ -1,31 +0,0 @@
-language: ruby
-
-rvm:
-  - 2.3
-  - 2.4
-  - 2.5
-  - 2.6
-  - jruby-9.1.5.0
-  - ruby-head
-
-env:
-  - COVERAGE=1
-
-cache:
-  - bundler
-
-matrix:
-  include:
-    - rvm: 2.1
-      before_install:
-        - gem install bundler -v '< 2.0'
-    - rvm: 2.2
-      before_install:
-        - gem install bundler -v '< 2.0'
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-9.1.5.0
-
-before_install:
-  - gem update --system
-  - gem install bundler

data/Gemfile

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gemspec
-
-gem "codecov", require: false
-gem "minitest"
-gem "minitest-reporters"
-gem "rubocop", require: false
-
-gem "memory_profiler", require: false

data/Rakefile

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-
-# By default, run tests and linter.
-task default: [:test, :rubocop]
-
-
-require "rake/testtask"
-
-Rake::TestTask.new do |t|
-  t.libs = %w( lib test )
-  t.pattern = "test/**/*_test.rb"
-  t.verbose = !ENV["VERBOSE"].nil?
-  t.warning = !ENV["WARNING"].nil?
-end
-
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-
-require "yard/rake/yardoc_task"
-
-YARD::Rake::YardocTask.new(:yardoc) do |y|
-  y.options = ["--output-dir", "yardoc"]
-end
-
-CLOBBER.include "yardoc"
-
-
-task :benchmarks do
-  Dir["benchmarks/bm_*.rb"].each do |file|
-    sh "ruby #{file}"
-  end
-end
-task default: [:benchmarks] if ENV["BENCHMARKS"] == "1"
-
-
-desc "Downloads the Public Suffix List file from the repository and stores it locally."
-task :"update-list" do
-  require "net/http"
-
-  DEFINITION_URL = "https://raw.githubusercontent.com/publicsuffix/list/master/public_suffix_list.dat"
-
-  File.open("data/list.txt", "w+") do |f|
-    response = Net::HTTP.get_response(URI.parse(DEFINITION_URL))
-    response.body
-    f.write(response.body)
-  end
-end

data/bin/console

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "public_suffix"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start

data/public_suffix.gemspec

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

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

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

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

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

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

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

data/test/benchmarks/bm_select_incremental.rb

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

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

@@ -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.domain("www.example.com")
-end
-
-report.pretty_print