httpx 0.0.1

data/lib/httpx/plugins/compression/brotli.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Compression
+      module Brotli
+        def self.load_dependencies(klass, *)
+          klass.plugin(:compression)
+          require "brotli"
+        end
+
+        def self.configure(*)
+          Compression.register "br", self
+        end
+
+        module Encoder
+          module_function
+
+          def deflate(raw, buffer, chunk_size:)
+            while (chunk = raw.read(chunk_size))
+              compressed = ::Brotli.deflate(chunk)
+              buffer << compressed
+              yield compressed if block_given?
+            end
+          end
+        end
+
+        module BrotliWrapper
+          module_function
+
+          def inflate(text)
+            ::Brotli.inflate(text)
+          end
+
+          def close; end
+
+          def finish
+            ""
+          end
+        end
+
+        module_function
+
+        def encoder
+          Encoder
+        end
+
+        def decoder
+          Decoder.new(BrotliWrapper)
+        end
+      end
+    end
+    register_plugin :"compression/brotli", Compression::Brotli
+  end
+end

data/lib/httpx/plugins/compression/deflate.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Compression
+      module Deflate
+        def self.load_dependencies(*)
+          require "stringio"
+          require "zlib"
+        end
+
+        def self.configure(*)
+          Compression.register "deflate", self
+        end
+
+        module Encoder
+          module_function
+
+          def deflate(raw, buffer, chunk_size:)
+            deflater = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
+                                         Zlib::MAX_WBITS,
+                                         Zlib::MAX_MEM_LEVEL,
+                                         Zlib::HUFFMAN_ONLY)
+            while (chunk = raw.read(chunk_size))
+              compressed = deflater.deflate(chunk)
+              buffer << compressed
+              yield compressed if block_given?
+            end
+            last = deflater.finish
+            buffer << last
+            yield last if block_given?
+          ensure
+            deflater.close
+          end
+        end
+
+        module_function
+
+        def encoder
+          Encoder
+        end
+
+        def decoder
+          Decoder.new(Zlib::Inflate.new(32 + Zlib::MAX_WBITS))
+        end
+      end
+    end
+    register_plugin :"compression/deflate", Compression::Deflate
+  end
+end

data/lib/httpx/plugins/compression/gzip.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX
+  module Plugins
+    module Compression
+      module GZIP
+        def self.load_dependencies(*)
+          require "zlib"
+        end
+
+        def self.configure(*)
+          Compression.register "gzip", self
+        end
+
+        class Encoder
+          def deflate(raw, buffer, chunk_size:)
+            gzip = Zlib::GzipWriter.new(self)
+
+            while (chunk = raw.read(chunk_size))
+              gzip.write(chunk)
+              gzip.flush
+              compressed = compressed_chunk
+              buffer << compressed
+              yield compressed if block_given?
+            end
+          ensure
+            gzip.close
+          end
+
+          private
+
+          def write(chunk)
+            @compressed_chunk = chunk
+          end
+
+          def compressed_chunk
+            compressed = @compressed_chunk
+            compressed
+          ensure
+            @compressed_chunk = nil
+          end
+        end
+
+        module_function
+
+        def encoder
+          Encoder.new
+        end
+
+        def decoder
+          Decoder.new(Zlib::Inflate.new(32 + Zlib::MAX_WBITS))
+        end
+      end
+    end
+    register_plugin :"compression/gzip", Compression::GZIP
+  end
+end

data/lib/httpx/plugins/cookies.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Cookies
+      def self.load_dependencies(*)
+        require "http/cookie"
+      end
+
+      module InstanceMethods
+        def cookies(cookies)
+          branch(default_options.with_cookies(cookies))
+        end
+      end
+
+      module RequestMethods
+        def initialize(*)
+          super
+          @headers.cookies(@options.cookies, self)
+        end
+      end
+
+      module HeadersMethods
+        def cookies(jar, request)
+          return unless jar
+          unless jar.is_a?(HTTP::CookieJar)
+            jar = jar.each_with_object(HTTP::CookieJar.new) do |(k, v), j|
+              cookie = k.is_a?(HTTP::Cookie) ? v : HTTP::Cookie.new(k.to_s, v.to_s)
+              cookie.domain = request.authority
+              cookie.path = request.path
+              j.add(cookie)
+            end
+          end
+          self["cookie"] = HTTP::Cookie.cookie_value(jar.cookies)
+        end
+      end
+
+      module ResponseMethods
+        def cookie_jar
+          return @cookies if defined?(@cookies)
+          return nil unless headers.key?("set-cookie")
+          @cookies ||= begin
+            jar = HTTP::CookieJar.new
+            jar.parse(headers["set-cookie"], @request.uri)
+            jar
+          end
+        end
+        alias_method :cookies, :cookie_jar
+      end
+
+      module OptionsMethods
+        def self.included(klass)
+          super
+          klass.def_option(:cookies) do |cookies|
+            cookies.split(/ *; */) if cookies.is_a?(String)
+            cookies
+          end
+        end
+      end
+    end
+    register_plugin :cookies, Cookies
+  end
+end

data/lib/httpx/plugins/digest_authentication.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module DigestAuthentication
+      DigestError = Class.new(Error)
+
+      def self.load_dependencies(*)
+        require "securerandom"
+        require "digest"
+      end
+
+      module InstanceMethods
+        def digest_authentication(user, password)
+          @_digest = Digest.new(user, password)
+          self
+        end
+        alias_method :digest_auth, :digest_authentication
+
+        def request(*args, keep_open: @keep_open, **options)
+          return super unless @_digest
+          begin
+            requests = __build_reqs(*args, **options)
+            probe_request = requests.first
+            prev_response = __send_reqs(*probe_request).first
+
+            unless prev_response.status == 401
+              raise Error, "request doesn't require authentication (status: #{prev_response})"
+            end
+
+            probe_request.transition(:idle)
+            responses = []
+
+            requests.each do |request|
+              token = @_digest.generate_header(request, prev_response)
+              request.headers["authorization"] = "Digest #{token}"
+              response = __send_reqs(*request).first
+              responses << response
+              prev_response = response
+            end
+            return responses.first if responses.size == 1
+            responses
+          ensure
+            close unless keep_open
+          end
+        end
+      end
+
+      class Digest
+        def initialize(user, password)
+          @user = user
+          @password = password
+          @nonce = 0
+        end
+
+        def generate_header(request, response, _iis = false)
+          method = request.verb.to_s.upcase
+          www = response.headers["www-authenticate"]
+
+          # TODO: assert if auth-type is Digest
+          auth_info = www[/^(\w+) (.*)/, 2]
+
+          uri = request.path
+
+          params = Hash[auth_info.scan(/(\w+)="(.*?)"/)]
+
+          nonce = params["nonce"]
+          nc = next_nonce
+
+          # verify qop
+          qop = params["qop"]
+
+          if params["algorithm"] =~ /(.*?)(-sess)?$/
+            algorithm = case Regexp.last_match(1)
+                        when "MD5"    then ::Digest::MD5
+                        when "SHA1"   then ::Digest::SHA1
+                        when "SHA2"   then ::Digest::SHA2
+                        when "SHA256" then ::Digest::SHA256
+                        when "SHA384" then ::Digest::SHA384
+                        when "SHA512" then ::Digest::SHA512
+                        when "RMD160" then ::Digest::RMD160
+                        else raise DigestError, "unknown algorithm \"#{Regexp.last_match(1)}\""
+            end
+            sess = Regexp.last_match(2)
+          else
+            algorithm = ::Digest::MD5
+          end
+
+          if qop || sess
+            cnonce = make_cnonce
+            nc = format("%08x", nc)
+          end
+
+          a1 = if sess
+            [algorithm.hexdigest("#{@user}:#{params["realm"]}:#{@password}"),
+             nonce,
+             cnonce].join ":"
+          else
+            "#{@user}:#{params["realm"]}:#{@password}"
+          end
+
+          ha1 = algorithm.hexdigest(a1)
+          ha2 = algorithm.hexdigest("#{method}:#{uri}")
+          request_digest = [ha1, nonce]
+          request_digest.push(nc, cnonce, qop) if qop
+          request_digest << ha2
+          request_digest = request_digest.join(":")
+
+          header = [
+            %(username="#{@user}"),
+            %(nonce="#{nonce}"),
+            %(uri="#{uri}"),
+            %(response="#{algorithm.hexdigest(request_digest)}"),
+          ]
+          header << %(realm="#{params["realm"]}") if params.key?("realm")
+          header << %(algorithm=#{params["algorithm"]}") if params.key?("algorithm")
+          header << %(opaque="#{params["opaque"]}") if params.key?("opaque")
+          header << %(cnonce="#{cnonce}") if cnonce
+          header << %(nc=#{nc})
+          header << %(qop=#{qop}) if qop
+          header.join ", "
+        end
+
+        private
+
+        def make_cnonce
+          ::Digest::MD5.hexdigest [
+            Time.now.to_i,
+            Process.pid,
+            SecureRandom.random_number(2**32),
+          ].join ":"
+        end
+
+        def next_nonce
+          @nonce += 1
+        end
+      end
+    end
+    register_plugin :digest_authentication, DigestAuthentication
+  end
+end

data/lib/httpx/plugins/follow_redirects.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module FollowRedirects
+      module InstanceMethods
+        MAX_REDIRECTS = 3
+        REDIRECT_STATUS = 300..399
+
+        def max_redirects(n)
+          branch(default_options.with_max_redirects(n.to_i))
+        end
+
+        def request(*args, **options)
+          # do not needlessly close channels
+          keep_open = @keep_open
+          @keep_open = true
+
+          max_redirects = @options.max_redirects || MAX_REDIRECTS
+          requests = __build_reqs(*args, **options)
+          responses = __send_reqs(*requests)
+
+          loop do
+            redirect_requests = []
+            indexes = responses.each_with_index.map do |response, index|
+              next unless REDIRECT_STATUS.include?(response.status)
+              request = requests[index]
+              retry_request = __build_redirect_req(request, response, options)
+              redirect_requests << retry_request
+              index
+            end.compact
+            break if redirect_requests.empty?
+            break if max_redirects <= 0
+            max_redirects -= 1
+
+            redirect_responses = __send_reqs(*redirect_requests)
+            indexes.each_with_index do |index, i2|
+              requests[index] = redirect_requests[i2]
+              responses[index] = redirect_responses[i2]
+            end
+          end
+
+          return responses.first if responses.size == 1
+          responses
+        ensure
+          @keep_open = keep_open
+        end
+
+        private
+
+        def __build_redirect_req(request, response, options)
+          redirect_uri = URI(response.headers["location"])
+          redirect_uri = response.uri.merge(redirect_uri) if redirect_uri.relative?
+
+          # TODO: integrate cookies in the next request
+          # redirects are **ALWAYS** GET
+          retry_options = options.merge(headers: request.headers,
+                                        body: request.body)
+          __build_req(:get, redirect_uri, retry_options)
+        end
+      end
+
+      module OptionsMethods
+        def self.included(klass)
+          super
+          klass.def_option(:max_redirects)
+        end
+      end
+    end
+    register_plugin :follow_redirects, FollowRedirects
+  end
+end

data/lib/httpx/plugins/h2c.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module H2C
+      def self.load_dependencies(*)
+        require "base64"
+      end
+
+      module InstanceMethods
+        def request(*args, keep_open: @keep_open, **options)
+          return super if @_h2c_probed
+          begin
+            requests = __build_reqs(*args, **options)
+
+            upgrade_request = requests.first
+            return super unless valid_h2c_upgrade_request?(upgrade_request)
+            upgrade_request.headers["upgrade"] = "h2c"
+            upgrade_request.headers.add("connection", "upgrade")
+            upgrade_request.headers.add("connection", "http2-settings")
+            upgrade_request.headers["http2-settings"] = HTTP2::Client.settings_header(@options.http2_settings)
+            # TODO: validate!
+            upgrade_response = __send_reqs(*upgrade_request, **options).first
+
+            if upgrade_response.status == 101
+              channel = find_channel(upgrade_request)
+              parser = channel.upgrade_parser("h2")
+              parser.extend(UpgradeExtensions)
+              parser.upgrade(upgrade_request, upgrade_response, **options)
+              data = upgrade_response.to_s
+              parser << data
+              response = upgrade_request.response
+              if response.status == 200
+                requests.delete(upgrade_request)
+                return response if requests.empty?
+              end
+              responses = __send_reqs(*requests)
+            else
+              # proceed as usual
+              responses = [upgrade_response] + __send_reqs(*requests[1..-1])
+            end
+            return responses.first if responses.size == 1
+            responses
+          ensure
+            @_h2c_probed = true
+            close unless keep_open
+          end
+        end
+
+        private
+
+        VALID_H2C_METHODS = %i[get options head].freeze
+        private_constant :VALID_H2C_METHODS
+
+        def valid_h2c_upgrade_request?(request)
+          VALID_H2C_METHODS.include?(request.verb) &&
+            request.scheme == "http"
+        end
+      end
+
+      module UpgradeExtensions
+        def upgrade(request, _response, **)
+          @connection.send_connection_preface
+          # skip checks, it is assumed that this is the first
+          # request in the connection
+          stream = @connection.upgrade
+          handle_stream(stream, request)
+          @streams[request] = stream
+        end
+      end
+
+      module FrameBuilder
+        include HTTP2
+
+        module_function
+
+        def settings_value(settings)
+          frame = Framer.new.generate(type: :settings, stream: 0, payload: settings)
+          Base64.urlsafe_encode64(frame[9..-1])
+        end
+      end
+    end
+    register_plugin(:h2c, H2C)
+  end
+end