paynow_sdk 1.0.9 → 1.1.2

data/vendor/bundle/ruby/2.7.0/gems/domain_name-0.5.20190701/test/test_domain_name-punycode.rb

@@ -1,97 +0,0 @@
-require 'helper'
-
-class TestDomainName < Test::Unit::TestCase
-  test "encode labels just as listed in RFC 3492 #7.1 (slightly modified)" do
-    [
-      ['(A) Arabic (Egyptian)',
-        [0x0644, 0x064A, 0x0647, 0x0645, 0x0627, 0x0628, 0x062A, 0x0643, 0x0644,
-          0x0645, 0x0648, 0x0634, 0x0639, 0x0631, 0x0628, 0x064A, 0x061F],
-        'egbpdaj6bu4bxfgehfvwxn'],
-      ['(B) Chinese (simplified)',
-        [0x4ED6, 0x4EEC, 0x4E3A, 0x4EC0, 0x4E48, 0x4E0D, 0x8BF4, 0x4E2D, 0x6587],
-        'ihqwcrb4cv8a8dqg056pqjye'],
-      ['(C) Chinese (traditional)',
-        [0x4ED6, 0x5011, 0x7232, 0x4EC0, 0x9EBD, 0x4E0D, 0x8AAA, 0x4E2D, 0x6587],
-        'ihqwctvzc91f659drss3x8bo0yb'],
-      ['(D) Czech: Pro<ccaron>prost<ecaron>nemluv<iacute><ccaron>esky',
-        [0x0050, 0x0072, 0x006F, 0x010D, 0x0070, 0x0072, 0x006F, 0x0073, 0x0074,
-          0x011B, 0x006E, 0x0065, 0x006D, 0x006C, 0x0075, 0x0076, 0x00ED, 0x010D,
-          0x0065, 0x0073, 0x006B, 0x0079],
-        'Proprostnemluvesky-uyb24dma41a'],
-      ['(E) Hebrew',
-        [0x05DC, 0x05DE, 0x05D4, 0x05D4, 0x05DD, 0x05E4, 0x05E9, 0x05D5, 0x05D8,
-          0x05DC, 0x05D0, 0x05DE, 0x05D3, 0x05D1, 0x05E8, 0x05D9, 0x05DD, 0x05E2,
-          0x05D1, 0x05E8, 0x05D9, 0x05EA],
-        '4dbcagdahymbxekheh6e0a7fei0b'],
-      ['(F) Hindi (Devanagari)',
-      [0x092F, 0x0939, 0x0932, 0x094B, 0x0917, 0x0939, 0x093F, 0x0928, 0x094D,
-          0x0926, 0x0940, 0x0915, 0x094D, 0x092F, 0x094B, 0x0902, 0x0928, 0x0939,
-          0x0940, 0x0902, 0x092C, 0x094B, 0x0932, 0x0938, 0x0915, 0x0924, 0x0947,
-          0x0939, 0x0948, 0x0902],
-        'i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd'],
-      ['(G) Japanese (kanji and hiragana)',
-        [0x306A, 0x305C, 0x307F, 0x3093, 0x306A, 0x65E5, 0x672C, 0x8A9E, 0x3092,
-          0x8A71, 0x3057, 0x3066, 0x304F, 0x308C, 0x306A, 0x3044, 0x306E, 0x304B],
-        'n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa'],
-      ['(H) Korean (Hangul syllables)',
-        [0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774,
-          0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74,
-          0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C],
-        '989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5j' <<
-        'psd879ccm6fea98c'],
-      ['(I) Russian (Cyrillic)',
-        [0x043F, 0x043E, 0x0447, 0x0435, 0x043C, 0x0443, 0x0436, 0x0435, 0x043E,
-          0x043D, 0x0438, 0x043D, 0x0435, 0x0433, 0x043E, 0x0432, 0x043E, 0x0440,
-          0x044F, 0x0442, 0x043F, 0x043E, 0x0440, 0x0443, 0x0441, 0x0441, 0x043A,
-          0x0438],
-        'b1abfaaepdrnnbgefbadotcwatmq2g4l'],
-      ['(J) Spanish: Porqu<eacute>nopuedensimplementehablarenEspa<ntilde>ol',
-        [0x0050, 0x006F, 0x0072, 0x0071, 0x0075, 0x00E9, 0x006E, 0x006F, 0x0070,
-          0x0075, 0x0065, 0x0064, 0x0065, 0x006E, 0x0073, 0x0069, 0x006D, 0x0070,
-          0x006C, 0x0065, 0x006D, 0x0065, 0x006E, 0x0074, 0x0065, 0x0068, 0x0061,
-          0x0062, 0x006C, 0x0061, 0x0072, 0x0065, 0x006E, 0x0045, 0x0073, 0x0070,
-          0x0061, 0x00F1, 0x006F, 0x006C],
-        'PorqunopuedensimplementehablarenEspaol-fmd56a'],
-      ['(K) Vietnamese: T<adotbelow>isaoh<odotbelow>kh<ocirc>ngth<ecirchookabove>ch' <<
-        '<ihookabove>n<oacute>iti<ecircacute>ngVi<ecircdotbelow>t',
-        [0x0054, 0x1EA1, 0x0069, 0x0073, 0x0061, 0x006F, 0x0068, 0x1ECD, 0x006B,
-          0x0068, 0x00F4, 0x006E, 0x0067, 0x0074, 0x0068, 0x1EC3, 0x0063, 0x0068,
-          0x1EC9, 0x006E, 0x00F3, 0x0069, 0x0074, 0x0069, 0x1EBF, 0x006E, 0x0067,
-          0x0056, 0x0069, 0x1EC7, 0x0074],
-        'TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g'],
-      ['(L) 3<nen>B<gumi><kinpachi><sensei>',
-        [0x0033, 0x5E74, 0x0042, 0x7D44, 0x91D1, 0x516B, 0x5148, 0x751F],
-        '3B-ww4c5e180e575a65lsy2b'],
-      ['(M) <amuro><namie>-with-SUPER-MONKEYS',
-        [0x5B89, 0x5BA4, 0x5948, 0x7F8E, 0x6075, 0x002D, 0x0077, 0x0069, 0x0074,
-          0x0068, 0x002D, 0x0053, 0x0055, 0x0050, 0x0045, 0x0052, 0x002D, 0x004D,
-          0x004F, 0x004E, 0x004B, 0x0045, 0x0059, 0x0053],
-        '-with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n'],
-      ['(N) Hello-Another-Way-<sorezore><no><basho>',
-       [0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002D, 0x0041, 0x006E, 0x006F,
-          0x0074, 0x0068, 0x0065, 0x0072, 0x002D, 0x0057, 0x0061, 0x0079, 0x002D,
-          0x305D, 0x308C, 0x305E, 0x308C, 0x306E, 0x5834, 0x6240],
-        'Hello-Another-Way--fc4qua05auwb3674vfr0b'],
-      ['(O) <hitotsu><yane><no><shita>2',
-        [0x3072, 0x3068, 0x3064, 0x5C4B, 0x6839, 0x306E, 0x4E0B, 0x0032],
-        '2-u9tlzr9756bt3uc0v'],
-      ['(P) Maji<de>Koi<suru>5<byou><mae>',
-        [0x004D, 0x0061, 0x006A, 0x0069, 0x3067, 0x004B, 0x006F, 0x0069, 0x3059,
-          0x308B, 0x0035, 0x79D2, 0x524D],
-        'MajiKoi5-783gue6qz075azm5e'],
-      ['(Q) <pafii>de<runba>',
-        [0x30D1, 0x30D5, 0x30A3, 0x30FC, 0x0064, 0x0065, 0x30EB, 0x30F3, 0x30D0],
-        'de-jg4avhby1noc0d'],
-      ['(R) <sono><supiido><de>',
-        [0x305D, 0x306E, 0x30B9, 0x30D4, 0x30FC, 0x30C9, 0x3067],
-        'd9juau41awczczp'],
-      ['(S) -> $1.00 <-',
-         [0x002D, 0x003E, 0x0020, 0x0024, 0x0031, 0x002E, 0x0030, 0x0030, 0x0020,
-          0x003C, 0x002D],
-        '-> $1.00 <--']
-    ].each { |title, cps, punycode|
-      assert_equal punycode, DomainName::Punycode.encode(cps.pack('U*')), title
-      assert_equal cps.pack('U*').to_nfc, DomainName::Punycode.decode(punycode), title
-    }
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/domain_name-0.5.20190701/test/test_domain_name.rb

@@ -1,317 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'helper'
-require 'ipaddr'
-
-class TestDomainName < Test::Unit::TestCase
-  test "raise ArgumentError if hostname starts with a dot" do
-    [
-      # Leading dot.
-      '.com',
-      '.example',
-      '.example.com',
-      '.example.example',
-    ].each { |hostname|
-      assert_raises(ArgumentError) { DomainName.new(hostname) }
-    }
-  end
-
-  test "accept a String-alike for initialization" do
-    Object.new.tap { |obj|
-      def obj.to_str
-        "Example.org"
-      end
-      assert_equal "example.org", DomainName.new(obj).hostname
-    }
-
-    Object.new.tap { |obj|
-      def obj.to_str
-        123
-      end
-      assert_raises(TypeError) { DomainName.new(obj) }
-    }
-
-    Object.new.tap { |obj|
-      assert_raises(TypeError) { DomainName.new(obj) }
-    }
-  end
-
-  test "parse canonical domain names correctly" do
-    [
-      # Mixed case.
-      ['COM', nil, false, 'com', true],
-      ['example.COM', 'example.com', true, 'com', true],
-      ['WwW.example.COM', 'example.com', true, 'com', true],
-      # Unlisted TLD.
-      ['example', 'example', false, 'example', false],
-      ['example.example', 'example.example', false, 'example', false],
-      ['b.example.example', 'example.example', false, 'example', false],
-      ['a.b.example.example', 'example.example', false, 'example', false],
-      # Listed, but non-Internet, TLD.
-      ['local', 'local', false, 'local', false],
-      ['example.local', 'example.local', false, 'local', false],
-      ['b.example.local', 'example.local', false, 'local', false],
-      ['a.b.example.local', 'example.local', false, 'local', false],
-      # TLD with only 1 rule.
-      ['biz', nil, false, 'biz', true],
-      ['domain.biz', 'domain.biz', true, 'biz', true],
-      ['b.domain.biz', 'domain.biz', true, 'biz', true],
-      ['a.b.domain.biz', 'domain.biz', true, 'biz', true],
-      # TLD with some 2-level rules.
-      ['com', nil, false, 'com', true],
-      ['example.com', 'example.com', true, 'com', true],
-      ['b.example.com', 'example.com', true, 'com', true],
-      ['a.b.example.com', 'example.com', true, 'com', true],
-      ['uk.com', nil, false, 'com', true],
-      ['example.uk.com', 'example.uk.com', true, 'com', true],
-      ['b.example.uk.com', 'example.uk.com', true, 'com', true],
-      ['a.b.example.uk.com', 'example.uk.com', true, 'com', true],
-      ['test.ac', 'test.ac', true, 'ac', true],
-      # TLD with only 1 (wildcard) rule.
-      ['bd', nil, false, 'bd', true],
-      ['c.bd', nil, false, 'bd', true],
-      ['b.c.bd', 'b.c.bd', true, 'bd', true],
-      ['a.b.c.bd', 'b.c.bd', true, 'bd', true],
-      # More complex TLD.
-      ['jp', nil, false, 'jp', true],
-      ['test.jp', 'test.jp', true, 'jp', true],
-      ['www.test.jp', 'test.jp', true, 'jp', true],
-      ['ac.jp', nil, false, 'jp', true],
-      ['test.ac.jp', 'test.ac.jp', true, 'jp', true],
-      ['www.test.ac.jp', 'test.ac.jp', true, 'jp', true],
-      ['kyoto.jp', nil, false, 'jp', true],
-      ['test.kyoto.jp', 'test.kyoto.jp', true, 'jp', true],
-      ['ide.kyoto.jp', nil, false, 'jp', true],
-      ['b.ide.kyoto.jp', 'b.ide.kyoto.jp', true, 'jp', true],
-      ['a.b.ide.kyoto.jp', 'b.ide.kyoto.jp', true, 'jp', true],
-      ['c.kobe.jp', nil, false, 'jp', true],
-      ['b.c.kobe.jp', 'b.c.kobe.jp', true, 'jp', true],
-      ['a.b.c.kobe.jp', 'b.c.kobe.jp', true, 'jp', true],
-      ['city.kobe.jp', 'city.kobe.jp', true, 'jp', true],
-      ['www.city.kobe.jp', 'city.kobe.jp', true, 'jp', true],
-      # TLD with a wildcard rule and exceptions.
-      ['ck', nil, false, 'ck', true],
-      ['test.ck', nil, false, 'ck', true],
-      ['b.test.ck', 'b.test.ck', true, 'ck', true],
-      ['a.b.test.ck', 'b.test.ck', true, 'ck', true],
-      ['www.ck', 'www.ck', true, 'ck', true],
-      ['www.www.ck', 'www.ck', true, 'ck', true],
-      # US K12.
-      ['us', nil, false, 'us', true],
-      ['test.us', 'test.us', true, 'us', true],
-      ['www.test.us', 'test.us', true, 'us', true],
-      ['ak.us', nil, false, 'us', true],
-      ['test.ak.us', 'test.ak.us', true, 'us', true],
-      ['www.test.ak.us', 'test.ak.us', true, 'us', true],
-      ['k12.ak.us', nil, false, 'us', true],
-      ['test.k12.ak.us', 'test.k12.ak.us', true, 'us', true],
-      ['www.test.k12.ak.us', 'test.k12.ak.us', true, 'us', true],
-      # IDN labels. (modified; currently DomainName always converts U-labels to A-labels)
-      ['食狮.com.cn', 'xn--85x722f.com.cn', true, 'cn', true],
-      ['食狮.公司.cn', 'xn--85x722f.xn--55qx5d.cn', true, 'cn', true],
-      ['www.食狮.公司.cn', 'xn--85x722f.xn--55qx5d.cn', true, 'cn', true],
-      ['shishi.公司.cn', 'shishi.xn--55qx5d.cn', true, 'cn', true],
-      ['公司.cn', nil, false, 'cn', true],
-      ['食狮.中国', 'xn--85x722f.xn--fiqs8s', true, 'xn--fiqs8s', true],
-      ['www.食狮.中国', 'xn--85x722f.xn--fiqs8s', true, 'xn--fiqs8s', true],
-      ['shishi.中国', 'shishi.xn--fiqs8s', true, 'xn--fiqs8s', true],
-      ['中国', nil, false, 'xn--fiqs8s', true],
-      # Same as above, but punycoded.
-      ['xn--85x722f.com.cn', 'xn--85x722f.com.cn', true, 'cn', true],
-      ['xn--85x722f.xn--55qx5d.cn', 'xn--85x722f.xn--55qx5d.cn', true, 'cn', true],
-      ['www.xn--85x722f.xn--55qx5d.cn', 'xn--85x722f.xn--55qx5d.cn', true, 'cn', true],
-      ['shishi.xn--55qx5d.cn', 'shishi.xn--55qx5d.cn', true, 'cn', true],
-      ['xn--55qx5d.cn', nil, false, 'cn', true],
-      ['xn--85x722f.xn--fiqs8s', 'xn--85x722f.xn--fiqs8s', true, 'xn--fiqs8s', true],
-      ['www.xn--85x722f.xn--fiqs8s', 'xn--85x722f.xn--fiqs8s', true, 'xn--fiqs8s', true],
-      ['shishi.xn--fiqs8s', 'shishi.xn--fiqs8s', true, 'xn--fiqs8s', true],
-      ['xn--fiqs8s', nil, false, 'xn--fiqs8s', true],
-    ].each { |hostname, domain, canonical, tld, canonical_tld|
-      dn = DomainName.new(hostname)
-      assert_equal(domain, dn.domain, hostname + ':domain')
-      assert_equal(canonical, dn.canonical?, hostname + ':canoninal?')
-      assert_equal(tld, dn.tld, hostname + ':tld')
-      assert_equal(canonical_tld, dn.canonical_tld?, hostname + ':canoninal_tld?')
-    }
-  end
-
-  test "compare hostnames correctly" do
-    [
-      ["foo.com", "abc.foo.com", 1],
-      ["COM", "abc.foo.com", 1],
-      ["abc.def.foo.com", "foo.com", -1],
-      ["abc.def.foo.com", "ABC.def.FOO.com", 0],
-      ["abc.def.foo.com", "bar.com", nil],
-    ].each { |x, y, v|
-      dx, dy = DomainName(x), DomainName(y)
-      [
-        [dx, y, v],
-        [dx, dy, v],
-        [dy, x, v ? -v : v],
-        [dy, dx, v ? -v : v],
-      ].each { |a, b, expected|
-        assert_equal expected, a <=> b
-        case expected
-        when 1
-          assert_equal(true,  a >  b)
-          assert_equal(true,  a >= b)
-          assert_equal(false, a == b)
-          assert_equal(false, a <= b)
-          assert_equal(false, a <  b)
-        when -1
-          assert_equal(true,  a <  b)
-          assert_equal(true,  a <= b)
-          assert_equal(false, a == b)
-          assert_equal(false, a >= b)
-          assert_equal(false, a >  b)
-        when 0
-          assert_equal(false, a <  b)
-          assert_equal(true,  a <= b)
-          assert_equal(true,  a == b)
-          assert_equal(true,  a >= b)
-          assert_equal(false, a >  b)
-        when nil
-          assert_equal(nil,   a <  b)
-          assert_equal(nil,   a <= b)
-          assert_equal(false, a == b)
-          assert_equal(nil,   a >= b)
-          assert_equal(nil,   a >  b)
-        end
-      }
-    }
-  end
-
-  test "check cookie domain correctly" do
-    {
-      'com' => [
-        ['com', false],
-        ['example.com', false],
-        ['foo.example.com', false],
-        ['bar.foo.example.com', false],
-      ],
-
-      'example.com' => [
-        ['com', false],
-        ['example.com', true],
-        ['foo.example.com', false],
-        ['bar.foo.example.com', false],
-      ],
-
-      'foo.example.com' => [
-        ['com', false],
-        ['example.com', true],
-        ['foo.example.com', true],
-        ['foo.Example.com', true],
-        ['bar.foo.example.com', false],
-        ['bar.Foo.Example.com', false],
-      ],
-
-      'b.sapporo.jp' => [
-        ['jp', false],
-        ['sapporo.jp', false],
-        ['b.sapporo.jp', false],
-        ['a.b.sapporo.jp', false],
-      ],
-
-      'b.c.sapporo.jp' => [
-        ['jp', false],
-        ['sapporo.jp', false],
-        ['c.sapporo.jp', false],
-        ['b.c.sapporo.jp', true],
-        ['a.b.c.sapporo.jp', false],
-      ],
-
-      'b.c.d.sapporo.jp' => [
-        ['jp', false],
-        ['sapporo.jp', false],
-        ['d.sapporo.jp', false],
-        ['c.d.sapporo.jp', true],
-        ['b.c.d.sapporo.jp', true],
-        ['a.b.c.d.sapporo.jp', false],
-      ],
-
-      'city.sapporo.jp' => [
-        ['jp', false],
-        ['sapporo.jp', false],
-        ['city.sapporo.jp', true],
-        ['a.city.sapporo.jp', false],
-      ],
-
-      'b.city.sapporo.jp' => [
-        ['jp', false],
-        ['sapporo.jp', false],
-        ['city.sapporo.jp', true],
-        ['b.city.sapporo.jp', true],
-        ['a.b.city.sapporo.jp', false],
-      ],
-    }.each_pair { |host, pairs|
-      dn = DomainName(host)
-      assert_equal(true, dn.cookie_domain?(host.upcase, true),     dn.to_s)
-      assert_equal(true, dn.cookie_domain?(host.downcase, true),   dn.to_s)
-      assert_equal(false, dn.cookie_domain?("www." << host, true), dn.to_s)
-      pairs.each { |domain, expected|
-        assert_equal(expected, dn.cookie_domain?(domain),             "%s - %s" % [dn.to_s, domain])
-        assert_equal(expected, dn.cookie_domain?(DomainName(domain)), "%s - %s" % [dn.to_s, domain])
-      }
-    }
-  end
-
-  test "parse IPv4 addresseses" do
-    a = '192.168.10.20'
-    dn = DomainName(a)
-    assert_equal(a, dn.hostname)
-    assert_equal(true, dn.ipaddr?)
-    assert_equal(IPAddr.new(a), dn.ipaddr)
-    assert_equal(true, dn.cookie_domain?(a))
-    assert_equal(true, dn.cookie_domain?(a, true))
-    assert_equal(true, dn.cookie_domain?(dn))
-    assert_equal(true, dn.cookie_domain?(dn, true))
-    assert_equal(false, dn.cookie_domain?('168.10.20'))
-    assert_equal(false, dn.cookie_domain?('20'))
-    assert_equal(nil, dn.superdomain)
-  end
-
-  test "parse IPv6 addresseses" do
-    a = '2001:200:dff:fff1:216:3eff:feb1:44d7'
-    b = '2001:0200:0dff:fff1:0216:3eff:feb1:44d7'
-    [b, b.upcase, "[#{b}]", "[#{b.upcase}]"].each { |host|
-      dn = DomainName(host)
-      assert_equal("[#{a}]", dn.uri_host)
-      assert_equal(a, dn.hostname)
-      assert_equal(true, dn.ipaddr?)
-      assert_equal(IPAddr.new(a), dn.ipaddr)
-      assert_equal(true, dn.cookie_domain?(host))
-      assert_equal(true, dn.cookie_domain?(host, true))
-      assert_equal(true, dn.cookie_domain?(dn))
-      assert_equal(true, dn.cookie_domain?(dn, true))
-      assert_equal(true, dn.cookie_domain?(a))
-      assert_equal(true, dn.cookie_domain?(a, true))
-      assert_equal(nil, dn.superdomain)
-    }
-  end
-
-  test "get superdomain" do
-    [
-      %w[www.sub.example.local sub.example.local example.local local],
-      %w[www.sub.example.com sub.example.com example.com com],
-    ].each { |domain, *superdomains|
-      dn = DomainName(domain)
-      superdomains.each { |superdomain|
-        sdn = DomainName(superdomain)
-        assert_equal sdn, dn.superdomain
-        dn = sdn
-      }
-      assert_equal nil, dn.superdomain
-    }
-  end
-
-  test "have idn methods" do
-    dn = DomainName("金八先生.B組.3年.日本語ドメイン名Example.日本")
-
-    assert_equal "xn--44q1cv48kq8x.xn--b-gf6c.xn--3-pj3b.xn--example-6q4fyliikhk162btq3b2zd4y2o.xn--wgv71a", dn.hostname
-    assert_equal "金八先生.b組.3年.日本語ドメイン名example.日本", dn.hostname_idn
-    assert_equal "xn--example-6q4fyliikhk162btq3b2zd4y2o.xn--wgv71a", dn.domain
-    assert_equal "日本語ドメイン名example.日本", dn.domain_idn
-    assert_equal "xn--wgv71a", dn.tld
-    assert_equal "日本", dn.tld_idn
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/domain_name-0.5.20190701/tool/gen_etld_data.rb

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'pathname'
-$basedir = Pathname.new(__FILE__).dirname.parent
-$LOAD_PATH.unshift $basedir + 'lib'
-require 'domain_name'
-require 'set'
-require 'erb'
-
-def main
-  dat_file = $basedir + 'data' + 'public_suffix_list.dat'
-  dir      = $basedir + 'lib' + 'domain_name'
-  erb_file = dir + 'etld_data.rb.erb'
-  rb_file  = dir + 'etld_data.rb'
-
-  etld_data_date = File.mtime(dat_file)
-
-  File.open(dat_file, 'r:utf-8') { |dat|
-    etld_data = parse(dat)
-    File.open(rb_file, 'w:utf-8') { |rb|
-      File.open(erb_file, 'r:utf-8') { |erb|
-        rb.print ERB.new(erb.read).result(binding)
-      }
-    }
-  }
-end
-
-def normalize_hostname(domain)
-  DomainName.normalize(domain)
-end
-
-def parse(f)
-  {}.tap { |table|
-    tlds = Set[]
-    f.each_line { |line|
-      line.sub!(%r{//.*}, '')
-      line.strip!
-      next if line.empty?
-      case line
-      when /^local$/
-        # ignore .local
-        next
-      when /^([^!*]+)$/
-        domain = normalize_hostname($1)
-        value = 0
-      when /^\*\.([^!*]+)$/
-        domain = normalize_hostname($1)
-        value = -1
-      when /^\!([^!*]+)$/
-        domain = normalize_hostname($1)
-        value = 1
-      else
-        raise "syntax error: #{line}"
-      end
-      tld = domain.match(/(?:^|\.)([^.]+)$/)[1]
-      table[tld] ||= 1
-      table[domain] = value
-    }
-  }
-end
-
-main()

data/vendor/bundle/ruby/2.7.0/gems/http-accept-1.7.0/.gitignore

@@ -1,9 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/

data/vendor/bundle/ruby/2.7.0/gems/http-accept-1.7.0/.rspec

@@ -1,4 +0,0 @@
---color
---format documentation
---backtrace
---warnings

data/vendor/bundle/ruby/2.7.0/gems/http-accept-1.7.0/.simplecov

@@ -1,9 +0,0 @@
-
-SimpleCov.start do
-	add_filter "/spec/"
-end
-
-if ENV['TRAVIS']
-	require 'coveralls'
-	Coveralls.wear!
-end

data/vendor/bundle/ruby/2.7.0/gems/http-accept-1.7.0/.travis.yml

@@ -1,5 +0,0 @@
-language: ruby
-sudo: false
-env: COVERAGE=true
-rvm:
-  - 2.3.0

data/vendor/bundle/ruby/2.7.0/gems/http-accept-1.7.0/Gemfile

@@ -1,9 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in http-accept.gemspec
-gemspec
-
-group :test do
-	gem 'simplecov'
-	gem 'coveralls', require: false
-end

data/vendor/bundle/ruby/2.7.0/gems/http-accept-1.7.0/README.md

@@ -1,137 +0,0 @@
-# HTTP::Accept
-
-Provides a robust set of parsers for dealing with HTTP `Accept`, `Accept-Language`, `Accept-Encoding`, `Accept-Charset` headers.
-
-[![Build Status](https://secure.travis-ci.org/ioquatix/http-accept.svg)](http://travis-ci.org/ioquatix/http-accept)
-[![Code Climate](https://codeclimate.com/github/ioquatix/http-accept.svg)](https://codeclimate.com/github/ioquatix/http-accept)
-[![Coverage Status](https://coveralls.io/repos/ioquatix/http-accept/badge.svg)](https://coveralls.io/r/ioquatix/http-accept)
-
-## Motivation
-
-I've been [developing some tools for building RESTful endpoints](https://github.com/ioquatix/utopia/blob/master/lib/utopia/controller/respond.rb) and part of that involved versioning. After reviewing the options, I settled on using the `Accept: application/json;version=1` method [as outlined here](http://labs.qandidate.com/blog/2014/10/16/using-the-accept-header-to-version-your-api/).
-
-The `version=1` part of the `media-type` is a `parameter` as defined by [RFC7231 Section 3.1.1.1](https://tools.ietf.org/html/rfc7231#section-3.1.1.1). After reviewing several existing different options for parsing the `Accept:` header, I noticed a disturbing trend: `header.split(',')`. Because parameters may contain quoted strings which contain commas, this is clearly not an appropriate way to parse the header.
-
-I am concerned about correctness, security and performance. As such, I implemented this gem to provide a simple high level interface for both parsing and correctly interpreting these headers.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'http-accept'
-```
-
-And then execute:
-
-	$ bundle
-
-Or install it yourself as:
-
-	$ gem install http-accept
-
-## Usage
-
-Here are some examples of how to parse various headers.
-
-### Parsing Accept: headers
-
-You can parse the incoming `Accept:` header:
-
-```ruby
-media_types = HTTP::Accept::MediaTypes.parse("text/html;q=0.5, application/json; version=1")
-
-expect(media_types[0].mime_type).to be == "application/json"
-expect(media_types[0].parameters).to be == {'version' => '1'}
-expect(media_types[1].mime_type).to be == "text/html"
-expect(media_types[1].parameters).to be == {'q' => '0.5'}
-```
-
-Normally, you'd want to match the media types against some set of available mime types:
-
-```ruby
-module ToJSON
-  def content_type
-    HTTP::Accept::ContentType.new("application/json", charset: 'utf-8')
-  end
-
-  # Used for inserting into map.
-  def split(*args)
-    content_type.split(*args)
-  end
-
-  def convert(object, options)
-    object.to_json
-  end
-end
-
-module ToXML
-  # Are you kidding?
-end
-
-map = HTTP::Accept::MediaTypes::Map.new
-map << ToJSON
-map << ToXML
-
-object, media_range = map.for(media_types)
-content = object.convert(model, media_range.parameters)
-response = [200, {'Content-Type' => object.content_type}, [content]]
-```
-
-### Parsing Accept-Language: headers
-
-You can parse the incoming `Accept-Language:` header:
-
-```ruby
-languages = HTTP::Accept::Languages.parse("da, en-gb;q=0.8, en;q=0.7")
-
-expect(languages[0].locale).to be == "da"
-expect(languages[1].locale).to be == "en-gb"
-expect(languages[2].locale).to be == "en"
-```
-
-Normally, you'd want to match the languages against some set of available localizations:
-
-```ruby
-available_localizations = HTTP::Accept::Languages::Locales.new(["en-nz", "en-us"])
-
-# Given the languages that the user wants, and the localizations available, compute the set of desired localizations.
-desired_localizations = available_localizations & languages
-```
-
-The `desired_localizations` in the example above is a subset of `available_localizations`.
-
-`HTTP::Accept::Languages::Locales` provides an efficient data-structure for matching the Accept-Languages header to set of available localizations according to https://tools.ietf.org/html/rfc7231#section-5.3.5 and https://tools.ietf.org/html/rfc4647#section-2.3
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-## License
-
-Released under the MIT license.
-
-Copyright, 2016, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams). 
-Copyright, 2016, by [Matthew Kerwin](http://kerwin.net.au).
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/vendor/bundle/ruby/2.7.0/gems/http-accept-1.7.0/Rakefile

@@ -1,8 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec) do |task|
-	task.rspec_opts = ["--require", "simplecov"] if ENV['COVERAGE']
-end
-
-task :default => :spec