direct7 0.0.9 → 0.0.11

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/lib/http/request.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "base64"
+require "time"
+
+require "http/errors"
+require "http/headers"
+require "http/request/body"
+require "http/request/writer"
+require "http/version"
+require "http/uri"
+
+module HTTP
+  class Request
+    extend Forwardable
+
+    include HTTP::Headers::Mixin
+
+    # The method given was not understood
+    class UnsupportedMethodError < RequestError; end
+
+    # The scheme of given URI was not understood
+    class UnsupportedSchemeError < RequestError; end
+
+    # Default User-Agent header value
+    USER_AGENT = "http.rb/#{HTTP::VERSION}"
+
+    METHODS = [
+      # RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1
+      :options, :get, :head, :post, :put, :delete, :trace, :connect,
+
+      # RFC 2518: HTTP Extensions for Distributed Authoring -- WEBDAV
+      :propfind, :proppatch, :mkcol, :copy, :move, :lock, :unlock,
+
+      # RFC 3648: WebDAV Ordered Collections Protocol
+      :orderpatch,
+
+      # RFC 3744: WebDAV Access Control Protocol
+      :acl,
+
+      # RFC 6352: vCard Extensions to WebDAV -- CardDAV
+      :report,
+
+      # RFC 5789: PATCH Method for HTTP
+      :patch,
+
+      # draft-reschke-webdav-search: WebDAV Search
+      :search,
+
+      # RFC 4791: Calendaring Extensions to WebDAV -- CalDAV
+      :mkcalendar
+    ].freeze
+
+    # Allowed schemes
+    SCHEMES = %i[http https ws wss].freeze
+
+    # Default ports of supported schemes
+    PORTS = {
+      :http  => 80,
+      :https => 443,
+      :ws    => 80,
+      :wss   => 443
+    }.freeze
+
+    # Method is given as a lowercase symbol e.g. :get, :post
+    attr_reader :verb
+
+    # Scheme is normalized to be a lowercase symbol e.g. :http, :https
+    attr_reader :scheme
+
+    attr_reader :uri_normalizer
+
+    # "Request URI" as per RFC 2616
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html
+    attr_reader :uri
+    attr_reader :proxy, :body, :version
+
+    # @option opts [String] :version
+    # @option opts [#to_s] :verb HTTP request method
+    # @option opts [#call] :uri_normalizer (HTTP::URI::NORMALIZER)
+    # @option opts [HTTP::URI, #to_s] :uri
+    # @option opts [Hash] :headers
+    # @option opts [Hash] :proxy
+    # @option opts [String, Enumerable, IO, nil] :body
+    def initialize(opts)
+      @verb           = opts.fetch(:verb).to_s.downcase.to_sym
+      @uri_normalizer = opts[:uri_normalizer] || HTTP::URI::NORMALIZER
+
+      @uri    = @uri_normalizer.call(opts.fetch(:uri))
+      @scheme = @uri.scheme.to_s.downcase.to_sym if @uri.scheme
+
+      raise(UnsupportedMethodError, "unknown method: #{verb}") unless METHODS.include?(@verb)
+      raise(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
+
+      @proxy   = opts[:proxy] || {}
+      @version = opts[:version] || "1.1"
+      @headers = prepare_headers(opts[:headers])
+      @body    = prepare_body(opts[:body])
+    end
+
+    # Returns new Request with updated uri
+    def redirect(uri, verb = @verb)
+      headers = self.headers.dup
+      headers.delete(Headers::HOST)
+
+      new_body = body.source
+      if verb == :get
+        # request bodies should not always be resubmitted when following a redirect
+        # some servers will close the connection after receiving the request headers
+        # which may cause Errno::ECONNRESET: Connection reset by peer
+        # see https://github.com/httprb/http/issues/649
+        # new_body = Request::Body.new(nil)
+        new_body = nil
+        # the CONTENT_TYPE header causes problems if set on a get request w/ an empty body
+        # the server might assume that there should be content if it is set to multipart
+        # rack raises EmptyContentError if this happens
+        headers.delete(Headers::CONTENT_TYPE)
+      end
+
+      self.class.new(
+        :verb           => verb,
+        :uri            => @uri.join(uri),
+        :headers        => headers,
+        :proxy          => proxy,
+        :body           => new_body,
+        :version        => version,
+        :uri_normalizer => uri_normalizer
+      )
+    end
+
+    # Stream the request to a socket
+    def stream(socket)
+      include_proxy_headers if using_proxy? && !@uri.https?
+      Request::Writer.new(socket, body, headers, headline).stream
+    end
+
+    # Is this request using a proxy?
+    def using_proxy?
+      proxy && proxy.keys.size >= 2
+    end
+
+    # Is this request using an authenticated proxy?
+    def using_authenticated_proxy?
+      proxy && proxy.keys.size >= 4
+    end
+
+    def include_proxy_headers
+      headers.merge!(proxy[:proxy_headers]) if proxy.key?(:proxy_headers)
+      include_proxy_authorization_header if using_authenticated_proxy?
+    end
+
+    # Compute and add the Proxy-Authorization header
+    def include_proxy_authorization_header
+      headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header
+    end
+
+    def proxy_authorization_header
+      digest = Base64.strict_encode64("#{proxy[:proxy_username]}:#{proxy[:proxy_password]}")
+      "Basic #{digest}"
+    end
+
+    # Setup tunnel through proxy for SSL request
+    def connect_using_proxy(socket)
+      Request::Writer.new(socket, nil, proxy_connect_headers, proxy_connect_header).connect_through_proxy
+    end
+
+    # Compute HTTP request header for direct or proxy request
+    def headline
+      request_uri =
+        if using_proxy? && !uri.https?
+          uri.omit(:fragment)
+        else
+          uri.request_uri
+        end
+
+      "#{verb.to_s.upcase} #{request_uri} HTTP/#{version}"
+    end
+
+    # Compute HTTP request header SSL proxy connection
+    def proxy_connect_header
+      "CONNECT #{host}:#{port} HTTP/#{version}"
+    end
+
+    # Headers to send with proxy connect request
+    def proxy_connect_headers
+      connect_headers = HTTP::Headers.coerce(
+        Headers::HOST       => headers[Headers::HOST],
+        Headers::USER_AGENT => headers[Headers::USER_AGENT]
+      )
+
+      connect_headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header if using_authenticated_proxy?
+      connect_headers.merge!(proxy[:proxy_headers]) if proxy.key?(:proxy_headers)
+      connect_headers
+    end
+
+    # Host for tcp socket
+    def socket_host
+      using_proxy? ? proxy[:proxy_address] : host
+    end
+
+    # Port for tcp socket
+    def socket_port
+      using_proxy? ? proxy[:proxy_port] : port
+    end
+
+    # Human-readable representation of base request info.
+    #
+    # @example
+    #
+    #     req.inspect
+    #     # => #<HTTP::Request/1.1 GET https://example.com>
+    #
+    # @return [String]
+    def inspect
+      "#<#{self.class}/#{@version} #{verb.to_s.upcase} #{uri}>"
+    end
+
+    private
+
+    # @!attribute [r] host
+    #   @return [String]
+    def_delegator :@uri, :host
+
+    # @!attribute [r] port
+    #   @return [Fixnum]
+    def port
+      @uri.port || @uri.default_port
+    end
+
+    # @return [String] Default host (with port if needed) header value.
+    def default_host_header_value
+      PORTS[@scheme] == port ? host : "#{host}:#{port}"
+    end
+
+    def prepare_body(body)
+      body.is_a?(Request::Body) ? body : Request::Body.new(body)
+    end
+
+    def prepare_headers(headers)
+      headers = HTTP::Headers.coerce(headers || {})
+
+      headers[Headers::HOST]       ||= default_host_header_value
+      headers[Headers::USER_AGENT] ||= USER_AGENT
+
+      headers
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/lib/http/response/body.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "http/client"
+
+module HTTP
+  class Response
+    # A streamable response body, also easily converted into a string
+    class Body
+      extend Forwardable
+      include Enumerable
+      def_delegator :to_s, :empty?
+
+      # The connection object used to make the corresponding request.
+      #
+      # @return [HTTP::Connection]
+      attr_reader :connection
+
+      def initialize(stream, encoding: Encoding::BINARY)
+        @stream     = stream
+        @connection = stream.is_a?(Inflater) ? stream.connection : stream
+        @streaming  = nil
+        @contents   = nil
+        @encoding   = find_encoding(encoding)
+      end
+
+      # (see HTTP::Client#readpartial)
+      def readpartial(*args)
+        stream!
+        chunk = @stream.readpartial(*args)
+
+        String.new(chunk, :encoding => @encoding) if chunk
+      end
+
+      # Iterate over the body, allowing it to be enumerable
+      def each
+        while (chunk = readpartial)
+          yield chunk
+        end
+      end
+
+      # @return [String] eagerly consume the entire body as a string
+      def to_s
+        return @contents if @contents
+
+        raise StateError, "body is being streamed" unless @streaming.nil?
+
+        begin
+          @streaming  = false
+          @contents   = String.new("", :encoding => @encoding)
+
+          while (chunk = @stream.readpartial)
+            @contents << String.new(chunk, :encoding => @encoding)
+            chunk = nil # deallocate string
+          end
+        rescue
+          @contents = nil
+          raise
+        end
+
+        @contents
+      end
+      alias to_str to_s
+
+      # Assert that the body is actively being streamed
+      def stream!
+        raise StateError, "body has already been consumed" if @streaming == false
+
+        @streaming = true
+      end
+
+      # Easier to interpret string inspect
+      def inspect
+        "#<#{self.class}:#{object_id.to_s(16)} @streaming=#{!!@streaming}>"
+      end
+
+      private
+
+      # Retrieve encoding by name. If encoding cannot be found, default to binary.
+      def find_encoding(encoding)
+        Encoding.find encoding
+      rescue ArgumentError
+        Encoding::BINARY
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/lib/http/response/inflater.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module HTTP
+  class Response
+    class Inflater
+      attr_reader :connection
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def readpartial(*args)
+        chunk = @connection.readpartial(*args)
+        if chunk
+          chunk = zstream.inflate(chunk)
+        elsif !zstream.closed?
+          zstream.finish if zstream.total_in.positive?
+          zstream.close
+        end
+        chunk
+      end
+
+      private
+
+      def zstream
+        @zstream ||= Zlib::Inflate.new(32 + Zlib::MAX_WBITS)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/lib/http/response/parser.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "llhttp"
+
+module HTTP
+  class Response
+    # @api private
+    class Parser
+      attr_reader :parser, :headers, :status_code, :http_version
+
+      def initialize
+        @handler = Handler.new(self)
+        @parser = LLHttp::Parser.new(@handler, :type => :response)
+        reset
+      end
+
+      def reset
+        @parser.reset
+        @handler.reset
+        @header_finished = false
+        @message_finished = false
+        @headers = Headers.new
+        @chunk = nil
+        @status_code = nil
+        @http_version = nil
+      end
+
+      def add(data)
+        parser << data
+
+        self
+      rescue LLHttp::Error => e
+        raise IOError, e.message
+      end
+
+      alias << add
+
+      def mark_header_finished
+        @header_finished = true
+        @status_code = @parser.status_code
+        @http_version = "#{@parser.http_major}.#{@parser.http_minor}"
+      end
+
+      def headers?
+        @header_finished
+      end
+
+      def add_header(name, value)
+        @headers.add(name, value)
+      end
+
+      def mark_message_finished
+        @message_finished = true
+      end
+
+      def finished?
+        @message_finished
+      end
+
+      def add_body(chunk)
+        if @chunk
+          @chunk << chunk
+        else
+          @chunk = chunk
+        end
+      end
+
+      def read(size)
+        return if @chunk.nil?
+
+        if @chunk.bytesize <= size
+          chunk  = @chunk
+          @chunk = nil
+        else
+          chunk = @chunk.byteslice(0, size)
+          @chunk[0, size] = ""
+        end
+
+        chunk
+      end
+
+      class Handler < LLHttp::Delegate
+        def initialize(target)
+          @target = target
+          super()
+          reset
+        end
+
+        def reset
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
+
+        def on_header_field(field)
+          append_header if @reading_header_value
+          @field << field
+        end
+
+        def on_header_value(value)
+          @reading_header_value = true
+          @field_value << value
+        end
+
+        def on_headers_complete
+          append_header if @reading_header_value
+          @target.mark_header_finished
+        end
+
+        def on_body(body)
+          @target.add_body(body)
+        end
+
+        def on_message_complete
+          @target.mark_message_finished
+        end
+
+        private
+
+        def append_header
+          @target.add_header(@field, @field_value)
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/http-5.1.1/lib/http/response/status/reasons.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# AUTO-GENERATED FILE, DO NOT CHANGE IT MANUALLY
+
+require "delegate"
+
+module HTTP
+  class Response
+    class Status < ::Delegator
+      # Code to Reason map
+      #
+      # @example Usage
+      #
+      #   REASONS[400] # => "Bad Request"
+      #   REASONS[414] # => "Request-URI Too Long"
+      #
+      # @return [Hash<Fixnum => String>]
+      REASONS = {
+        100 => "Continue",
+        101 => "Switching Protocols",
+        102 => "Processing",
+        200 => "OK",
+        201 => "Created",
+        202 => "Accepted",
+        203 => "Non-Authoritative Information",
+        204 => "No Content",
+        205 => "Reset Content",
+        206 => "Partial Content",
+        207 => "Multi-Status",
+        208 => "Already Reported",
+        226 => "IM Used",
+        300 => "Multiple Choices",
+        301 => "Moved Permanently",
+        302 => "Found",
+        303 => "See Other",
+        304 => "Not Modified",
+        305 => "Use Proxy",
+        307 => "Temporary Redirect",
+        308 => "Permanent Redirect",
+        400 => "Bad Request",
+        401 => "Unauthorized",
+        402 => "Payment Required",
+        403 => "Forbidden",
+        404 => "Not Found",
+        405 => "Method Not Allowed",
+        406 => "Not Acceptable",
+        407 => "Proxy Authentication Required",
+        408 => "Request Timeout",
+        409 => "Conflict",
+        410 => "Gone",
+        411 => "Length Required",
+        412 => "Precondition Failed",
+        413 => "Payload Too Large",
+        414 => "URI Too Long",
+        415 => "Unsupported Media Type",
+        416 => "Range Not Satisfiable",
+        417 => "Expectation Failed",
+        421 => "Misdirected Request",
+        422 => "Unprocessable Entity",
+        423 => "Locked",
+        424 => "Failed Dependency",
+        426 => "Upgrade Required",
+        428 => "Precondition Required",
+        429 => "Too Many Requests",
+        431 => "Request Header Fields Too Large",
+        451 => "Unavailable For Legal Reasons",
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        502 => "Bad Gateway",
+        503 => "Service Unavailable",
+        504 => "Gateway Timeout",
+        505 => "HTTP Version Not Supported",
+        506 => "Variant Also Negotiates",
+        507 => "Insufficient Storage",
+        508 => "Loop Detected",
+        510 => "Not Extended",
+        511 => "Network Authentication Required"
+      }.each { |_, v| v.freeze }.freeze
+    end
+  end
+end