vagrant-unbundled 2.2.18.0 → 2.2.19.0

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/test/server.rb

@@ -0,0 +1,106 @@
+require 'open4'
+require 'excon'
+require 'excon/test/plugin/server/webrick'
+require 'excon/test/plugin/server/unicorn'
+require 'excon/test/plugin/server/puma'
+require 'excon/test/plugin/server/exec'
+
+
+module Excon
+  module Test
+    class Server
+      attr_accessor :app, :server, :bind, :pid, :read, :write, :error, :started_at, :timeout
+
+      # Methods that must be implemented by a plugin
+      INSTANCE_REQUIRES = [:start]
+      Excon.defaults.merge!(
+        connect_timeout: 5,
+        read_timeout: 5,
+        write_timeout: 5
+      )
+
+      def initialize(args)
+        # TODO: Validate these args
+        @server = args.keys.first
+        @app = args[server]
+        args[:bind] ||= 'tcp://127.0.0.1:9292'
+        @bind = URI.parse(args[:bind])
+        @is_unix_socket = (@bind.scheme == 'unix')
+        @bind.host = @bind.host.gsub(/[\[\]]/, '') unless @is_unix_socket
+        if args[:timeout]
+          @timeout = args[:timeout]
+        else
+          @timeout = 20
+        end
+        name = @server.to_s.split('_').collect(&:capitalize).join
+        plug = nested_const_get("Excon::Test::Plugin::Server::#{name}")
+        self.extend plug
+        check_implementation(plug)
+      end
+
+      def open_process(*args)
+        if RUBY_PLATFORM == 'java'
+          @pid, @write, @read, @error = IO.popen4(*args)
+        else
+          GC.disable if RUBY_VERSION < '1.9'
+          @pid, @write, @read, @error = Open4.popen4(*args)
+        end
+        @started_at = Time.now
+      end
+
+      def elapsed_time
+        Time.now - started_at
+      end
+
+      def stop
+        if RUBY_PLATFORM == 'java'
+          Process.kill('USR1', pid)
+        else
+          Process.kill(9, pid)
+          GC.enable if RUBY_VERSION < '1.9'
+          Process.wait(pid)
+        end
+
+        if @is_unix_socket
+          socket = @bind.path
+          File.delete(socket) if File.exist?(socket)
+        end
+
+        # TODO: Ensure process is really dead
+        dump_errors
+        true
+      end
+      def dump_errors
+        lines = error.read.split($/)
+        while (line = lines.shift)
+          case line
+            when /(ERROR|Error)/
+              unless line =~ /(null cert chain|did not return a certificate|SSL_read:: internal error)/
+                in_err = true
+                puts
+              end
+            when /^(127|localhost)/
+              in_err = false
+            end
+          puts line if in_err
+        end
+      end
+
+      private
+
+      def nested_const_get(namespace)
+        namespace.split('::').inject(Object) do |mod, klass|
+          mod.const_get(klass)
+        end
+      end
+
+      def check_implementation(plug)
+        INSTANCE_REQUIRES.each do |m|
+          unless self.respond_to? m
+            raise "FATAL: #{plug} does not implement ##{m}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/unix_socket.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module Excon
+  class UnixSocket < Excon::Socket
+
+    private
+
+    def connect
+      @socket  = ::Socket.new(::Socket::AF_UNIX, ::Socket::SOCK_STREAM, 0)
+      # If a Unix proxy was specified, the :path option will be set for it,
+      # otherwise fall back to the :socket option.
+      proxy_path = @data[:proxy] ? @data[:proxy][:path] : nil
+      sockaddr = ::Socket.sockaddr_un(proxy_path || @data[:socket])
+      if @nonblock
+        begin
+          @socket.connect_nonblock(sockaddr)
+        rescue Errno::EINPROGRESS
+          unless IO.select(nil, [@socket], nil, @data[:connect_timeout])
+            raise(Excon::Errors::Timeout.new("connect timeout reached"))
+          end
+          begin
+            @socket.connect_nonblock(sockaddr)
+          rescue Errno::EISCONN
+            0 # same return as connect_nonblock success
+          end
+        end
+      else
+        begin
+          Timeout.timeout(@data[:connect_timeout]) do
+            @socket.connect(sockaddr)
+          end
+        rescue Timeout::Error
+          raise Excon::Errors::Timeout.new('connect timeout reached')
+        end
+      end
+
+    rescue => error
+      @socket.close rescue nil if @socket
+      raise error
+    end
+
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/utils.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+module Excon
+  module Utils
+    extend self
+
+    CONTROL   = (0x0..0x1f).map {|c| c.chr }.join + "\x7f"
+    DELIMS    = '<>#%"'
+    UNWISE    = '{}|\\^[]`'
+    NONASCII  = (0x80..0xff).map {|c| c.chr }.join
+    UNESCAPED = /([#{ Regexp.escape(CONTROL + ' ' + DELIMS + UNWISE + NONASCII) }])/
+    ESCAPED   = /%([0-9a-fA-F]{2})/
+
+    def binary_encode(string)
+      if FORCE_ENC && string.encoding != Encoding::ASCII_8BIT
+        if string.frozen?
+          string.dup.force_encoding('BINARY')
+        else
+          string.force_encoding('BINARY')
+        end
+      else
+        string
+      end
+    end
+
+    def connection_uri(datum = @data)
+      unless datum
+        raise ArgumentError, '`datum` must be given unless called on a Connection'
+      end
+      if datum[:scheme] == UNIX
+        "#{datum[:scheme]}://#{datum[:socket]}"
+      else
+        "#{datum[:scheme]}://#{datum[:host]}#{port_string(datum)}"
+      end
+    end
+
+    # Redact sensitive info from provided data
+    def redact(datum)
+      datum = datum.dup
+      if datum.has_key?(:headers)
+        if datum[:headers].has_key?('Authorization') || datum[:headers].has_key?('Proxy-Authorization')
+          datum[:headers] = datum[:headers].dup
+        end
+        if datum[:headers].has_key?('Authorization')
+          datum[:headers]['Authorization'] = REDACTED
+        end
+        if datum[:headers].has_key?('Proxy-Authorization')
+          datum[:headers]['Proxy-Authorization'] = REDACTED
+        end
+      end
+      if datum.has_key?(:password)
+        datum[:password] = REDACTED
+      end
+      if datum.has_key?(:proxy) && datum[:proxy] && datum[:proxy].has_key?(:password)
+        datum[:proxy] = datum[:proxy].dup
+        datum[:proxy][:password] = REDACTED
+      end
+      datum
+    end
+
+    def request_uri(datum)
+      connection_uri(datum) + datum[:path] + query_string(datum)
+    end
+
+    def port_string(datum)
+      if datum[:port].nil? || (datum[:omit_default_port] && ((datum[:scheme].casecmp('http') == 0 && datum[:port] == 80) || (datum[:scheme].casecmp('https') == 0 && datum[:port] == 443)))
+        ''
+      else
+        ':' + datum[:port].to_s
+      end
+    end
+
+    def query_string(datum)
+      str = String.new
+      case datum[:query]
+      when String
+        str << '?' << datum[:query]
+      when Hash
+        str << '?'
+        datum[:query].sort_by {|k,_| k.to_s }.each do |key, values|
+          key = CGI.escape(key.to_s)
+          if values.nil?
+            str << key << '&'
+          else
+            [values].flatten.each do |value|
+              str << key << '=' << CGI.escape(value.to_s) << '&'
+            end
+          end
+        end
+        str.chop! # remove trailing '&'
+      end
+      str
+    end
+
+    # Splits a header value +str+ according to HTTP specification.
+    def split_header_value(str)
+      return [] if str.nil?
+      str = str.dup.strip
+      str = binary_encode(str)
+      str.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",])+)
+                    (?:,\s*|\Z)'xn).flatten
+    end
+
+    # Escapes HTTP reserved and unwise characters in +str+
+    def escape_uri(str)
+      str = str.dup
+      str = binary_encode(str)
+      str.gsub(UNESCAPED) { "%%%02X" % $1[0].ord }
+    end
+
+    # Unescapes HTTP reserved and unwise characters in +str+
+    def unescape_uri(str)
+      str = str.dup
+      str = binary_encode(str)
+      str.gsub(ESCAPED) { $1.hex.chr }
+    end
+
+    # Unescape form encoded values in +str+
+    def unescape_form(str)
+      str = str.dup
+      str = binary_encode(str)
+      str.gsub!(/\+/, ' ')
+      str.gsub(ESCAPED) { $1.hex.chr }
+    end
+
+    # Performs validation on the passed header hash and returns a string representation of the headers
+    def headers_hash_to_s(headers)
+      headers_str = String.new
+      headers.each do |key, values|
+        if key.to_s.match(/[\r\n]/)
+          raise Excon::Errors::InvalidHeaderKey.new(key.to_s.inspect + ' contains forbidden "\r" or "\n"')
+        end
+        [values].flatten.each do |value|
+          if value.to_s.match(/[\r\n]/)
+            # Don't include the potentially sensitive header value (i.e. authorization token) in the message
+            raise Excon::Errors::InvalidHeaderValue.new(key.to_s + ' header value contains forbidden "\r" or "\n"')
+          end
+          headers_str << key.to_s << ': ' << value.to_s << CR_NL
+        end
+      end
+      headers_str
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Excon
+  VERSION = '0.89.0'
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'cgi'
+require 'forwardable'
+require 'openssl'
+require 'rbconfig'
+require 'socket'
+require 'timeout'
+require 'uri'
+require 'zlib'
+require 'stringio'
+
+require 'excon/version'
+
+require 'excon/extensions/uri'
+
+require 'excon/middlewares/base'
+require 'excon/middlewares/expects'
+require 'excon/middlewares/idempotent'
+require 'excon/middlewares/instrumentor'
+require 'excon/middlewares/mock'
+require 'excon/middlewares/response_parser'
+
+require 'excon/error'
+require 'excon/constants'
+require 'excon/utils'
+
+require 'excon/connection'
+require 'excon/headers'
+require 'excon/response'
+require 'excon/middlewares/decompress'
+require 'excon/middlewares/escape_path'
+require 'excon/middlewares/redirect_follower'
+require 'excon/middlewares/capture_cookies'
+require 'excon/pretty_printer'
+require 'excon/socket'
+require 'excon/ssl_socket'
+require 'excon/instrumentors/standard_instrumentor'
+require 'excon/instrumentors/logging_instrumentor'
+require 'excon/unix_socket'
+
+# Define defaults first so they will be available to other files
+module Excon
+  class << self
+
+    # @return [Hash] defaults for Excon connections
+    def defaults
+      @defaults ||= DEFAULTS
+    end
+
+    # Change defaults for Excon connections
+    # @return [Hash] defaults for Excon connections
+    def defaults=(new_defaults)
+      @defaults = new_defaults
+    end
+
+    def display_warning(warning)
+      # Show warning if $VERBOSE or ENV['EXCON_DEBUG'] is set
+      if $VERBOSE || ENV['EXCON_DEBUG']
+        $stderr.puts "[excon][WARNING] #{warning}\n#{ caller.join("\n") }"
+      end
+
+      if @raise_on_warnings
+        raise Error::Warning.new(warning)
+      end
+    end
+
+    def set_raise_on_warnings!(should_raise)
+      @raise_on_warnings = should_raise
+    end
+
+    # Status of mocking
+    def mock
+      display_warning('Excon#mock is deprecated, use Excon.defaults[:mock] instead.')
+      self.defaults[:mock]
+    end
+
+    # Change the status of mocking
+    # false is the default and works as expected
+    # true returns a value from stubs or raises
+    def mock=(new_mock)
+      display_warning('Excon#mock is deprecated, use Excon.defaults[:mock]= instead.')
+      self.defaults[:mock] = new_mock
+    end
+
+    # @return [String] The filesystem path to the SSL Certificate Authority
+    def ssl_ca_path
+      display_warning('Excon#ssl_ca_path is deprecated, use Excon.defaults[:ssl_ca_path] instead.')
+      self.defaults[:ssl_ca_path]
+    end
+
+    # Change path to the SSL Certificate Authority
+    # @return [String] The filesystem path to the SSL Certificate Authority
+    def ssl_ca_path=(new_ssl_ca_path)
+      display_warning('Excon#ssl_ca_path= is deprecated, use Excon.defaults[:ssl_ca_path]= instead.')
+      self.defaults[:ssl_ca_path] = new_ssl_ca_path
+    end
+
+    # @return [true, false] Whether or not to verify the peer's SSL certificate / chain
+    def ssl_verify_peer
+      display_warning('Excon#ssl_verify_peer is deprecated, use Excon.defaults[:ssl_verify_peer] instead.')
+      self.defaults[:ssl_verify_peer]
+    end
+
+    # Change the status of ssl peer verification
+    # @see Excon#ssl_verify_peer (attr_reader)
+    def ssl_verify_peer=(new_ssl_verify_peer)
+      display_warning('Excon#ssl_verify_peer= is deprecated, use Excon.defaults[:ssl_verify_peer]= instead.')
+      self.defaults[:ssl_verify_peer] = new_ssl_verify_peer
+    end
+
+    # @see Connection#initialize
+    # Initializes a new keep-alive session for a given remote host
+    # @param [String] url The destination URL
+    # @param [Hash<Symbol, >] params One or more option params to set on the Connection instance
+    # @return [Connection] A new Excon::Connection instance
+    def new(url, params = {})
+      uri_parser = params[:uri_parser] || defaults[:uri_parser]
+      uri = uri_parser.parse(url)
+      if params[:path]
+        uri_parser.parse(params[:path])
+      end
+      unless uri.scheme
+        raise ArgumentError.new("Invalid URI: #{uri}")
+      end
+      params = {
+        :host       => uri.host,
+        :hostname   => uri.hostname,
+        :path       => uri.path,
+        :port       => uri.port,
+        :query      => uri.query,
+        :scheme     => uri.scheme
+      }.merge(params)
+      if uri.password
+        params[:password] = Utils.unescape_uri(uri.password)
+      end
+      if uri.user
+        params[:user] = Utils.unescape_uri(uri.user)
+      end
+      Excon::Connection.new(params)
+    end
+
+    # push an additional stub onto the list to check for mock requests
+    # @param request_params [Hash<Symbol, >] request params to match against, omitted params match all
+    # @param response_params [Hash<Symbol, >] response params to return from matched request or block to call with params
+    def stub(request_params = {}, response_params = nil, &block)
+      if (method = request_params.delete(:method))
+        request_params[:method] = method.to_s.downcase.to_sym
+      end
+      if (url = request_params.delete(:url))
+        uri = URI.parse(url)
+        request_params = {
+          :host              => uri.host,
+          :path              => uri.path,
+          :port              => uri.port,
+          :query             => uri.query,
+          :scheme            => uri.scheme
+        }.merge!(request_params)
+        if uri.user || uri.password
+          request_params[:headers] ||= {}
+          user, pass = Utils.unescape_form(uri.user.to_s), Utils.unescape_form(uri.password.to_s)
+          request_params[:headers]['Authorization'] ||= 'Basic ' + ["#{user}:#{pass}"].pack('m').delete(Excon::CR_NL)
+        end
+      end
+      if request_params.has_key?(:headers)
+        headers = Excon::Headers.new
+        request_params[:headers].each do |key, value|
+          headers[key] = value
+        end
+        request_params[:headers] = headers
+      end
+      if block_given?
+        if response_params
+          raise(ArgumentError.new("stub requires either response_params OR a block"))
+        else
+          stub = [request_params, block]
+        end
+      elsif response_params
+        stub = [request_params, response_params]
+      else
+        raise(ArgumentError.new("stub requires either response_params OR a block"))
+      end
+      stubs.unshift(stub)
+      stub
+    end
+
+    # get a stub matching params or nil
+    # @param request_params [Hash<Symbol, >] request params to match against, omitted params match all
+    # @return [Hash<Symbol, >] response params to return from matched request or block to call with params
+    def stub_for(request_params={})
+      if (method = request_params.delete(:method))
+        request_params[:method] = method.to_s.downcase.to_sym
+      end
+      Excon.stubs.each do |stub, response_params|
+        captures = { :headers => {} }
+        headers_match = !stub.has_key?(:headers) || stub[:headers].keys.all? do |key|
+          case value = stub[:headers][key]
+          when Regexp
+            if (match = value.match(request_params[:headers][key]))
+              captures[:headers][key] = match.captures
+            end
+            match
+          else
+            value == request_params[:headers][key]
+          end
+        end
+        non_headers_match = (stub.keys - [:headers]).all? do |key|
+          case value = stub[key]
+          when Regexp
+            if (match = value.match(request_params[key]))
+              captures[key] = match.captures
+            end
+            match
+          else
+            value == request_params[key]
+          end
+        end
+        if headers_match && non_headers_match
+          request_params[:captures] = captures
+          return [stub, response_params]
+        end
+      end
+      nil
+    end
+
+    # get a list of defined stubs
+    def stubs
+      case Excon.defaults[:stubs]
+      when :global
+        @stubs ||= []
+      when :local
+        Thread.current[:_excon_stubs] ||= []
+      end
+    end
+
+    # remove first/oldest stub matching request_params
+    # @param request_params [Hash<Symbol, >] request params to match against, omitted params match all
+    # @return [Hash<Symbol, >] response params from deleted stub
+    def unstub(request_params = {})
+      stub = stub_for(request_params)
+      Excon.stubs.delete_at(Excon.stubs.index(stub))
+    end
+
+    # Generic non-persistent HTTP methods
+    HTTP_VERBS.each do |method|
+      module_eval <<-DEF, __FILE__, __LINE__ + 1
+        def #{method}(url, params = {}, &block)
+          new(url, params).request(:method => :#{method}, &block)
+        end
+      DEF
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/i18n-1.8.11/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 The Ruby I18n team
+
+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/3.0.0/gems/i18n-1.8.11/README.md

@@ -0,0 +1,122 @@
+# Ruby I18n
+
+[![Build Status](https://github.com/ruby-i18n/i18n/workflows/Ruby/badge.svg)](https://github.com/ruby-i18n/i18n/actions?query=workflow%3ARuby)
+
+Ruby internationalization and localization (i18n) solution.
+
+Currently maintained by @radar.
+
+## Usage
+
+### Rails
+
+You will most commonly use this library within a Rails app.
+
+[See the Rails Guide](https://guides.rubyonrails.org/i18n.html) for an example of its usage.
+
+### Ruby (without Rails)
+
+If you want to use this library without Rails, you can simply add `i18n` to your `Gemfile`:
+
+```ruby
+gem 'i18n'
+```
+
+Then configure I18n with some translations, and a default locale:
+
+```ruby
+I18n.load_path << Dir[File.expand_path("config/locales") + "/*.yml"]
+I18n.default_locale = :en # (note that `en` is already the default!)
+```
+
+A simple translation file in your project might live at `config/locales/en.yml` and look like:
+
+```yml
+en:
+  test: "This is a test"
+```
+
+You can then access this translation by doing:
+
+```ruby
+I18n.t(:test)
+```
+
+You can switch locales in your project by setting `I18n.locale` to a different value:
+
+```ruby
+I18n.locale = :de
+I18n.t(:test) # => "Dies ist ein Test"
+```
+
+## Features
+
+* Translation and localization
+* Interpolation of values to translations
+* Pluralization (CLDR compatible)
+* Customizable transliteration to ASCII
+* Flexible defaults
+* Bulk lookup
+* Lambdas as translation data
+* Custom key/scope separator
+* Custom exception handlers
+* Extensible architecture with a swappable backend
+
+## Pluggable Features
+
+* Cache
+* Pluralization: lambda pluralizers stored as translation data
+* Locale fallbacks, RFC4647 compliant (optionally: RFC4646 locale validation)
+* [Gettext support](https://github.com/ruby-i18n/i18n/wiki/Gettext)
+* Translation metadata
+
+## Alternative Backend
+
+* Chain
+* ActiveRecord (optionally: ActiveRecord::Missing and ActiveRecord::StoreProcs)
+* KeyValue (uses active_support/json and cannot store procs)
+
+For more information and lots of resources see [the 'Resources' page on the wiki](https://github.com/ruby-i18n/i18n/wiki/Resources).
+
+## Tests
+
+You can run tests both with
+
+* `rake test` or just `rake`
+* run any test file directly, e.g. `ruby -Ilib:test test/api/simple_test.rb`
+
+You can run all tests against all Gemfiles with
+
+* `ruby test/run_all.rb`
+
+The structure of the test suite is a bit unusual as it uses modules to reuse
+particular tests in different test cases.
+
+The reason for this is that we need to enforce the I18n API across various
+combinations of extensions. E.g. the Simple backend alone needs to support
+the same API as any combination of feature and/or optimization modules included
+to the Simple backend. We test this by reusing the same API definition (implemented
+as test methods) in test cases with different setups.
+
+You can find the test cases that enforce the API in test/api. And you can find
+the API definition test methods in test/api/tests.
+
+All other test cases (e.g. as defined in test/backend, test/core_ext) etc.
+follow the usual test setup and should be easy to grok.
+
+## More Documentation
+
+Additional documentation can be found here: https://github.com/ruby-i18n/i18n/wiki
+
+## Contributors
+
+* @radar
+* @carlosantoniodasilva
+* @josevalim
+* @knapo
+* @tigrish
+* [and many more](https://github.com/ruby-i18n/i18n/graphs/contributors)
+
+## License
+
+MIT License. See the included MIT-LICENSE file.