vagrant-unbundled 2.2.4.0 → 2.2.5.0

data/vendor/bundle/ruby/2.6.0/gems/domain_name-0.5.20190701/lib/domain_name/etld_data.rb.erb

@@ -0,0 +1,11 @@
+class DomainName
+  ETLD_DATA_DATE = '<%= etld_data_date.utc.strftime('%Y-%m-%dT%H:%M:%SZ') %>'
+
+  ETLD_DATA = {
+<% etld_data.each_pair { |key, value| %>    <%= key.inspect %> => <%= value.inspect %>,
+<% } %>  }
+
+  def self.etld_data
+    ETLD_DATA
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/domain_name-0.5.20190701/lib/domain_name/punycode.rb

@@ -0,0 +1,283 @@
+# -*- coding: utf-8 -*-
+#--
+# punycode.rb - PunyCode encoder for the Domain Name library
+#
+# Copyright (C) 2011-2017 Akinori MUSHA, All rights reserved.
+#
+# Ported from puny.c, a part of VeriSign XCode (encode/decode) IDN
+# Library.
+#
+# Copyright (C) 2000-2002 Verisign Inc., All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the following
+# conditions are met:
+#
+#  1) Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#
+#  2) Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in
+#     the documentation and/or other materials provided with the
+#     distribution.
+#
+#  3) Neither the name of the VeriSign Inc. nor the names of its
+#     contributors may be used to endorse or promote products derived
+#     from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# This software is licensed under the BSD open source license. For more
+# information visit www.opensource.org.
+#
+# Authors:
+#  John Colosi (VeriSign)
+#  Srikanth Veeramachaneni (VeriSign)
+#  Nagesh Chigurupati (Verisign)
+#  Praveen Srinivasan(Verisign)
+#++
+
+class DomainName
+  module Punycode
+    BASE = 36
+    TMIN = 1
+    TMAX = 26
+    SKEW = 38
+    DAMP = 700
+    INITIAL_BIAS = 72
+    INITIAL_N = 0x80
+    DELIMITER = '-'.freeze
+
+    MAXINT = (1 << 32) - 1
+
+    LOBASE = BASE - TMIN
+    CUTOFF = LOBASE * TMAX / 2
+
+    RE_NONBASIC = /[^\x00-\x7f]/
+
+    # Returns the numeric value of a basic code point (for use in
+    # representing integers) in the range 0 to base-1, or nil if cp
+    # is does not represent a value.
+    DECODE_DIGIT = {}.tap { |map|
+      # ASCII A..Z map to 0..25
+      # ASCII a..z map to 0..25
+      (0..25).each { |i| map[65 + i] = map[97 + i] = i }
+      # ASCII 0..9 map to 26..35
+      (26..35).each { |i| map[22 + i] = i }
+    }
+
+    # Returns the basic code point whose value (when used for
+    # representing integers) is d, which must be in the range 0 to
+    # BASE-1.  The lowercase form is used unless flag is true, in
+    # which case the uppercase form is used.  The behavior is
+    # undefined if flag is nonzero and digit d has no uppercase
+    # form.
+    ENCODE_DIGIT = proc { |d, flag|
+      (d + 22 + (d < 26 ? 75 : 0) - (flag ? (1 << 5) : 0)).chr
+      #  0..25 map to ASCII a..z or A..Z
+      # 26..35 map to ASCII 0..9
+    }
+
+    DOT = '.'.freeze
+    PREFIX = 'xn--'.freeze
+
+    # Most errors we raise are basically kind of ArgumentError.
+    class ArgumentError < ::ArgumentError; end
+    class BufferOverflowError < ArgumentError; end
+
+    class << self
+      # Encode a +string+ in Punycode
+      def encode(string)
+        input = string.unpack('U*')
+        output = ''
+
+        # Initialize the state
+        n = INITIAL_N
+        delta = 0
+        bias = INITIAL_BIAS
+
+        # Handle the basic code points
+        input.each { |cp| output << cp.chr if cp < 0x80 }
+
+        h = b = output.length
+
+        # h is the number of code points that have been handled, b is the
+        # number of basic code points, and out is the number of characters
+        # that have been output.
+
+        output << DELIMITER if b > 0
+
+        # Main encoding loop
+
+        while h < input.length
+          # All non-basic code points < n have been handled already.  Find
+          # the next larger one
+
+          m = MAXINT
+          input.each { |cp|
+            m = cp if (n...m) === cp
+          }
+
+          # Increase delta enough to advance the decoder's <n,i> state to
+          # <m,0>, but guard against overflow
+
+          delta += (m - n) * (h + 1)
+          raise BufferOverflowError if delta > MAXINT
+          n = m
+
+          input.each { |cp|
+            # AMC-ACE-Z can use this simplified version instead
+            if cp < n
+              delta += 1
+              raise BufferOverflowError if delta > MAXINT
+            elsif cp == n
+              # Represent delta as a generalized variable-length integer
+              q = delta
+              k = BASE
+              loop {
+                t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
+                break if q < t
+                q, r = (q - t).divmod(BASE - t)
+                output << ENCODE_DIGIT[t + r, false]
+                k += BASE
+              }
+
+              output << ENCODE_DIGIT[q, false]
+
+              # Adapt the bias
+              delta = h == b ? delta / DAMP : delta >> 1
+              delta += delta / (h + 1)
+              bias = 0
+              while delta > CUTOFF
+                delta /= LOBASE
+                bias += BASE
+              end
+              bias += (LOBASE + 1) * delta / (delta + SKEW)
+
+              delta = 0
+              h += 1
+            end
+          }
+
+          delta += 1
+          n += 1
+        end
+
+        output
+      end
+
+      # Encode a hostname using IDN/Punycode algorithms
+      def encode_hostname(hostname)
+        hostname.match(RE_NONBASIC) or return hostname
+
+        hostname.split(DOT).map { |name|
+          if name.match(RE_NONBASIC)
+            PREFIX + encode(name)
+          else
+            name
+          end
+        }.join(DOT)
+      end
+
+      # Decode a +string+ encoded in Punycode
+      def decode(string)
+        # Initialize the state
+        n = INITIAL_N
+        i = 0
+        bias = INITIAL_BIAS
+
+        if j = string.rindex(DELIMITER)
+          b = string[0...j]
+
+          b.match(RE_NONBASIC) and
+            raise ArgumentError, "Illegal character is found in basic part: #{string.inspect}"
+
+          # Handle the basic code points
+
+          output = b.unpack('U*')
+          u = string[(j + 1)..-1]
+        else
+          output = []
+          u = string
+        end
+
+        # Main decoding loop: Start just after the last delimiter if any
+        # basic code points were copied; start at the beginning
+        # otherwise.
+
+        input = u.unpack('C*')
+        input_length = input.length
+        h = 0
+        out = output.length
+
+        while h < input_length
+          # Decode a generalized variable-length integer into delta,
+          # which gets added to i.  The overflow checking is easier
+          # if we increase i as we go, then subtract off its starting
+          # value at the end to obtain delta.
+
+          oldi = i
+          w = 1
+          k = BASE
+
+          loop {
+            digit = DECODE_DIGIT[input[h]] or
+            raise ArgumentError, "Illegal character is found in non-basic part: #{string.inspect}"
+            h += 1
+            i += digit * w
+            raise BufferOverflowError if i > MAXINT
+            t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
+            break if digit < t
+            w *= BASE - t
+            raise BufferOverflowError if w > MAXINT
+            k += BASE
+            h < input_length or raise ArgumentError, "Malformed input given: #{string.inspect}"
+          }
+
+          # Adapt the bias
+          delta = oldi == 0 ? i / DAMP : (i - oldi) >> 1
+          delta += delta / (out + 1)
+          bias = 0
+          while delta > CUTOFF
+            delta /= LOBASE
+            bias += BASE
+          end
+          bias += (LOBASE + 1) * delta / (delta + SKEW)
+
+          # i was supposed to wrap around from out+1 to 0, incrementing
+          # n each time, so we'll fix that now:
+
+          q, i = i.divmod(out + 1)
+          n += q
+          raise BufferOverflowError if n > MAXINT
+
+          # Insert n at position i of the output:
+
+          output[i, 0] = n
+
+          out += 1
+          i += 1
+        end
+        output.pack('U*')
+      end
+
+      # Decode a hostname using IDN/Punycode algorithms
+      def decode_hostname(hostname)
+        hostname.gsub(/(\A|#{Regexp.quote(DOT)})#{Regexp.quote(PREFIX)}([^#{Regexp.quote(DOT)}]*)/o) {
+          $1 << decode($2)
+        }
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/domain_name-0.5.20190701/lib/domain_name/version.rb

@@ -0,0 +1,3 @@
+class DomainName
+  VERSION = '0.5.20190701'
+end

data/vendor/bundle/ruby/2.6.0/gems/domain_name-0.5.20190701/lib/domain_name.rb

@@ -0,0 +1,297 @@
+# -*- coding: utf-8 -*-
+#
+# domain_name.rb - Domain Name manipulation library for Ruby
+#
+# Copyright (C) 2011-2017 Akinori MUSHA, All rights reserved.
+#
+
+require 'domain_name/version'
+require 'domain_name/punycode'
+require 'domain_name/etld_data'
+require 'unf'
+require 'ipaddr'
+
+# Represents a domain name ready for extracting its registered domain
+# and TLD.
+class DomainName
+  # The full host name normalized, ASCII-ized and downcased using the
+  # Unicode NFC rules and the Punycode algorithm.  If initialized with
+  # an IP address, the string representation of the IP address
+  # suitable for opening a connection to.
+  attr_reader :hostname
+
+  # The Unicode representation of the #hostname property.
+  #
+  # :attr_reader: hostname_idn
+
+  # The least "universally original" domain part of this domain name.
+  # For example, "example.co.uk" for "www.sub.example.co.uk".  This
+  # may be nil if the hostname does not have one, like when it is an
+  # IP address, an effective TLD or higher itself, or of a
+  # non-canonical domain.
+  attr_reader :domain
+
+  # The Unicode representation of the #domain property.
+  #
+  # :attr_reader: domain_idn
+
+  # The TLD part of this domain name.  For example, if the hostname is
+  # "www.sub.example.co.uk", the TLD part is "uk".  This property is
+  # nil only if +ipaddr?+ is true.  This may be nil if the hostname
+  # does not have one, like when it is an IP address or of a
+  # non-canonical domain.
+  attr_reader :tld
+
+  # The Unicode representation of the #tld property.
+  #
+  # :attr_reader: tld_idn
+
+  # Returns an IPAddr object if this is an IP address.
+  attr_reader :ipaddr
+
+  # Returns true if this is an IP address, such as "192.168.0.1" and
+  # "[::1]".
+  def ipaddr?
+    @ipaddr ? true : false
+  end
+
+  # Returns a host name representation suitable for use in the host
+  # name part of a URI.  A host name, an IPv4 address, or a IPv6
+  # address enclosed in square brackets.
+  attr_reader :uri_host
+
+  # Returns true if this domain name has a canonical TLD.
+  def canonical_tld?
+    @canonical_tld_p
+  end
+
+  # Returns true if this domain name has a canonical registered
+  # domain.
+  def canonical?
+    @canonical_tld_p && (@domain ? true : false)
+  end
+
+  DOT = '.'.freeze	# :nodoc:
+
+  # Parses _hostname_ into a DomainName object.  An IP address is also
+  # accepted.  An IPv6 address may be enclosed in square brackets.
+  def initialize(hostname)
+    hostname.is_a?(String) or
+      (hostname.respond_to?(:to_str) && (hostname = hostname.to_str).is_a?(String)) or
+      raise TypeError, "#{hostname.class} is not a String"
+    if hostname.start_with?(DOT)
+      raise ArgumentError, "domain name must not start with a dot: #{hostname}"
+    end
+    case hostname
+    when /\A([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)\z/
+      @ipaddr = IPAddr.new($1)
+      @uri_host = @hostname = @ipaddr.to_s
+      @domain = @tld = nil
+      return
+    when /\A([0-9A-Fa-f:]*:[0-9A-Fa-f:]*:[0-9A-Fa-f:]*)\z/,
+      /\A\[([0-9A-Fa-f:]*:[0-9A-Fa-f:]*:[0-9A-Fa-f:]*)\]\z/
+      @ipaddr = IPAddr.new($1)
+      @hostname = @ipaddr.to_s
+      @uri_host = "[#{@hostname}]"
+      @domain = @tld = nil
+      return
+    end
+    @ipaddr = nil
+    @hostname = DomainName.normalize(hostname)
+    @uri_host = @hostname
+    if last_dot = @hostname.rindex(DOT)
+      @tld = @hostname[(last_dot + 1)..-1]
+    else
+      @tld = @hostname
+    end
+    etld_data = DomainName.etld_data
+    if @canonical_tld_p = etld_data.key?(@tld)
+      subdomain = domain = nil
+      parent = @hostname
+      loop {
+        case etld_data[parent]
+        when 0
+          @domain = domain
+          return
+        when -1
+          @domain = subdomain
+          return
+        when 1
+          @domain = parent
+          return
+        end
+        subdomain = domain
+        domain = parent
+        pos = @hostname.index(DOT, -domain.length) or break
+        parent = @hostname[(pos + 1)..-1]
+      }
+    else
+      # unknown/local TLD
+      if last_dot
+        # fallback - accept cookies down to second level
+        # cf. http://www.dkim-reputation.org/regdom-libs/
+        if penultimate_dot = @hostname.rindex(DOT, last_dot - 1)
+          @domain = @hostname[(penultimate_dot + 1)..-1]
+        else
+          @domain = @hostname
+        end
+      else
+        # no domain part - must be a local hostname
+        @domain = @tld
+      end
+    end
+  end
+
+  # Checks if the server represented by this domain is qualified to
+  # send and receive cookies with a domain attribute value of
+  # _domain_.  A true value given as the second argument represents
+  # cookies without a domain attribute value, in which case only
+  # hostname equality is checked.
+  def cookie_domain?(domain, host_only = false)
+    # RFC 6265 #5.3
+    # When the user agent "receives a cookie":
+    return self == domain if host_only
+
+    domain = DomainName.new(domain) unless DomainName === domain
+    if ipaddr?
+      # RFC 6265 #5.1.3
+      # Do not perform subdomain matching against IP addresses.
+      @hostname == domain.hostname
+    else
+      # RFC 6265 #4.1.1
+      # Domain-value must be a subdomain.
+      @domain && self <= domain && domain <= @domain ? true : false
+    end
+  end
+
+  # Returns the superdomain of this domain name.
+  def superdomain
+    return nil if ipaddr?
+    pos = @hostname.index(DOT) or return nil
+    self.class.new(@hostname[(pos + 1)..-1])
+  end
+
+  def ==(other)
+    other = DomainName.new(other) unless DomainName === other
+    other.hostname == @hostname
+  end
+
+  def <=>(other)
+    other = DomainName.new(other) unless DomainName === other
+    othername = other.hostname
+    if othername == @hostname
+      0
+    elsif @hostname.end_with?(othername) && @hostname[-othername.size - 1, 1] == DOT
+      # The other is higher
+      -1
+    elsif othername.end_with?(@hostname) && othername[-@hostname.size - 1, 1] == DOT
+      # The other is lower
+      1
+    else
+      nil
+    end
+  end
+
+  def <(other)
+    case self <=> other
+    when -1
+      true
+    when nil
+      nil
+    else
+      false
+    end
+  end
+
+  def >(other)
+    case self <=> other
+    when 1
+      true
+    when nil
+      nil
+    else
+      false
+    end
+  end
+
+  def <=(other)
+    case self <=> other
+    when -1, 0
+      true
+    when nil
+      nil
+    else
+      false
+    end
+  end
+
+  def >=(other)
+    case self <=> other
+    when 1, 0
+      true
+    when nil
+      nil
+    else
+      false
+    end
+  end
+
+  def to_s
+    @hostname
+  end
+
+  alias to_str to_s
+
+  def hostname_idn
+    @hostname_idn ||=
+      if @ipaddr
+        @hostname
+      else
+        DomainName::Punycode.decode_hostname(@hostname)
+      end
+  end
+
+  alias idn hostname_idn
+
+  def domain_idn
+    @domain_idn ||=
+      if @ipaddr
+        @domain
+      else
+        DomainName::Punycode.decode_hostname(@domain)
+      end
+  end
+
+  def tld_idn
+    @tld_idn ||=
+      if @ipaddr
+        @tld
+      else
+        DomainName::Punycode.decode_hostname(@tld)
+      end
+  end
+
+  def inspect
+    str = '#<%s:%s' % [self.class.name, @hostname]
+    if @ipaddr
+      str << ' (ipaddr)'
+    else
+      str << ' domain=' << @domain if @domain
+      str << ' tld=' << @tld if @tld
+    end
+    str << '>'
+  end
+
+  class << self
+    # Normalizes a _domain_ using the Punycode algorithm as necessary.
+    # The result will be a downcased, ASCII-only string.
+    def normalize(domain)
+      DomainName::Punycode.encode_hostname(domain.chomp(DOT).to_nfc).downcase
+    end
+  end
+end
+
+# Short hand for DomainName.new().
+def DomainName(hostname)
+  DomainName.new(hostname)
+end

data/vendor/bundle/ruby/2.6.0/gems/domain_name-0.5.20190701/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'domain_name'
+
+class Test::Unit::TestCase
+end