httpx 0.24.6 → 1.0.0

data/lib/httpx/response/body.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class Response::Body
+    attr_reader :encoding, :encodings
+
+    def initialize(response, options)
+      @response = response
+      @headers = response.headers
+      @options = options
+      @threshold_size = options.body_threshold_size
+      @window_size = options.window_size
+      @encoding = response.content_type.charset || Encoding::BINARY
+      @encodings = []
+      @length = 0
+      @buffer = nil
+      @state = :idle
+      initialize_inflaters
+    end
+
+    def initialize_dup(other)
+      super
+
+      @buffer = other.instance_variable_get(:@buffer).dup
+    end
+
+    def closed?
+      @state == :closed
+    end
+
+    def write(chunk)
+      return if @state == :closed
+
+      @inflaters.reverse_each do |inflater|
+        chunk = inflater.call(chunk)
+      end if @inflaters
+
+      size = chunk.bytesize
+      @length += size
+      transition(:open)
+      @buffer.write(chunk)
+
+      @response.emit(:chunk_received, chunk)
+      size
+    end
+
+    def read(*args)
+      return unless @buffer
+
+      unless @reader
+        rewind
+        @reader = @buffer
+      end
+
+      @reader.read(*args)
+    end
+
+    def bytesize
+      @length
+    end
+
+    def each
+      return enum_for(__method__) unless block_given?
+
+      begin
+        if @buffer
+          rewind
+          while (chunk = @buffer.read(@window_size))
+            yield(chunk.force_encoding(@encoding))
+          end
+        end
+      ensure
+        close
+      end
+    end
+
+    def filename
+      return unless @headers.key?("content-disposition")
+
+      Utils.get_filename(@headers["content-disposition"])
+    end
+
+    def to_s
+      return "".b unless @buffer
+
+      @buffer.to_s
+    end
+
+    alias_method :to_str, :to_s
+
+    def empty?
+      @length.zero?
+    end
+
+    def copy_to(dest)
+      return unless @buffer
+
+      rewind
+
+      if dest.respond_to?(:path) && @buffer.respond_to?(:path)
+        FileUtils.mv(@buffer.path, dest.path)
+      else
+        ::IO.copy_stream(@buffer, dest)
+      end
+    end
+
+    # closes/cleans the buffer, resets everything
+    def close
+      if @buffer
+        @buffer.close
+        @buffer = nil
+      end
+      @length = 0
+      transition(:closed)
+    end
+
+    def ==(other)
+      object_id == other.object_id || begin
+        if other.respond_to?(:read)
+          _with_same_buffer_pos { FileUtils.compare_stream(@buffer, other) }
+        else
+          to_s == other.to_s
+        end
+      end
+    end
+
+    # :nocov:
+    def inspect
+      "#<HTTPX::Response::Body:#{object_id} " \
+        "@state=#{@state} " \
+        "@length=#{@length}>"
+    end
+    # :nocov:
+
+    def rewind
+      return unless @buffer
+
+      # in case there's some reading going on
+      @reader = nil
+
+      @buffer.rewind
+    end
+
+    private
+
+    def initialize_inflaters
+      return unless @headers.key?("content-encoding")
+
+      return unless @options.decompress_response_body
+
+      @inflaters = @headers.get("content-encoding").filter_map do |encoding|
+        next if encoding == "identity"
+
+        inflater = self.class.initialize_inflater_by_encoding(encoding, @response)
+
+        # do not uncompress if there is no decoder available. In fact, we can't reliably
+        # continue decompressing beyond that, so ignore.
+        break unless inflater
+
+        @encodings << encoding
+        inflater
+      end
+    end
+
+    def transition(nextstate)
+      case nextstate
+      when :open
+        return unless @state == :idle
+
+        @buffer = Response::Buffer.new(
+          threshold_size: @threshold_size,
+          bytesize: @length,
+          encoding: @encoding
+        )
+      when :closed
+        return if @state == :closed
+      end
+
+      @state = nextstate
+    end
+
+    def _with_same_buffer_pos
+      return yield unless @buffer && @buffer.respond_to?(:pos)
+
+      # @type ivar @buffer: StringIO | Tempfile
+      current_pos = @buffer.pos
+      @buffer.rewind
+      begin
+        yield
+      ensure
+        @buffer.pos = current_pos
+      end
+    end
+
+    class << self
+      def initialize_inflater_by_encoding(encoding, response, **kwargs)
+        case encoding
+        when "gzip"
+          Transcoder::GZIP.decode(response, **kwargs)
+        when "deflate"
+          Transcoder::Deflate.decode(response, **kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/httpx/response/buffer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "stringio"
+require "tempfile"
+
+module HTTPX
+  class Response::Buffer < SimpleDelegator
+    def initialize(threshold_size:, bytesize: 0, encoding: Encoding::BINARY)
+      @threshold_size = threshold_size
+      @bytesize = bytesize
+      @encoding = encoding
+      try_upgrade_buffer
+      super(@buffer)
+    end
+
+    def initialize_dup(other)
+      super
+
+      @buffer = other.instance_variable_get(:@buffer).dup
+    end
+
+    def size
+      @bytesize
+    end
+
+    def write(chunk)
+      @bytesize += chunk.bytesize
+      try_upgrade_buffer
+      @buffer.write(chunk)
+    end
+
+    def to_s
+      case @buffer
+      when StringIO
+        begin
+          @buffer.string.force_encoding(@encoding)
+        rescue ArgumentError
+          @buffer.string
+        end
+      when Tempfile
+        rewind
+        content = _with_same_buffer_pos { @buffer.read }
+        begin
+          content.force_encoding(@encoding)
+        rescue ArgumentError # ex: unknown encoding name - utf
+          content
+        end
+      end
+    end
+
+    def close
+      @buffer.close
+      @buffer.unlink if @buffer.respond_to?(:unlink)
+    end
+
+    private
+
+    def try_upgrade_buffer
+      if !@buffer.is_a?(Tempfile) && @bytesize > @threshold_size
+        aux = @buffer
+
+        @buffer = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
+
+        if aux
+          aux.rewind
+          ::IO.copy_stream(aux, @buffer)
+          aux.close
+        end
+
+      else
+        return if @buffer
+
+        @buffer = StringIO.new("".b)
+
+      end
+      __setobj__(@buffer)
+    end
+
+    def _with_same_buffer_pos
+      current_pos = @buffer.pos
+      @buffer.rewind
+      begin
+        yield
+      ensure
+        @buffer.pos = current_pos
+      end
+    end
+  end
+end

data/lib/httpx/response.rb

@@ -124,199 +124,6 @@ module HTTPX
           content_length == "0"
         end
     end
-
-    class Body
-      attr_reader :encoding
-
-      def initialize(response, options)
-        @response = response
-        @headers = response.headers
-        @options = options
-        @threshold_size = options.body_threshold_size
-        @window_size = options.window_size
-        @encoding = response.content_type.charset || Encoding::BINARY
-        @length = 0
-        @buffer = nil
-        @state = :idle
-      end
-
-      def initialize_dup(other)
-        super
-
-        @buffer = other.instance_variable_get(:@buffer).dup
-      end
-
-      def closed?
-        @state == :closed
-      end
-
-      def write(chunk)
-        return if @state == :closed
-
-        size = chunk.bytesize
-        @length += size
-        transition
-        @buffer.write(chunk)
-
-        @response.emit(:chunk_received, chunk)
-        size
-      end
-
-      def read(*args)
-        return unless @buffer
-
-        unless @reader
-          rewind
-          @reader = @buffer
-        end
-
-        @reader.read(*args)
-      end
-
-      def bytesize
-        @length
-      end
-
-      def each
-        return enum_for(__method__) unless block_given?
-
-        begin
-          if @buffer
-            rewind
-            while (chunk = @buffer.read(@window_size))
-              yield(chunk.force_encoding(@encoding))
-            end
-          end
-        ensure
-          close
-        end
-      end
-
-      def filename
-        return unless @headers.key?("content-disposition")
-
-        Utils.get_filename(@headers["content-disposition"])
-      end
-
-      def to_s
-        case @buffer
-        when StringIO
-          begin
-            @buffer.string.force_encoding(@encoding)
-          rescue ArgumentError
-            @buffer.string
-          end
-        when Tempfile
-          rewind
-          content = _with_same_buffer_pos { @buffer.read }
-          begin
-            content.force_encoding(@encoding)
-          rescue ArgumentError # ex: unknown encoding name - utf
-            content
-          end
-        else
-          "".b
-        end
-      end
-      alias_method :to_str, :to_s
-
-      def empty?
-        @length.zero?
-      end
-
-      def copy_to(dest)
-        return unless @buffer
-
-        rewind
-
-        if dest.respond_to?(:path) && @buffer.respond_to?(:path)
-          FileUtils.mv(@buffer.path, dest.path)
-        else
-          ::IO.copy_stream(@buffer, dest)
-        end
-      end
-
-      # closes/cleans the buffer, resets everything
-      def close
-        if @buffer
-          @buffer.close
-          @buffer.unlink if @buffer.respond_to?(:unlink)
-          @buffer = nil
-        end
-        @length = 0
-        @state = :closed
-      end
-
-      def ==(other)
-        object_id == other.object_id || begin
-          if other.respond_to?(:read)
-            _with_same_buffer_pos { FileUtils.compare_stream(@buffer, other) }
-          else
-            to_s == other.to_s
-          end
-        end
-      end
-
-      # :nocov:
-      def inspect
-        "#<HTTPX::Response::Body:#{object_id} " \
-          "@state=#{@state} " \
-          "@length=#{@length}>"
-      end
-      # :nocov:
-
-      def rewind
-        return unless @buffer
-
-        # in case there's some reading going on
-        @reader = nil
-
-        @buffer.rewind
-      end
-
-      private
-
-      def transition
-        case @state
-        when :idle
-          if @length > @threshold_size
-            @state = :buffer
-            @buffer = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
-          else
-            @state = :memory
-            @buffer = StringIO.new("".b)
-          end
-        when :memory
-          # @type ivar @buffer: StringIO | Tempfile
-          if @length > @threshold_size
-            aux = @buffer
-            @buffer = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
-            aux.rewind
-            ::IO.copy_stream(aux, @buffer)
-            # (this looks like a bug from Ruby < 2.3
-            @buffer.pos = aux.pos ##################
-            ########################################
-            aux.close
-            @state = :buffer
-          end
-        end
-
-        nil unless %i[memory buffer].include?(@state)
-      end
-
-      def _with_same_buffer_pos
-        return yield unless @buffer && @buffer.respond_to?(:pos)
-
-        # @type ivar @buffer: StringIO | Tempfile
-        current_pos = @buffer.pos
-        @buffer.rewind
-        begin
-          yield
-        ensure
-          @buffer.pos = current_pos
-        end
-      end
-    end
   end
 
   class ContentType
@@ -358,20 +165,8 @@ module HTTPX
       log_exception(@error)
     end
 
-    def status
-      warn ":#{__method__} is deprecated, use :error.message instead"
-      @error.message
-    end
-
-    if Exception.method_defined?(:full_message)
-      def to_s
-        @error.full_message(highlight: false)
-      end
-    else
-      def to_s
-        "#{@error.message} (#{@error.class})\n" \
-          "#{@error.backtrace.join("\n") if @error.backtrace}"
-      end
+    def to_s
+      @error.full_message(highlight: false)
     end
 
     def close
@@ -388,4 +183,6 @@ module HTTPX
   end
 end
 
-require "httpx/pmatch_extensions" if RUBY_VERSION >= "3.0.0"
+require_relative "response/body"
+require_relative "response/buffer"
+require_relative "pmatch_extensions" if RUBY_VERSION >= "3.0.0"

data/lib/httpx/selector.rb

@@ -9,8 +9,6 @@ class HTTPX::Selector
   private_constant :READABLE
   private_constant :WRITABLE
 
-  using HTTPX::IOExtensions
-
   def initialize
     @selectables = []
   end

data/lib/httpx/session.rb

@@ -339,16 +339,6 @@ module HTTPX
         end
         self
       end
-
-      # :nocov:
-      def plugins(pls)
-        warn ":#{__method__} is deprecated, use :plugin instead"
-        pls.each do |pl|
-          plugin(pl)
-        end
-        self
-      end
-      # :nocov:
     end
   end
 

data/lib/httpx/transcoder/body.rb

@@ -9,7 +9,6 @@ module HTTPX::Transcoder
     module_function
 
     class Encoder
-      using HTTPX::ArrayExtensions::Sum
       extend Forwardable
 
       def_delegator :@raw, :to_s

data/lib/httpx/transcoder/deflate.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "zlib"
+require_relative "utils/deflater"
+
+module HTTPX
+  module Transcoder
+    module Deflate
+      class Deflater < Transcoder::Deflater
+        def deflate(chunk)
+          @deflater ||= Zlib::Deflate.new
+
+          if chunk.nil?
+            unless @deflater.closed?
+              last = @deflater.finish
+              @deflater.close
+              last.empty? ? nil : last
+            end
+          else
+            @deflater.deflate(chunk)
+          end
+        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
+        GZIP::Inflater.new(bytesize)
+      end
+    end
+  end
+end

data/lib/httpx/transcoder/form.rb

@@ -2,57 +2,77 @@
 
 require "forwardable"
 require "uri"
+require_relative "multipart"
 
-module HTTPX::Transcoder
-  module Form
-    module_function
+module HTTPX
+  module Transcoder
+    module Form
+      module_function
 
-    PARAM_DEPTH_LIMIT = 32
+      PARAM_DEPTH_LIMIT = 32
 
-    class Encoder
-      extend Forwardable
+      class Encoder
+        extend Forwardable
 
-      def_delegator :@raw, :to_s
+        def_delegator :@raw, :to_s
 
-      def_delegator :@raw, :to_str
+        def_delegator :@raw, :to_str
 
-      def_delegator :@raw, :bytesize
+        def_delegator :@raw, :bytesize
 
-      def initialize(form)
-        @raw = form.each_with_object("".b) do |(key, val), buf|
-          HTTPX::Transcoder.normalize_keys(key, val) do |k, v|
-            buf << "&" unless buf.empty?
-            buf << URI.encode_www_form_component(k)
-            buf << "=#{URI.encode_www_form_component(v.to_s)}" unless v.nil?
+        def initialize(form)
+          @raw = form.each_with_object("".b) do |(key, val), buf|
+            HTTPX::Transcoder.normalize_keys(key, val) do |k, v|
+              buf << "&" unless buf.empty?
+              buf << URI.encode_www_form_component(k)
+              buf << "=#{URI.encode_www_form_component(v.to_s)}" unless v.nil?
+            end
           end
         end
-      end
 
-      def content_type
-        "application/x-www-form-urlencoded"
+        def content_type
+          "application/x-www-form-urlencoded"
+        end
       end
-    end
 
-    module Decoder
-      module_function
+      module Decoder
+        module_function
 
-      def call(response, *)
-        URI.decode_www_form(response.to_s).each_with_object({}) do |(field, value), params|
-          HTTPX::Transcoder.normalize_query(params, field, value, PARAM_DEPTH_LIMIT)
+        def call(response, *)
+          URI.decode_www_form(response.to_s).each_with_object({}) do |(field, value), params|
+            HTTPX::Transcoder.normalize_query(params, field, value, PARAM_DEPTH_LIMIT)
+          end
         end
       end
-    end
 
-    def encode(form)
-      Encoder.new(form)
-    end
+      def encode(form)
+        if multipart?(form)
+          Multipart::Encoder.new(form)
+        else
+          Encoder.new(form)
+        end
+      end
 
-    def decode(response)
-      content_type = response.content_type.mime_type
+      def decode(response)
+        content_type = response.content_type.mime_type
 
-      raise HTTPX::Error, "invalid form mime type (#{content_type})" unless content_type == "application/x-www-form-urlencoded"
+        case content_type
+        when "application/x-www-form-urlencoded"
+          Decoder
+        when "multipart/form-data"
+          Multipart::Decoder.new(response)
+        else
+          raise Error, "invalid form mime type (#{content_type})"
+        end
+      end
 
-      Decoder
+      def multipart?(data)
+        data.any? do |_, v|
+          Multipart::MULTIPART_VALUE_COND.call(v) ||
+            (v.respond_to?(:to_ary) && v.to_ary.any?(&Multipart::MULTIPART_VALUE_COND)) ||
+            (v.respond_to?(:to_hash) && v.to_hash.any? { |_, e| Multipart::MULTIPART_VALUE_COND.call(e) })
+        end
+      end
     end
   end
 end