tdiary 5.2.2 → 5.2.3

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

@@ -1,177 +0,0 @@
-# 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("%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-4.0.7/public_suffix.gemspec

@@ -1,29 +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.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.3"
-
-  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-4.0.7/test/acceptance_test.rb

@@ -1,131 +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
-
-  # 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-4.0.7/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/vendor/bundle/ruby/3.1.0/gems/public_suffix-4.0.7/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