tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/public_suffix-5.0.0/lib/public_suffix.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+# = Public Suffix
+#
+# Domain name parser based on the Public Suffix List.
+#
+# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+
+require_relative "public_suffix/domain"
+require_relative "public_suffix/version"
+require_relative "public_suffix/errors"
+require_relative "public_suffix/rule"
+require_relative "public_suffix/list"
+
+# PublicSuffix is a Ruby domain name parser based on the Public Suffix List.
+#
+# The [Public Suffix List](https://publicsuffix.org) is a cross-vendor initiative
+# to provide an accurate list of domain name suffixes.
+#
+# The Public Suffix List is an initiative of the Mozilla Project,
+# but is maintained as a community resource. It is available for use in any software,
+# but was originally created to meet the needs of browser manufacturers.
+module PublicSuffix
+
+  DOT   = "."
+  BANG  = "!"
+  STAR  = "*"
+
+  # Parses +name+ and returns the {PublicSuffix::Domain} instance.
+  #
+  # @example Parse a valid domain
+  #   PublicSuffix.parse("google.com")
+  #   # => #<PublicSuffix::Domain:0x007fec2e51e588 @sld="google", @tld="com", @trd=nil>
+  #
+  # @example Parse a valid subdomain
+  #   PublicSuffix.parse("www.google.com")
+  #   # => #<PublicSuffix::Domain:0x007fec276d4cf8 @sld="google", @tld="com", @trd="www">
+  #
+  # @example Parse a fully qualified domain
+  #   PublicSuffix.parse("google.com.")
+  #   # => #<PublicSuffix::Domain:0x007fec257caf38 @sld="google", @tld="com", @trd=nil>
+  #
+  # @example Parse a fully qualified domain (subdomain)
+  #   PublicSuffix.parse("www.google.com.")
+  #   # => #<PublicSuffix::Domain:0x007fec27b6bca8 @sld="google", @tld="com", @trd="www">
+  #
+  # @example Parse an invalid (unlisted) domain
+  #   PublicSuffix.parse("x.yz")
+  #   # => #<PublicSuffix::Domain:0x007fec2f49bec0 @sld="x", @tld="yz", @trd=nil>
+  #
+  # @example Parse an invalid (unlisted) domain with strict checking (without applying the default * rule)
+  #   PublicSuffix.parse("x.yz", default_rule: nil)
+  #   # => PublicSuffix::DomainInvalid: `x.yz` is not a valid domain
+  #
+  # @example Parse an URL (not supported, only domains)
+  #   PublicSuffix.parse("http://www.google.com")
+  #   # => PublicSuffix::DomainInvalid: http://www.google.com is not expected to contain a scheme
+  #
+  #
+  # @param  name [#to_s] The domain name or fully qualified domain name to parse.
+  # @param  list [PublicSuffix::List] The rule list to search, defaults to the default {PublicSuffix::List}
+  # @param  ignore_private [Boolean]
+  # @return [PublicSuffix::Domain]
+  #
+  # @raise [PublicSuffix::DomainInvalid] If domain is not a valid domain.
+  # @raise [PublicSuffix::DomainNotAllowed] If a rule for +domain+ is found, but the rule doesn't allow +domain+.
+  def self.parse(name, list: List.default, default_rule: list.default_rule, ignore_private: false)
+    what = normalize(name)
+    raise what if what.is_a?(DomainInvalid)
+
+    rule = list.find(what, default: default_rule, ignore_private: ignore_private)
+
+    # rubocop:disable Style/IfUnlessModifier
+    if rule.nil?
+      raise DomainInvalid, "`#{what}` is not a valid domain"
+    end
+    if rule.decompose(what).last.nil?
+      raise DomainNotAllowed, "`#{what}` is not allowed according to Registry policy"
+    end
+
+    # rubocop:enable Style/IfUnlessModifier
+
+    decompose(what, rule)
+  end
+
+  # Checks whether +domain+ is assigned and allowed, without actually parsing it.
+  #
+  # This method doesn't care whether domain is a domain or subdomain.
+  # The validation is performed using the default {PublicSuffix::List}.
+  #
+  # @example Validate a valid domain
+  #   PublicSuffix.valid?("example.com")
+  #   # => true
+  #
+  # @example Validate a valid subdomain
+  #   PublicSuffix.valid?("www.example.com")
+  #   # => true
+  #
+  # @example Validate a not-listed domain
+  #   PublicSuffix.valid?("example.tldnotlisted")
+  #   # => true
+  #
+  # @example Validate a not-listed domain with strict checking (without applying the default * rule)
+  #   PublicSuffix.valid?("example.tldnotlisted")
+  #   # => true
+  #   PublicSuffix.valid?("example.tldnotlisted", default_rule: nil)
+  #   # => false
+  #
+  # @example Validate a fully qualified domain
+  #   PublicSuffix.valid?("google.com.")
+  #   # => true
+  #   PublicSuffix.valid?("www.google.com.")
+  #   # => true
+  #
+  # @example Check an URL (which is not a valid domain)
+  #   PublicSuffix.valid?("http://www.example.com")
+  #   # => false
+  #
+  #
+  # @param  name [#to_s] The domain name or fully qualified domain name to validate.
+  # @param  ignore_private [Boolean]
+  # @return [Boolean]
+  def self.valid?(name, list: List.default, default_rule: list.default_rule, ignore_private: false)
+    what = normalize(name)
+    return false if what.is_a?(DomainInvalid)
+
+    rule = list.find(what, default: default_rule, ignore_private: ignore_private)
+
+    !rule.nil? && !rule.decompose(what).last.nil?
+  end
+
+  # Attempt to parse the name and returns the domain, if valid.
+  #
+  # This method doesn't raise. Instead, it returns nil if the domain is not valid for whatever reason.
+  #
+  # @param  name [#to_s] The domain name or fully qualified domain name to parse.
+  # @param  list [PublicSuffix::List] The rule list to search, defaults to the default {PublicSuffix::List}
+  # @param  ignore_private [Boolean]
+  # @return [String]
+  def self.domain(name, **options)
+    parse(name, **options).domain
+  rescue PublicSuffix::Error
+    nil
+  end
+
+
+  # private
+
+  def self.decompose(name, rule)
+    left, right = rule.decompose(name)
+
+    parts = left.split(DOT)
+    # If we have 0 parts left, there is just a tld and no domain or subdomain
+    # If we have 1 part  left, there is just a tld, domain and not subdomain
+    # If we have 2 parts left, the last part is the domain, the other parts (combined) are the subdomain
+    tld = right
+    sld = parts.empty? ? nil : parts.pop
+    trd = parts.empty? ? nil : parts.join(DOT)
+
+    Domain.new(tld, sld, trd)
+  end
+
+  # Pretend we know how to deal with user input.
+  def self.normalize(name)
+    name = name.to_s.dup
+    name.strip!
+    name.chomp!(DOT)
+    name.downcase!
+
+    return DomainInvalid.new("Name is blank") if name.empty?
+    return DomainInvalid.new("Name starts with a dot") if name.start_with?(DOT)
+    return DomainInvalid.new(format("%s is not expected to contain a scheme", name)) if name.include?("://")
+
+    name
+  end
+
+end

data/vendor/bundle/ruby/3.1.0/gems/public_suffix-5.0.0/public_suffix.gemspec

@@ -0,0 +1,29 @@
+# -*- 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.metadata = {
+    "bug_tracker_uri" => "https://github.com/weppos/publicsuffix-ruby/issues",
+    "changelog_uri" => "https://github.com/weppos/publicsuffix-ruby/blob/master/CHANGELOG.md",
+    "documentation_uri" => "https://rubydoc.info/gems/#{s.name}/#{s.version}",
+    "homepage_uri" => s.homepage,
+    "source_code_uri" => "https://github.com/weppos/publicsuffix-ruby/tree/v#{s.version}",
+  }
+
+  s.required_ruby_version = ">= 2.6"
+
+  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 )
+end

data/vendor/bundle/ruby/3.1.0/gems/public_suffix-5.0.0/test/acceptance_test.rb

@@ -0,0 +1,131 @@
+# 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),
+                   format("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
+
+  # rubocop:disable Style/CombinableLoops
+  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
+  # rubocop:enable Style/CombinableLoops
+
+
+  def valid_uri?(name)
+    uri = URI.parse(name)
+    !uri.host.nil?
+  rescue StandardError
+    false
+  end
+
+  def valid_domain?(name)
+    uri = URI.parse(name)
+    !uri.host.nil? && uri.scheme.nil?
+  rescue StandardError
+    false
+  end
+
+end

data/vendor/bundle/ruby/3.1.0/gems/public_suffix-5.0.0/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 += format("Expected %s to be %s, got %s\n", i.inspect, o.inspect, d.inspect) }
+    assert_equal 0, failures.size, message
+  end
+
+end

data/vendor/bundle/ruby/3.1.0/gems/public_suffix-5.0.0/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