httpx 0.24.5 → 1.0.0

data/lib/httpx/transcoder/gzip.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "uri"
+require "stringio"
+require "zlib"
+
+module HTTPX
+  module Transcoder
+    module GZIP
+      class Deflater < Transcoder::Deflater
+        def initialize(body)
+          @compressed_chunk = "".b
+          super
+        end
+
+        def deflate(chunk)
+          @deflater ||= Zlib::GzipWriter.new(self)
+
+          if chunk.nil?
+            unless @deflater.closed?
+              @deflater.flush
+              @deflater.close
+              compressed_chunk
+            end
+          else
+            @deflater.write(chunk)
+            compressed_chunk
+          end
+        end
+
+        private
+
+        def write(chunk)
+          @compressed_chunk << chunk
+        end
+
+        def compressed_chunk
+          @compressed_chunk.dup
+        ensure
+          @compressed_chunk.clear
+        end
+      end
+
+      class Inflater
+        def initialize(bytesize)
+          @inflater = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)
+          @bytesize = bytesize
+        end
+
+        def call(chunk)
+          buffer = @inflater.inflate(chunk)
+          @bytesize -= chunk.bytesize
+          if @bytesize <= 0
+            buffer << @inflater.finish
+            @inflater.close
+          end
+          buffer
+        end
+      end
+
+      module_function
+
+      def encode(body)
+        Deflater.new(body)
+      end
+
+      def decode(response, bytesize: nil)
+        bytesize ||= response.headers.key?("content-length") ? response.headers["content-length"].to_i : Float::INFINITY
+        Inflater.new(bytesize)
+      end
+    end
+  end
+end

data/lib/httpx/transcoder/json.rb

@@ -4,12 +4,10 @@ require "forwardable"
 
 module HTTPX::Transcoder
   module JSON
-    JSON_REGEX = %r{\bapplication/(?:vnd\.api\+)?json\b}i.freeze
-
-    using HTTPX::RegexpExtensions unless Regexp.method_defined?(:match?)
-
     module_function
 
+    JSON_REGEX = %r{\bapplication/(?:vnd\.api\+)?json\b}i.freeze
+
     class Encoder
       extend Forwardable
 

data/lib/httpx/transcoder/multipart/decoder.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "delegate"
+
+module HTTPX
+  module Transcoder
+    module Multipart
+      class FilePart < SimpleDelegator
+        attr_reader :original_filename, :content_type
+
+        def initialize(filename, content_type)
+          @original_filename = filename
+          @content_type = content_type
+          @file = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
+          super(@file)
+        end
+      end
+
+      class Decoder
+        include HTTPX::Utils
+
+        CRLF = "\r\n"
+        BOUNDARY_RE = /;\s*boundary=([^;]+)/i.freeze
+        MULTIPART_CONTENT_TYPE = /Content-Type: (.*)#{CRLF}/ni.freeze
+        MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*;\s*name=(#{VALUE})/ni.freeze
+        MULTIPART_CONTENT_ID = /Content-ID:\s*([^#{CRLF}]*)/ni.freeze
+        WINDOW_SIZE = 2 << 14
+
+        def initialize(response)
+          @boundary = begin
+            m = response.headers["content-type"].to_s[BOUNDARY_RE, 1]
+            raise Error, "no boundary declared in content-type header" unless m
+
+            m.strip
+          end
+          @buffer = "".b
+          @parts = {}
+          @intermediate_boundary = "--#{@boundary}"
+          @state = :idle
+        end
+
+        def call(response, *)
+          response.body.each do |chunk|
+            @buffer << chunk
+
+            parse
+          end
+
+          raise Error, "invalid or unsupported multipart format" unless @buffer.empty?
+
+          @parts
+        end
+
+        private
+
+        def parse
+          case @state
+          when :idle
+            raise Error, "payload does not start with boundary" unless @buffer.start_with?("#{@intermediate_boundary}#{CRLF}")
+
+            @buffer = @buffer.byteslice(@intermediate_boundary.bytesize + 2..-1)
+
+            @state = :part_header
+          when :part_header
+            idx = @buffer.index("#{CRLF}#{CRLF}")
+
+            # raise Error, "couldn't parse part headers" unless idx
+            return unless idx
+
+            head = @buffer.byteslice(0..idx + 4 - 1)
+
+            @buffer = @buffer.byteslice(head.bytesize..-1)
+
+            content_type = head[MULTIPART_CONTENT_TYPE, 1]
+            if (name = head[MULTIPART_CONTENT_DISPOSITION, 1])
+              name = /\A"(.*)"\Z/ =~ name ? Regexp.last_match(1) : name.dup
+              name.gsub!(/\\(.)/, "\\1")
+              name
+            else
+              name = head[MULTIPART_CONTENT_ID, 1]
+            end
+
+            filename = HTTPX::Utils.get_filename(head)
+
+            name = filename || +"#{content_type || "text/plain"}[]" if name.nil? || name.empty?
+
+            @current = name
+
+            @parts[name] = if filename
+              FilePart.new(filename, content_type)
+            else
+              "".b
+            end
+
+            @state = :part_body
+          when :part_body
+            part = @parts[@current]
+
+            body_separator = if part.is_a?(FilePart)
+              "#{CRLF}#{CRLF}"
+            else
+              CRLF
+            end
+            idx = @buffer.index(body_separator)
+
+            if idx
+              payload = @buffer.byteslice(0..idx - 1)
+              @buffer = @buffer.byteslice(idx + body_separator.bytesize..-1)
+              part << payload
+              part.rewind if part.respond_to?(:rewind)
+              @state = :parse_boundary
+            else
+              part << @buffer
+              @buffer.clear
+            end
+          when :parse_boundary
+            raise Error, "payload does not start with boundary" unless @buffer.start_with?(@intermediate_boundary)
+
+            @buffer = @buffer.byteslice(@intermediate_boundary.bytesize..-1)
+
+            if @buffer == "--"
+              @buffer.clear
+              @state = :done
+              return
+            elsif @buffer.start_with?(CRLF)
+              @buffer = @buffer.byteslice(2..-1)
+              @state = :part_header
+            else
+              return
+            end
+          when :done
+            raise Error, "parsing should have been over by now"
+          end until @buffer.empty?
+        end
+      end
+    end
+  end
+end

data/lib/httpx/{plugins → transcoder}/multipart/encoder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module HTTPX::Plugins
-  module Multipart
+module HTTPX
+  module Transcoder::Multipart
     class Encoder
       attr_reader :bytesize
 
@@ -43,7 +43,7 @@ module HTTPX::Plugins
       def to_parts(form)
         @bytesize = 0
         params = form.each_with_object([]) do |(key, val), aux|
-          Multipart.normalize_keys(key, val) do |k, v|
+          Transcoder.normalize_keys(key, val, MULTIPART_VALUE_COND) do |k, v|
             next if v.nil?
 
             value, content_type, filename = Part.call(v)

data/lib/httpx/{plugins → transcoder}/multipart/mime_type_detector.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HTTPX
-  module Plugins::Multipart
+  module Transcoder::Multipart
     module MimeTypeDetector
       module_function
 

data/lib/httpx/{plugins → transcoder}/multipart/part.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HTTPX
-  module Plugins::Multipart
+  module Transcoder::Multipart
     module Part
       module_function
 
@@ -21,7 +21,8 @@ module HTTPX
 
         value = value.open(File::RDONLY) if Object.const_defined?(:Pathname) && value.is_a?(Pathname)
 
-        if value.is_a?(File)
+        if value.respond_to?(:path) && value.respond_to?(:read)
+          # either a File, a Tempfile, or something else which has to quack like a file
           filename ||= File.basename(value.path)
           content_type ||= MimeTypeDetector.call(value, filename) || "application/octet-stream"
           [value, content_type, filename]

data/lib/httpx/transcoder/multipart.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "multipart/encoder"
+require_relative "multipart/decoder"
+require_relative "multipart/part"
+require_relative "multipart/mime_type_detector"
+
+module HTTPX::Transcoder
+  module Multipart
+    MULTIPART_VALUE_COND = lambda do |value|
+      value.respond_to?(:read) ||
+        (value.respond_to?(:to_hash) &&
+          value.key?(:body) &&
+          (value.key?(:filename) || value.key?(:content_type)))
+    end
+  end
+end

data/lib/httpx/transcoder/utils/body_reader.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module HTTPX
+  module Transcoder
+    class BodyReader
+      def initialize(body)
+        @body = if body.respond_to?(:read)
+          body.rewind if body.respond_to?(:rewind)
+          body
+        elsif body.respond_to?(:each)
+          body.enum_for(:each)
+        else
+          StringIO.new(body.to_s)
+        end
+      end
+
+      def bytesize
+        return @body.bytesize if @body.respond_to?(:bytesize)
+
+        Float::INFINITY
+      end
+
+      def read(length = nil, outbuf = nil)
+        return @body.read(length, outbuf) if @body.respond_to?(:read)
+
+        begin
+          chunk = @body.next
+          if outbuf
+            outbuf.clear.force_encoding(Encoding::BINARY)
+            outbuf << chunk
+          else
+            outbuf = chunk
+          end
+          outbuf unless length && outbuf.empty?
+        rescue StopIteration
+        end
+      end
+
+      def close
+        @body.close if @body.respond_to?(:close)
+      end
+    end
+  end
+end

data/lib/httpx/transcoder/utils/deflater.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require_relative "body_reader"
+
+module HTTPX
+  module Transcoder
+    class Deflater
+      extend Forwardable
+
+      attr_reader :content_type
+
+      def initialize(body)
+        @content_type = body.content_type
+        @body = BodyReader.new(body)
+        @closed = false
+      end
+
+      def bytesize
+        buffer_deflate!
+
+        @buffer.size
+      end
+
+      def read(length = nil, outbuf = nil)
+        return @buffer.read(length, outbuf) if @buffer
+
+        return if @closed
+
+        chunk = @body.read(length)
+
+        compressed_chunk = deflate(chunk)
+
+        return unless compressed_chunk
+
+        if outbuf
+          outbuf.clear.force_encoding(Encoding::BINARY)
+          outbuf << compressed_chunk
+        else
+          compressed_chunk
+        end
+      end
+
+      def close
+        return if @closed
+
+        @buffer.close if @buffer
+
+        @body.close
+
+        @closed = true
+      end
+
+      private
+
+      # rubocop:disable Naming/MemoizedInstanceVariableName
+      def buffer_deflate!
+        return @buffer if defined?(@buffer)
+
+        buffer = Response::Buffer.new(
+          threshold_size: Options::MAX_BODY_THRESHOLD_SIZE
+        )
+        ::IO.copy_stream(self, buffer)
+
+        buffer.rewind
+
+        @buffer = buffer
+      end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
+    end
+  end
+end

data/lib/httpx/transcoder/xml.rb

@@ -6,8 +6,6 @@ require "uri"
 
 module HTTPX::Transcoder
   module Xml
-    using HTTPX::RegexpExtensions
-
     module_function
 
     MIME_TYPES = %r{\b(application|text)/(.+\+)?xml\b}.freeze

data/lib/httpx/transcoder.rb

@@ -2,8 +2,6 @@
 
 module HTTPX
   module Transcoder
-    using RegexpExtensions unless Regexp.method_defined?(:match?)
-
     module_function
 
     def normalize_keys(key, value, cond = nil, &block)
@@ -90,3 +88,5 @@ require "httpx/transcoder/form"
 require "httpx/transcoder/json"
 require "httpx/transcoder/xml"
 require "httpx/transcoder/chunker"
+require "httpx/transcoder/deflate"
+require "httpx/transcoder/gzip"

data/lib/httpx/utils.rb

@@ -3,7 +3,6 @@
 module HTTPX
   module Utils
     using URIExtensions
-    using HTTPX::RegexpExtensions unless Regexp.method_defined?(:match?)
 
     TOKEN = %r{[^\s()<>,;:\\"/\[\]?=]+}.freeze
     VALUE = /"(?:\\"|[^"])*"|#{TOKEN}/.freeze
@@ -55,31 +54,22 @@ module HTTPX
       filename
     end
 
-    if RUBY_VERSION < "2.3"
+    URIParser = URI::RFC2396_Parser.new
 
-      def to_uri(uri)
-        URI(uri)
-      end
-
-    else
-
-      URIParser = URI::RFC2396_Parser.new
+    def to_uri(uri)
+      return URI(uri) unless uri.is_a?(String) && !uri.ascii_only?
 
-      def to_uri(uri)
-        return URI(uri) unless uri.is_a?(String) && !uri.ascii_only?
+      uri = URI(URIParser.escape(uri))
 
-        uri = URI(URIParser.escape(uri))
+      non_ascii_hostname = URIParser.unescape(uri.host)
 
-        non_ascii_hostname = URIParser.unescape(uri.host)
+      non_ascii_hostname.force_encoding(Encoding::UTF_8)
 
-        non_ascii_hostname.force_encoding(Encoding::UTF_8)
+      idna_hostname = Punycode.encode_hostname(non_ascii_hostname)
 
-        idna_hostname = Punycode.encode_hostname(non_ascii_hostname)
-
-        uri.host = idna_hostname
-        uri.non_ascii_hostname = non_ascii_hostname
-        uri
-      end
+      uri.host = idna_hostname
+      uri.non_ascii_hostname = non_ascii_hostname
+      uri
     end
   end
 end

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.24.5"
+  VERSION = "1.0.0"
 end

data/lib/httpx.rb

@@ -53,14 +53,6 @@ module HTTPX
     end
   end
 
-  # :nocov:
-  def self.const_missing(const_name)
-    super unless const_name == :Client
-    warn "DEPRECATION WARNING: the class #{self}::Client is deprecated. Use #{self}::Session instead."
-    Session
-  end
-  # :nocov:
-
   extend Chainable
 end
 

data/sig/chainable.rbs

@@ -12,18 +12,17 @@ module HTTPX
     def with: (options) -> Session
             | (options) { (Session) -> void } -> void
 
-    def plugin: (:authentication, ?options) -> Plugins::sessionAuthentication
-              | (:basic_authentication, ?options) -> Plugins::sessionBasicAuth
-              | (:digest_authentication, ?options) -> Plugins::sessionDigestAuth
-              | (:ntlm_authentication, ?options) -> Plugins::sessionNTLMAuth
+    def plugin: (:auth, ?options) -> Plugins::sessionAuthorization
+              | (:basic_auth, ?options) -> Plugins::sessionBasicAuth
+              | (:digest_auth, ?options) -> Plugins::sessionDigestAuth
+              | (:ntlm_auth, ?options) -> Plugins::sessionNTLMAuth
               | (:aws_sdk_authentication, ?options) -> Plugins::sessionAwsSdkAuthentication
-              | (:compression, ?options) -> Session
+              | (:brotli, ?options) -> Session
               | (:cookies, ?options) -> Plugins::sessionCookies
               | (:expect, ?options) -> Session
               | (:follow_redirects, ?options) -> Plugins::sessionFollowRedirects
               | (:upgrade, ?options) -> Session
               | (:h2c, ?options) -> Session
-              | (:multipart, ?options) -> Session
               | (:persistent, ?options) -> Plugins::sessionPersistent
               | (:proxy, ?options) -> (Plugins::sessionProxy & Plugins::httpProxy)
               | (:push_promise, ?options) -> Plugins::sessionPushPromise

data/sig/connection.rbs

@@ -36,7 +36,6 @@ module HTTPX
     @keep_alive_timeout: Numeric?
     @timeout: Numeric?
     @current_timeout: Numeric?
-    @total_timeout: Numeric?
     @io: TCP | SSL | UNIX
     @parser: HTTP1 | HTTP2 | _Parser
     @connected_at: Float

data/sig/errors.rbs

@@ -17,9 +17,6 @@ module HTTPX
     def initialize: (Numeric timeout, String message) -> untyped
   end
 
-  class TotalTimeoutError < TimeoutError
-  end
-
   class ConnectTimeoutError < TimeoutError
   end
 

data/sig/httpx.rbs

@@ -5,7 +5,8 @@ module HTTPX
 
   VERSION: String
 
-  type uri = URI::HTTP | URI::HTTPS | string
+  type http_uri = URI::HTTP | URI::HTTPS
+  type uri = http_uri | string
   type generic_uri = String | URI::Generic
 
   type verb = "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE" | "CONNECT" |

data/sig/io/unix.rbs

@@ -5,6 +5,6 @@ module HTTPX
 
     alias host path
 
-    def initialize: (URI::HTTP | URI::HTTPS origin, Array[String]? addresses, options options) -> void
+    def initialize: (http_uri origin, Array[String]? addresses, options options) -> void
   end
 end

data/sig/options.rbs

@@ -11,13 +11,11 @@ module HTTPX
     SETTINGS_TIMEOUT: Integer
     DEFAULT_OPTIONS: Hash[Symbol, untyped]
 
-    type timeout_type = :connect_timeout | :settings_timeout | :operation_timeout | :keep_alive_timeout | :total_timeout | :read_timeout | :write_timeout | :request_timeout
+    type timeout_type = :connect_timeout | :settings_timeout | :operation_timeout | :keep_alive_timeout | :read_timeout | :write_timeout | :request_timeout
     type timeout = Hash[timeout_type, Numeric]
 
     def self.new: (?options) -> instance
 
-    def self.def_option: (Symbol, ?String) -> void
-                       | (Symbol) { (*nil) -> untyped } -> void
     # headers
     attr_reader uri: URI?
 
@@ -48,12 +46,18 @@ module HTTPX
     # transport
     attr_reader transport: "unix" | nil
 
-    # transport_options
-    attr_reader transport_options: Hash[untyped, untyped]?
-
     # addresses
     attr_reader addresses: Array[ipaddr]?
 
+    # supported_compression_formats
+    attr_reader supported_compression_formats: Array[String]
+
+    # compress_request_body
+    attr_reader compress_request_body: bool
+
+    # decompress_response_body
+    attr_reader decompress_response_body: bool
+
     # params
     attr_reader params: Transcoder::urlencoded_input?
 
@@ -124,9 +128,9 @@ module HTTPX
 
     REQUEST_IVARS: Array[Symbol]
 
-    def initialize: (?options options) -> untyped
+    def initialize: (?options options) -> void
 
-    def __initialize__: (?options options) -> untyped
+    def do_initialize: (?options options) -> void
   end
 
   type options = Options | Hash[Symbol, untyped]

data/sig/plugins/{authentication → auth}/basic.rbs

@@ -5,8 +5,6 @@ module HTTPX
         @user: String
         @password: String
 
-        def can_authenticate?: (String? authenticate) -> boolish
-
         def authenticate: (*untyped) -> String
 
         private

data/sig/plugins/auth.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module Authorization
+      module InstanceMethods
+        def authorization: (string token) -> instance
+
+        def bearer_auth: (string token) -> instance
+      end
+    end
+
+    type sessionAuthorization = Session & Authorization::InstanceMethods
+  end
+end

data/sig/plugins/{basic_authentication.rbs → basic_auth.rbs}

@@ -6,10 +6,10 @@ module HTTPX
       def self.configure: (singleton(Session)) -> void
 
       module InstanceMethods
-        def basic_authentication: (string user, string password) -> instance
+        def basic_auth: (string user, string password) -> instance
       end
     end
 
-    type sessionBasicAuth = sessionAuthentication & Authentication::InstanceMethods & BasicAuth::InstanceMethods
+    type sessionBasicAuth = sessionAuthorization & BasicAuth::InstanceMethods
   end
 end