vagrant-unbundled 2.2.18.0 → 2.2.19.0

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Decompress < Excon::Middleware::Base
+
+      INFLATE_ZLIB_OR_GZIP  = 47 # Zlib::MAX_WBITS + 32
+      INFLATE_RAW           = -15 # Zlib::MAX_WBITS * -1
+
+      def request_call(datum)
+        unless datum.has_key?(:response_block)
+          key = datum[:headers].keys.detect {|k| k.to_s.casecmp('Accept-Encoding') == 0 } || 'Accept-Encoding'
+          if datum[:headers][key].to_s.empty?
+            datum[:headers][key] = 'deflate, gzip'
+          end
+        end
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        body = datum[:response][:body]
+        unless datum.has_key?(:response_block) || body.nil? || body.empty?
+          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Encoding') == 0 })
+            encodings = Utils.split_header_value(datum[:response][:headers][key])
+            if (encoding = encodings.last)
+              if encoding.casecmp('deflate') == 0
+                datum[:response][:body] = begin
+                  Zlib::Inflate.new(INFLATE_ZLIB_OR_GZIP).inflate(body)
+                rescue Zlib::DataError # fallback to raw on error
+                  Zlib::Inflate.new(INFLATE_RAW).inflate(body)
+                end
+                encodings.pop
+              elsif encoding.casecmp('gzip') == 0 || encoding.casecmp('x-gzip') == 0
+                datum[:response][:body] = Zlib::GzipReader.new(StringIO.new(body)).read
+                encodings.pop
+              end
+              datum[:response][:headers][key] = encodings.join(', ')
+            end
+          end
+        end
+        @stack.response_call(datum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class EscapePath < Excon::Middleware::Base
+      def request_call(datum)
+        # make sure path is encoded, prevent double encoding
+        datum[:path] = Excon::Utils.escape_uri(Excon::Utils.unescape_uri(datum[:path]))
+        @stack.request_call(datum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Expects < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :expects
+        ]
+      end
+
+      def response_call(datum)
+        if datum.has_key?(:expects) && ![*datum[:expects]].include?(datum[:response][:status])
+          raise(
+            Excon::Errors.status_error(
+              datum.reject {|key,_| key == :response},
+              Excon::Response.new(datum[:response])
+            )
+          )
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'set'
+
+module Excon
+  module Middleware
+    class Idempotent < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :idempotent,
+          :retries_remaining,
+          :retry_errors,
+          :retry_interval,
+          :retry_limit
+        ]
+      end
+
+      def request_call(datum)
+        datum[:retries_remaining] ||= datum[:retry_limit]
+        @stack.request_call(datum)
+      end
+
+      def error_call(datum)
+        if datum[:idempotent]
+          if datum.has_key?(:request_block)
+            if datum[:request_block].respond_to?(:rewind)
+              datum[:request_block].rewind
+            else
+              Excon.display_warning('Excon requests with a :request_block must implement #rewind in order to be :idempotent.')
+              datum[:idempotent] = false
+            end
+          end
+          if datum.has_key?(:response_block) && datum[:response_block].respond_to?(:rewind)
+            datum[:response_block].rewind
+          end
+          if datum.has_key?(:pipeline)
+            Excon.display_warning("Excon requests can not be :idempotent when pipelining.")
+            datum[:idempotent] = false
+          end
+        end
+
+        if datum[:idempotent] && datum[:retry_errors].any? {|ex| datum[:error].kind_of?(ex) } && datum[:retries_remaining] > 1
+
+          sleep(datum[:retry_interval]) if datum[:retry_interval]
+
+          # reduces remaining retries, reset connection, and restart request_call
+          datum[:retries_remaining] -= 1
+          connection = datum.delete(:connection)
+          valid_keys = Set.new(connection.valid_request_keys(datum[:middlewares]))
+          datum.select! {|key, _| valid_keys.include?(key) }
+          connection.request(datum)
+        else
+          @stack.error_call(datum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Instrumentor < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :logger,
+          :instrumentor,
+          :instrumentor_name
+        ]
+      end
+
+      def error_call(datum)
+        if datum.has_key?(:instrumentor)
+          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.error", :error => datum[:error]) do
+            @stack.error_call(datum)
+          end
+        else
+          @stack.error_call(datum)
+        end
+      end
+
+      def request_call(datum)
+        if datum.has_key?(:instrumentor)
+          if datum[:retries_remaining] < datum[:retry_limit]
+            event_name = "#{datum[:instrumentor_name]}.retry"
+          else
+            event_name = "#{datum[:instrumentor_name]}.request"
+          end
+          datum[:instrumentor].instrument(event_name, datum) do
+            @stack.request_call(datum)
+          end
+        else
+          @stack.request_call(datum)
+        end
+      end
+
+      def response_call(datum)
+        if datum.has_key?(:instrumentor)
+          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.response", datum[:response]) do
+            @stack.response_call(datum)
+          end
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Mock < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :allow_unstubbed_requests,
+          :captures,
+          :mock
+        ]
+      end
+
+      def request_call(datum)
+        if datum[:mock]
+          # convert File/Tempfile body to string before matching:
+          if datum[:body].respond_to?(:read)
+           if datum[:body].respond_to?(:binmode)
+             datum[:body].binmode
+           end
+           if datum[:body].respond_to?(:rewind)
+             datum[:body].rewind
+           end
+           datum[:body] = datum[:body].read
+          elsif !datum[:body].nil? && !datum[:body].is_a?(String)
+            raise Excon::Errors::InvalidStub.new("Request body should be a string or an IO object. #{datum[:body].class} provided")
+          end
+
+          if (stub = Excon.stub_for(datum))
+            datum[:remote_ip] ||= '127.0.0.1'
+            datum[:response] = {
+              :body       => '',
+              :headers    => {},
+              :status     => 200,
+              :remote_ip  => datum[:remote_ip]
+            }
+
+            stub_datum = case stub.last
+            when Proc
+              stub.last.call(datum)
+            else
+              stub.last
+            end
+
+            datum[:response].merge!(stub_datum.reject {|key,_| key == :headers})
+            if stub_datum.has_key?(:headers)
+              datum[:response][:headers].merge!(stub_datum[:headers])
+            end
+          elsif datum[:allow_unstubbed_requests] != true
+            # if we reach here no stubs matched
+            message = StringIO.new
+            message.puts('no stubs matched')
+            Excon::PrettyPrinter.pp(message, datum)
+            raise(Excon::Errors::StubNotFound.new(message.string))
+          end
+        end
+
+        @stack.request_call(datum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class RedirectFollower < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :redirects_remaining,
+          :redirect_limit
+        ]
+      end
+
+      def request_call(datum)
+        datum[:redirects_remaining] ||= datum[:redirect_limit] ||
+                                        Excon::DEFAULT_REDIRECT_LIMIT
+        @stack.request_call(datum)
+      end
+
+      def get_header(datum, header)
+        _, header_value = datum[:response][:headers].detect do |key, _|
+          key.casecmp(header) == 0
+        end
+        header_value
+      end
+
+      def response_call(datum)
+        if datum.has_key?(:response)
+          case datum[:response][:status]
+          when 301, 302, 303, 307, 308
+            if datum[:redirects_remaining] <= 0
+              raise Excon::Errors::TooManyRedirects
+            end
+
+            datum[:redirects_remaining] -= 1
+
+            uri_parser = datum[:uri_parser] || Excon.defaults[:uri_parser]
+
+            location = get_header(datum, 'Location')
+            base_uri = Excon::Utils.request_uri(datum)
+            uri = uri_parser.join(base_uri, location)
+
+            # delete old/redirect response and remote_ip
+            response = datum.delete(:response)
+            datum.delete(:remote_ip)
+
+            params = datum.dup
+            params.delete(:connection)
+            params.delete(:password)
+            params.delete(:stack)
+            params.delete(:user)
+
+            if [301, 302, 303].include?(response[:status])
+              params[:method] = :get
+              params.delete(:body)
+              params[:headers].delete('Content-Length')
+            end
+            params[:headers] = datum[:headers].dup
+            params[:headers].delete('Authorization')
+            params[:headers].delete('Proxy-Connection')
+            params[:headers].delete('Proxy-Authorization')
+            params[:headers].delete('Host')
+            params.merge!(
+              :scheme     => uri.scheme || datum[:scheme],
+              :host       => uri.host   || datum[:host],
+              :hostname   => uri.hostname || datum[:hostname],
+              :port       => uri.port   || datum[:port],
+              :path       => uri.path,
+              :query      => uri.query
+            )
+
+            params.merge!(:user => Utils.unescape_uri(uri.user)) if uri.user
+            params.merge!(:password => Utils.unescape_uri(uri.password)) if uri.password
+
+            response = Excon::Connection.new(params).request
+            datum.merge!({
+              :remote_ip  => response.remote_ip,
+              :response   => response.data
+            })
+          else
+            @stack.response_call(datum)
+          end
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class ResponseParser < Excon::Middleware::Base
+      def response_call(datum)
+        unless datum.has_key?(:response)
+          datum = Excon::Response.parse(datum[:connection].send(:socket), datum)
+        end
+        if datum.has_key?(:logger)
+          datum[:response][:logger] = datum[:logger]
+        end
+        @stack.response_call(datum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module Excon
+  class PrettyPrinter
+    def self.pp(io, datum, indent=0)
+      datum = datum.dup
+
+      # reduce duplication/noise of output
+      unless datum.is_a?(Excon::Headers)
+        datum.delete(:connection)
+        datum.delete(:stack)
+
+        datum = Utils.redact(datum)
+      end
+
+      indent += 2
+      max_key_length = datum.keys.map {|key| key.inspect.length}.max
+      datum.keys.sort_by {|key| key.to_s}.each do |key|
+        value = datum[key]
+        io.write("#{' ' * indent}#{key.inspect.ljust(max_key_length)} => ")
+        case value
+        when Array
+          io.puts("[")
+          value.each do |v|
+            io.puts("#{' ' * indent}  #{v.inspect}")
+          end
+          io.write("#{' ' * indent}]")
+        when Hash
+          io.puts("{")
+          self.pp(io, value, indent)
+          io.write("#{' ' * indent}}")
+        else
+          io.write("#{value.inspect}")
+        end
+        io.puts
+      end
+      indent -= 2
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+module Excon
+  class Response
+
+    attr_accessor :data
+
+    # backwards compatability reader/writers
+    def body=(new_body)
+      @data[:body] = new_body
+    end
+    def body
+      @data[:body]
+    end
+    def headers=(new_headers)
+      @data[:headers] = new_headers
+    end
+    def headers
+      @data[:headers]
+    end
+    def host
+      @data[:host]
+    end
+    def local_address
+      @data[:local_address]
+    end
+    def local_port
+      @data[:local_port]
+    end
+    def path
+      @data[:path]
+    end
+    def port
+      @data[:port]
+    end
+    def reason_phrase=(new_reason_phrase)
+      @data[:reason_phrase] = new_reason_phrase
+    end
+    def reason_phrase
+      @data[:reason_phrase]
+    end
+    def remote_ip=(new_remote_ip)
+      @data[:remote_ip] = new_remote_ip
+    end
+    def remote_ip
+      @data[:remote_ip]
+    end
+    def status=(new_status)
+      @data[:status] = new_status
+    end
+    def status
+      @data[:status]
+    end
+    def status_line
+      @data[:status_line]
+    end
+    def status_line=(new_status_line)
+      @data[:status_line] = new_status_line
+    end
+
+    def self.parse(socket, datum)
+      # this will discard any trailing lines from the previous response if any.
+      line = nil
+      loop do
+        line = socket.readline
+        break if line[9,3].to_i != 0
+      end
+
+      status = line[9, 3].to_i
+      reason_phrase = line[13..-3] # -3 strips the trailing "\r\n"
+
+      datum[:response] = {
+        :body          => String.new,
+        :cookies       => [],
+        :host          => datum[:host],
+        :headers       => Excon::Headers.new,
+        :path          => datum[:path],
+        :port          => datum[:port],
+        :status        => status,
+        :status_line   => line,
+        :reason_phrase => reason_phrase
+      }
+
+      unix_proxy = datum[:proxy] ? datum[:proxy][:scheme] == UNIX : false
+      unless datum[:scheme] == UNIX || unix_proxy
+        datum[:response].merge!(
+          :remote_ip     => socket.remote_ip,
+          :local_port    => socket.local_port,
+          :local_address => socket.local_address
+        )
+      end
+
+      parse_headers(socket, datum)
+
+      unless (['HEAD', 'CONNECT'].include?(datum[:method].to_s.upcase)) || NO_ENTITY.include?(datum[:response][:status])
+
+        if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Transfer-Encoding') == 0 })
+          encodings = Utils.split_header_value(datum[:response][:headers][key])
+          if (encoding = encodings.last) && encoding.casecmp('chunked') == 0
+            transfer_encoding_chunked = true
+            if encodings.length == 1
+              datum[:response][:headers].delete(key)
+            else
+              datum[:response][:headers][key] = encodings[0...-1].join(', ')
+            end
+          end
+        end
+
+        # use :response_block unless :expects would fail
+        if (response_block = datum[:response_block])
+          if datum[:middlewares].include?(Excon::Middleware::Expects) && datum[:expects] &&
+                                !Array(datum[:expects]).include?(datum[:response][:status])
+            response_block = nil
+          end
+        end
+
+        if transfer_encoding_chunked
+          if response_block
+            while (chunk_size = socket.readline.chomp!.to_i(16)) > 0
+              while chunk_size > 0
+                chunk = socket.read(chunk_size) || raise(EOFError)
+                chunk_size -= chunk.bytesize
+                response_block.call(chunk, nil, nil)
+              end
+              new_line_size = 2 # 2 == "\r\n".length
+              while new_line_size > 0
+                chunk = socket.read(new_line_size) || raise(EOFError)
+                new_line_size -= chunk.length
+              end
+            end
+          else
+            while (chunk_size = socket.readline.chomp!.to_i(16)) > 0
+              while chunk_size > 0
+                chunk = socket.read(chunk_size) || raise(EOFError)
+                chunk_size -= chunk.bytesize
+                datum[:response][:body] << chunk
+              end
+              new_line_size = 2 # 2 == "\r\n".length
+              while new_line_size > 0
+                chunk = socket.read(new_line_size) || raise(EOFError)
+                new_line_size -= chunk.length
+              end
+            end
+          end
+          parse_headers(socket, datum) # merge trailers into headers
+        else
+          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Length') == 0 })
+            content_length = datum[:response][:headers][key].to_i
+          end
+
+          if (remaining = content_length)
+            if response_block
+              while remaining > 0
+                chunk = socket.read([datum[:chunk_size], remaining].min) || raise(EOFError)
+                response_block.call(chunk, [remaining - chunk.bytesize, 0].max, content_length)
+                remaining -= chunk.bytesize
+              end
+            else
+              while remaining > 0
+                chunk = socket.read([datum[:chunk_size], remaining].min) || raise(EOFError)
+                datum[:response][:body] << chunk
+                remaining -= chunk.bytesize
+              end
+            end
+          else
+            if response_block
+              while (chunk = socket.read(datum[:chunk_size]))
+                response_block.call(chunk, nil, nil)
+              end
+            else
+              while (chunk = socket.read(datum[:chunk_size]))
+                datum[:response][:body] << chunk
+              end
+            end
+          end
+        end
+      end
+      datum
+    end
+
+    def self.parse_headers(socket, datum)
+      last_key = nil
+      until (data = socket.readline.chomp).empty?
+        if !data.lstrip!.nil?
+          raise Excon::Error::ResponseParse, 'malformed header' unless last_key
+          # append to last_key's last value
+          datum[:response][:headers][last_key] << ' ' << data.rstrip
+        else
+          key, value = data.split(':', 2)
+          raise Excon::Error::ResponseParse, 'malformed header' unless value
+          # add key/value or append value to existing values
+          datum[:response][:headers][key] = ([datum[:response][:headers][key]] << value.strip).compact.join(', ')
+          if key.casecmp('Set-Cookie') == 0
+            datum[:response][:cookies] << value.strip
+          end
+          last_key = key
+        end
+      end
+    end
+
+    def initialize(params={})
+      @data = {
+        :body     => ''
+      }.merge(params)
+      @data[:headers] = Excon::Headers.new.merge!(params[:headers] || {})
+
+      @body          = @data[:body]
+      @headers       = @data[:headers]
+      @status        = @data[:status]
+      @remote_ip     = @data[:remote_ip]
+      @local_port    = @data[:local_port]
+      @local_address = @data[:local_address]
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def params
+      Excon.display_warning('Excon::Response#params is deprecated use Excon::Response#data instead.')
+      data
+    end
+
+    def pp
+      Excon::PrettyPrinter.pp($stdout, @data)
+    end
+
+    # Retrieve a specific header value. Header names are treated case-insensitively.
+    # @param [String] name Header name
+    def get_header(name)
+      headers[name]
+    end
+
+  end # class Response
+end # module Excon