httpx-patched 1.6.2.1

data/lib/httpx/timers.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class Timers
+    def initialize
+      @intervals = []
+    end
+
+    def after(interval_in_secs, cb = nil, &blk)
+      callback = cb || blk
+
+      raise Error, "timer must have a callback" unless callback
+
+      # I'm assuming here that most requests will have the same
+      # request timeout, as in most cases they share common set of
+      # options. A user setting different request timeouts for 100s of
+      # requests will already have a hard time dealing with that.
+      unless (interval = @intervals.bsearch { |t| t.interval == interval_in_secs })
+        interval = Interval.new(interval_in_secs)
+        @intervals << interval
+        @intervals.sort!
+      end
+
+      interval << callback
+
+      @next_interval_at = nil
+
+      Timer.new(interval, callback)
+    end
+
+    def wait_interval
+      drop_elapsed!
+
+      return if @intervals.empty?
+
+      @next_interval_at = Utils.now
+
+      @intervals.first.interval
+    end
+
+    def fire(error = nil)
+      raise error if error && error.timeout != @intervals.first
+      return if @intervals.empty? || !@next_interval_at
+
+      elapsed_time = Utils.elapsed_time(@next_interval_at)
+
+      drop_elapsed!(elapsed_time)
+
+      @intervals = @intervals.drop_while { |interval| interval.elapse(elapsed_time) <= 0 }
+
+      @next_interval_at = nil if @intervals.empty?
+    end
+
+    private
+
+    def drop_elapsed!(elapsed_time = 0)
+      # check first, if not elapsed, then return
+      first_interval = @intervals.first
+
+      return unless first_interval && first_interval.elapsed?(elapsed_time)
+
+      # TODO: would be nice to have a drop_while!
+      @intervals = @intervals.drop_while { |interval| interval.elapse(elapsed_time) <= 0 }
+    end
+
+    class Timer
+      def initialize(interval, callback)
+        @interval = interval
+        @callback = callback
+      end
+
+      def cancel
+        @interval.delete(@callback)
+      end
+    end
+
+    class Interval
+      include Comparable
+
+      attr_reader :interval
+
+      def initialize(interval)
+        @interval = interval
+        @callbacks = []
+      end
+
+      def <=>(other)
+        @interval <=> other.interval
+      end
+
+      def ==(other)
+        return @interval == other if other.is_a?(Numeric)
+
+        @interval == other.to_f # rubocop:disable Lint/FloatComparison
+      end
+
+      def to_f
+        Float(@interval)
+      end
+
+      def <<(callback)
+        @callbacks << callback
+      end
+
+      def delete(callback)
+        @callbacks.delete(callback)
+      end
+
+      def no_callbacks?
+        @callbacks.empty?
+      end
+
+      def elapsed?(elapsed = 0)
+        (@interval - elapsed) <= 0 || @callbacks.empty?
+      end
+
+      def elapse(elapsed)
+        # same as elapsing
+        return 0 if @callbacks.empty?
+
+        @interval -= elapsed
+
+        if @interval <= 0
+          cb = @callbacks.dup
+          cb.each(&:call)
+        end
+
+        @interval
+      end
+    end
+    private_constant :Interval
+  end
+end

data/lib/httpx/transcoder/body.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module HTTPX::Transcoder
+  module Body
+    class Error < HTTPX::Error; end
+
+    module_function
+
+    class Encoder < SimpleDelegator
+      def initialize(body)
+        body = body.open(File::RDONLY, encoding: Encoding::BINARY) if Object.const_defined?(:Pathname) && body.is_a?(Pathname)
+        @body = body
+        super(body)
+      end
+
+      def bytesize
+        if @body.respond_to?(:bytesize)
+          @body.bytesize
+        elsif @body.respond_to?(:to_ary)
+          @body.sum(&:bytesize)
+        elsif @body.respond_to?(:size)
+          @body.size || Float::INFINITY
+        elsif @body.respond_to?(:length)
+          @body.length || Float::INFINITY
+        elsif @body.respond_to?(:each)
+          Float::INFINITY
+        else
+          raise Error, "cannot determine size of body: #{@body.inspect}"
+        end
+      end
+
+      def content_type
+        "application/octet-stream"
+      end
+    end
+
+    def encode(body)
+      Encoder.new(body)
+    end
+  end
+end

data/lib/httpx/transcoder/chunker.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX::Transcoder
+  module Chunker
+    class Error < HTTPX::Error; end
+
+    CRLF = "\r\n".b
+
+    class Encoder
+      extend Forwardable
+
+      def initialize(body)
+        @raw = body
+      end
+
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @raw.each do |chunk|
+          yield "#{chunk.bytesize.to_s(16)}#{CRLF}#{chunk}#{CRLF}"
+        end
+        yield "0#{CRLF}"
+      end
+
+      def respond_to_missing?(meth, *args)
+        @raw.respond_to?(meth, *args) || super
+      end
+    end
+
+    class Decoder
+      extend Forwardable
+
+      def_delegator :@buffer, :empty?
+
+      def_delegator :@buffer, :<<
+
+      def_delegator :@buffer, :clear
+
+      def initialize(buffer, trailers = false)
+        @buffer = buffer
+        @chunk_buffer = "".b
+        @finished = false
+        @state = :length
+        @trailers = trailers
+      end
+
+      def to_s
+        @buffer
+      end
+
+      def each
+        loop do
+          case @state
+          when :length
+            index = @buffer.index(CRLF)
+            return unless index && index.positive?
+
+            # Read hex-length
+            hexlen = @buffer.byteslice(0, index)
+            @buffer = @buffer.byteslice(index..-1) || "".b
+            hexlen[/\h/] || raise(Error, "wrong chunk size line: #{hexlen}")
+            @chunk_length = hexlen.hex
+            # check if is last chunk
+            @finished = @chunk_length.zero?
+            nextstate(:crlf)
+          when :crlf
+            crlf_size = @finished && !@trailers ? 4 : 2
+            # consume CRLF
+            return if @buffer.bytesize < crlf_size
+            raise Error, "wrong chunked encoding format" unless @buffer.start_with?(CRLF * (crlf_size / 2))
+
+            @buffer = @buffer.byteslice(crlf_size..-1)
+            if @chunk_length.nil?
+              nextstate(:length)
+            else
+              return if @finished
+
+              nextstate(:data)
+            end
+          when :data
+            chunk = @buffer.byteslice(0, @chunk_length)
+            @buffer = @buffer.byteslice(@chunk_length..-1) || "".b
+            @chunk_buffer << chunk
+            @chunk_length -= chunk.bytesize
+            if @chunk_length.zero?
+              yield @chunk_buffer unless @chunk_buffer.empty?
+              @chunk_buffer.clear
+              @chunk_length = nil
+              nextstate(:crlf)
+            end
+          end
+          break if @buffer.empty?
+        end
+      end
+
+      def finished?
+        @finished
+      end
+
+      private
+
+      def nextstate(state)
+        @state = state
+      end
+    end
+
+    module_function
+
+    def encode(chunks)
+      Encoder.new(chunks)
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "uri"
+require_relative "multipart"
+
+module HTTPX
+  module Transcoder
+    module Form
+      module_function
+
+      PARAM_DEPTH_LIMIT = 32
+
+      class Encoder
+        extend Forwardable
+
+        def_delegator :@raw, :to_s
+
+        def_delegator :@raw, :to_str
+
+        def_delegator :@raw, :bytesize
+
+        def_delegator :@raw, :==
+
+        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
+
+        def content_type
+          "application/x-www-form-urlencoded"
+        end
+      end
+
+      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)
+          end
+        end
+      end
+
+      def encode(form)
+        Encoder.new(form)
+      end
+
+      def decode(response)
+        content_type = response.content_type.mime_type
+
+        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
+    end
+  end
+end

data/lib/httpx/transcoder/gzip.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX::Transcoder
+  module JSON
+    module_function
+
+    JSON_REGEX = %r{
+      \b
+      application/
+      # optional vendor specific type
+      (?:
+        # token as per https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6
+        [!#$%&'*+\-.^_`|~0-9a-z]+
+        # literal plus sign
+        \+
+      )?
+      json
+      \b
+    }ix.freeze
+
+    class Encoder
+      extend Forwardable
+
+      def_delegator :@raw, :to_s
+
+      def_delegator :@raw, :bytesize
+
+      def_delegator :@raw, :==
+
+      def initialize(json)
+        @raw = JSON.json_dump(json)
+        @charset = @raw.encoding.name.downcase
+      end
+
+      def content_type
+        "application/json; charset=#{@charset}"
+      end
+    end
+
+    def encode(json)
+      Encoder.new(json)
+    end
+
+    def decode(response)
+      content_type = response.content_type.mime_type
+
+      raise HTTPX::Error, "invalid json mime type (#{content_type})" unless JSON_REGEX.match?(content_type)
+
+      method(:json_load)
+    end
+
+    # rubocop:disable Style/SingleLineMethods
+    if defined?(MultiJson)
+      def json_load(*args); MultiJson.load(*args); end
+      def json_dump(*args); MultiJson.dump(*args); end
+    elsif defined?(Oj)
+      def json_load(response, *args); Oj.load(response.to_s, *args); end
+      def json_dump(obj, options = {}); Oj.dump(obj, { mode: :compat }.merge(options)); end
+    elsif defined?(Yajl)
+      def json_load(response, *args); Yajl::Parser.new(*args).parse(response.to_s); end
+      def json_dump(*args); Yajl::Encoder.encode(*args); end
+    else
+      require "json"
+      def json_load(*args); ::JSON.parse(*args); end
+      def json_dump(*args); ::JSON.dump(*args); end
+    end
+    # rubocop:enable Style/SingleLineMethods
+  end
+end

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

@@ -0,0 +1,141 @@
+# 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
+          @current = nil
+          @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
+
+            # @type var head: String
+            head = @buffer.byteslice(0..idx + 4 - 1)
+
+            @buffer = @buffer.byteslice(head.bytesize..-1)
+
+            content_type = head[MULTIPART_CONTENT_TYPE, 1] || "text/plain"
+            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}[]" 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