httpx 0.20.5 → 0.21.0

data/lib/httpx/plugins/webdav.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin implements convenience methods for performing WEBDAV requests.
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/WEBDAV
+    #
+    module WebDav
+      module InstanceMethods
+        def copy(src, dest)
+          request(:copy, src, headers: { "destination" => @options.origin.merge(dest) })
+        end
+
+        def move(src, dest)
+          request(:move, src, headers: { "destination" => @options.origin.merge(dest) })
+        end
+
+        def lock(path, timeout: nil, &blk)
+          headers = {}
+          headers["timeout"] = if timeout && timeout.positive?
+            "Second-#{timeout}"
+          else
+            "Infinite, Second-4100000000"
+          end
+          xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" \
+                "<D:lockinfo xmlns:D=\"DAV:\">" \
+                "<D:lockscope><D:exclusive/></D:lockscope>" \
+                "<D:locktype><D:write/></D:locktype>" \
+                "<D:owner>null</D:owner>" \
+                "</D:lockinfo>"
+          response = request(:lock, path, headers: headers, xml: xml)
+
+          return response unless blk && response.status == 200
+
+          lock_token = response.headers["lock-token"]
+
+          begin
+            blk.call(response)
+          ensure
+            unlock(path, lock_token)
+          end
+        end
+
+        def unlock(path, lock_token)
+          request(:unlock, path, headers: { "lock-token" => lock_token })
+        end
+
+        def mkcol(dir)
+          request(:mkcol, dir)
+        end
+
+        def propfind(path, xml = nil)
+          body = case xml
+                 when :acl
+                   '<?xml version="1.0" encoding="utf-8" ?><D:propfind xmlns:D="DAV:"><D:prop><D:owner/>' \
+                   "<D:supported-privilege-set/><D:current-user-privilege-set/><D:acl/></D:prop></D:propfind>"
+                 when nil
+                   '<?xml version="1.0" encoding="utf-8"?><DAV:propfind xmlns:DAV="DAV:"><DAV:allprop/></DAV:propfind>'
+                 else
+                   xml
+          end
+
+          request(:propfind, path, headers: { "depth" => "1" }, xml: body)
+        end
+
+        def proppatch(path, xml)
+          body = "<?xml version=\"1.0\"?>" \
+                 "<D:propertyupdate xmlns:D=\"DAV:\" xmlns:Z=\"http://ns.example.com/standards/z39.50/\">#{xml}</D:propertyupdate>"
+          request(:proppatch, path, xml: body)
+        end
+        # %i[ orderpatch acl report search]
+      end
+    end
+    register_plugin(:webdav, WebDav)
+  end
+end

data/lib/httpx/request.rb

@@ -9,29 +9,6 @@ module HTTPX
     include Callbacks
     using URIExtensions
 
-    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
-    ].freeze
-
     USER_AGENT = "httpx.rb/#{VERSION}"
 
     attr_reader :verb, :uri, :headers, :body, :state, :options, :response
@@ -54,8 +31,6 @@ module HTTPX
         @uri = origin.merge("#{base_path}#{@uri}")
       end
 
-      raise(Error, "unknown method: #{verb}") unless METHODS.include?(@verb)
-
       @headers = @options.headers_class.new(@options.headers)
       @headers["user-agent"] ||= USER_AGENT
       @headers["accept"]     ||= "*/*"
@@ -64,6 +39,18 @@ module HTTPX
       @state = :idle
     end
 
+    def read_timeout
+      @options.timeout[:read_timeout]
+    end
+
+    def write_timeout
+      @options.timeout[:write_timeout]
+    end
+
+    def request_timeout
+      @options.timeout[:request_timeout]
+    end
+
     def trailers?
       defined?(@trailers)
     end
@@ -108,6 +95,7 @@ module HTTPX
 
     def path
       path = uri.path.dup
+      path =  +"" if path.nil?
       path << "/" if path.empty?
       path << "?#{query}" unless query.empty?
       path
@@ -174,6 +162,8 @@ module HTTPX
           Transcoder.registry("form").encode(options.form)
         elsif options.json
           Transcoder.registry("json").encode(options.json)
+        elsif options.xml
+          Transcoder.registry("xml").encode(options.xml)
         end
         return if @body.nil?
 

data/lib/httpx/resolver/https.rb

@@ -102,7 +102,7 @@ module HTTPX
         @requests[request] = hostname
         resolver_connection.send(request)
         @connections << connection
-      rescue ResolveError, Resolv::DNS::EncodeError, JSON::JSONError => e
+      rescue ResolveError, Resolv::DNS::EncodeError => e
         @queries.delete(hostname)
         emit_resolve_error(connection, connection.origin.host, e)
       end
@@ -129,7 +129,7 @@ module HTTPX
     def parse(request, response)
       begin
         answers = decode_response_body(response)
-      rescue Resolv::DNS::DecodeError, JSON::JSONError => e
+      rescue Resolv::DNS::DecodeError => e
         host, connection = @queries.first
         @queries.delete(host)
         emit_resolve_error(connection, connection.origin.host, e)
@@ -203,11 +203,6 @@ module HTTPX
 
     def decode_response_body(response)
       case response.headers["content-type"]
-      when "application/dns-json",
-           "application/json",
-           %r{^application/x-javascript} # because google...
-        payload = JSON.parse(response.to_s)
-        payload["Answer"]
       when "application/dns-udpwireformat",
            "application/dns-message"
         Resolver.decode_dns_answer(response.to_s)

data/lib/httpx/resolver/native.rb

@@ -77,7 +77,8 @@ module HTTPX
       nil
     rescue Errno::EHOSTUNREACH => e
       @ns_index += 1
-      if @ns_index < @nameserver.size
+      nameserver = @nameserver
+      if nameserver && @ns_index < nameserver.size
         log { "resolver: failed resolving on nameserver #{@nameserver[@ns_index - 1]} (#{e.message})" }
         transition(:idle)
       else

data/lib/httpx/response.rb

@@ -31,6 +31,7 @@ module HTTPX
       @status = Integer(status)
       @headers = @options.headers_class.new(headers)
       @body = @options.response_body_class.new(self, @options)
+      @finished = complete?
     end
 
     def merge_headers(h)
@@ -41,15 +42,24 @@ module HTTPX
       @body.write(data)
     end
 
+    def content_type
+      @content_type ||= ContentType.new(@headers["content-type"])
+    end
+
+    def finished?
+      @finished
+    end
+
+    def finish!
+      @finished = true
+      @headers.freeze
+    end
+
     def bodyless?
       @request.verb == :head ||
         no_data?
     end
 
-    def content_type
-      @content_type ||= ContentType.new(@headers["content-type"])
-    end
-
     def complete?
       bodyless? || (@request.verb == :connect && @status == 200)
     end
@@ -76,17 +86,21 @@ module HTTPX
       raise err
     end
 
-    def json(options = nil)
-      decode("json", options)
+    def json(*args)
+      decode("json", *args)
     end
 
     def form
       decode("form")
     end
 
+    def xml
+      decode("xml")
+    end
+
     private
 
-    def decode(format, options = nil)
+    def decode(format, *args)
       # TODO: check if content-type is a valid format, i.e. "application/json" for json parsing
       transcoder = Transcoder.registry(format)
 
@@ -96,13 +110,13 @@ module HTTPX
 
       raise Error, "no decoder available for \"#{format}\"" unless decoder
 
-      decoder.call(self, options)
+      decoder.call(self, *args)
     rescue Registry::Error
       raise Error, "no decoder available for \"#{format}\""
     end
 
     def no_data?
-      @status < 200 ||
+      @status < 200 || # informational response
         @status == 204 ||
         @status == 205 ||
         @status == 304 || begin
@@ -339,6 +353,10 @@ module HTTPX
       end
     end
 
+    def finished?
+      true
+    end
+
     def raise_for_status
       raise @error
     end

data/lib/httpx/timers.rb

@@ -37,9 +37,12 @@ module HTTPX
       elapsed_time = Utils.elapsed_time(@next_interval_at)
 
       @intervals.delete_if { |interval| interval.elapse(elapsed_time) <= 0 }
+
+      @next_interval_at = nil if @intervals.empty?
     end
 
     def cancel
+      @next_interval_at = nil
       @intervals.clear
     end
 

data/lib/httpx/transcoder/form.rb

@@ -36,7 +36,7 @@ module HTTPX::Transcoder
     module Decoder
       module_function
 
-      def call(response, _)
+      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

data/lib/httpx/transcoder/json.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "forwardable"
-require "json"
 
 module HTTPX::Transcoder
   module JSON
@@ -19,7 +18,7 @@ module HTTPX::Transcoder
       def_delegator :@raw, :bytesize
 
       def initialize(json)
-        @raw = ::JSON.dump(json)
+        @raw = JSON.json_dump(json)
         @charset = @raw.encoding.name.downcase
       end
 
@@ -37,8 +36,25 @@ module HTTPX::Transcoder
 
       raise HTTPX::Error, "invalid json mime type (#{content_type})" unless JSON_REGEX.match?(content_type)
 
-      ::JSON.method(:parse)
+      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(*args); Oj.dump(*args); 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
   register "json", JSON
 end

data/lib/httpx/transcoder/xml.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+require "uri"
+
+module HTTPX::Transcoder
+  module Xml
+    using HTTPX::RegexpExtensions
+
+    module_function
+
+    MIME_TYPES = %r{\b(application|text)/(.+\+)?xml\b}.freeze
+
+    class Encoder
+      def initialize(xml)
+        @raw = xml
+      end
+
+      def content_type
+        charset = @raw.respond_to?(:encoding) ? @raw.encoding.to_s.downcase : "utf-8"
+        "application/xml; charset=#{charset}"
+      end
+
+      def bytesize
+        @raw.to_s.bytesize
+      end
+
+      def to_s
+        @raw.to_s
+      end
+    end
+
+    def encode(xml)
+      Encoder.new(xml)
+    end
+
+    begin
+      require "nokogiri"
+
+      # rubocop:disable Lint/DuplicateMethods
+      def decode(response)
+        content_type = response.content_type.mime_type
+
+        raise HTTPX::Error, "invalid form mime type (#{content_type})" unless MIME_TYPES.match?(content_type)
+
+        Nokogiri::XML.method(:parse)
+      end
+    rescue LoadError
+      def decode(_response)
+        raise HTTPX::Error, "\"nokogiri\" is required in order to decode XML"
+      end
+    end
+    # rubocop:enable Lint/DuplicateMethods
+  end
+  register "xml", Xml
+end

data/lib/httpx/transcoder.rb

@@ -90,4 +90,5 @@ end
 require "httpx/transcoder/body"
 require "httpx/transcoder/form"
 require "httpx/transcoder/json"
+require "httpx/transcoder/xml"
 require "httpx/transcoder/chunker"

data/lib/httpx/version.rb

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

data/sig/buffer.rbs

@@ -15,7 +15,7 @@ module HTTPX
     # delegated
     def <<: (string data) -> String
     def empty?: () -> bool
-    def bytesize: () -> Integer
+    def bytesize: () -> (Integer | Float)
     def clear: () -> void
     def replace: (string) -> void
 

data/sig/chainable.rbs

@@ -33,6 +33,7 @@ module HTTPX
               | (:aws_sigv4, ?options) -> Plugins::awsSigV4Session
               | (:grpc, ?options) -> Plugins::grpcSession
               | (:response_cache, ?options) -> Plugins::sessionResponseCache
+              | (:circuit_breaker, ?options) -> Plugins::sessionCircuitBreaker
               | (Symbol | Module, ?options) { (Class) -> void } -> Session
               | (Symbol | Module, ?options) -> Session
 

data/sig/connection.rbs

@@ -28,7 +28,7 @@ module HTTPX
     attr_reader options: Options
     attr_writer timers: Timers
 
-    @origins: Array[URI::Generic]
+    @type: io_type
     @window_size: Integer
     @read_buffer: Buffer
     @write_buffer: Buffer
@@ -40,7 +40,7 @@ module HTTPX
 
     def addresses=: (Array[ipaddr]) -> void
 
-    def match?: (URI::Generic, options) -> bool
+    def match?: (URI::Generic uri, Options options) -> bool
 
     def mergeable?: (Connection) -> bool
 
@@ -54,13 +54,15 @@ module HTTPX
 
     def match_altsvcs?: (URI::Generic uri) -> bool
 
+    def match_altsvc_options?: (URI::Generic uri, Options options) -> bool
+
     def connecting?: () -> bool
 
     def inflight?: () -> boolish
 
     def interests: () -> io_interests?
 
-    def to_io: () -> IO
+    def to_io: () -> ::IO
 
     def call: () -> void
 
@@ -77,7 +79,7 @@ module HTTPX
 
     private
 
-    def initialize: (String, URI::Generic, options) -> untyped
+    def initialize: (io_type, URI::Generic, options) -> untyped
 
     def connect: () -> void
 
@@ -103,5 +105,11 @@ module HTTPX
     def handle_error: (StandardError) -> void
 
     def purge_after_closed: () -> void
+
+    def set_request_timeouts: (Request request) -> void
+
+    def write_timeout_callback: (Request request, Numeric write_timeout) -> void
+
+    def read_timeout_callback: (Request request, Numeric read_timeout, ?singleton(RequestTimeoutError) error_type) -> void
   end
 end

data/sig/errors.rbs

@@ -23,6 +23,19 @@ module HTTPX
   class ResolveTimeoutError < TimeoutError
   end
 
+  class RequestTimeoutError < TimeoutError
+    attr_reader request: Request
+    attr_reader response: response?
+
+    def initialize: (Request request, response? response, Numeric timeout) -> void
+  end
+
+  class ReadTimeoutError < RequestTimeoutError
+  end
+
+  class WriteTimeoutError < RequestTimeoutError
+  end
+
   class ResolveError < Error
   end
 

data/sig/io.rbs

@@ -0,0 +1,6 @@
+module HTTPX
+  type io_type = "udp" | "tcp" | "ssl" | "unix"
+
+  module IO
+  end
+end

data/sig/options.rbs

@@ -10,7 +10,7 @@ module HTTPX
     SETTINGS_TIMEOUT: Integer
     DEFAULT_OPTIONS: Hash[Symbol, untyped]
 
-    type timeout_type = :connect_timeout | :settings_timeout | :operation_timeout | :keep_alive_timeout | :total_timeout
+    type timeout_type = :connect_timeout | :settings_timeout | :operation_timeout | :keep_alive_timeout | :total_timeout | :read_timeout | :write_timeout | :request_timeout
     type timeout = Hash[timeout_type, Numeric]
 
     def self.new: (?options) -> instance
@@ -65,6 +65,9 @@ module HTTPX
     # body
     attr_reader origin: URI::Generic?
 
+    # base_path
+    attr_reader base_path: String?
+
     # ssl
 
     # http2_settings

data/sig/plugins/circuit_breaker.rbs

@@ -0,0 +1,61 @@
+module HTTPX
+  module Plugins
+    module CircuitBreaker
+
+      class CircuitStore
+        @circuits: Hash[String, Circuit]
+
+        def try_open: (generic_uri uri, response response) -> void
+
+        def try_respond: (Request request) -> response?
+
+        private
+
+        def get_circuit_for_uri: (generic_uri uri) -> Circuit
+
+        def initialize: (Options & _CircuitOptions options) -> void
+      end
+
+      class Circuit
+        @state: :closed | :open | :half_open
+        @max_attempts: Integer
+        @reset_attempts_in: Float
+        @break_in: Float
+        @circuit_breaker_half_open_drip_rate: Float
+        @attempts: Integer
+
+        @response: response?
+        @opened_at: Float?
+        @attempted_at: Float?
+
+        def respond: () -> response?
+
+        def try_open: (response) -> void
+
+        def try_close: () -> void
+
+        private
+
+        def initialize: (Integer max_attempts, Float reset_attempts_in, Float break_in, Float circuit_breaker_half_open_drip_rate) -> void
+      end
+
+      interface _CircuitOptions
+        def circuit_breaker_max_attempts: () -> Integer
+        def circuit_breaker_reset_attempts_in: () -> Float
+        def circuit_breaker_break_in: () -> Float
+        def circuit_breaker_half_open_drip_rate: () -> Float
+        def circuit_breaker_break_on: () -> (^(Response) -> boolish | nil)
+      end
+
+      def self.load_dependencies: (singleton(Session)) -> void
+      def self.extra_options: (Options) -> (Options & _CircuitOptions)
+
+      module InstanceMethods
+        @circuit_store: CircuitStore
+      end
+
+    end
+
+    type sessionCircuitBreaker = Session & CircuitBreaker::InstanceMethods
+  end
+end

data/sig/plugins/compression/brotli.rbs

@@ -6,7 +6,7 @@ module HTTPX
         def self.configure: (singleton(Session)) -> void
 
         def self?.deflater: () -> _Deflater
-        def self?.decoder: (Numeric bytesize) -> Inflater
+        def self?.decoder: (Integer | Float bytesize) -> Inflater
 
         module Deflater
           extend _Deflater

data/sig/plugins/compression/deflate.rbs

@@ -6,7 +6,7 @@ module HTTPX
         def self.configure: (singleton(Session)) -> void
 
         def self?.deflater: () -> _Deflater
-        def self?.inflater: (Numeric bytesize) -> GZIP::Inflater
+        def self?.inflater: (Integer | Float bytesize) -> GZIP::Inflater
 
         module Deflater
           extend _Deflater

data/sig/plugins/compression/gzip.rbs

@@ -6,15 +6,15 @@ module HTTPX
         def self.configure: (singleton(Session)) -> void
 
         def self?.deflater: () -> _Deflater
-        def self?.inflater: (Numeric bytesize) -> Inflater
+        def self?.inflater: (Integer | Float bytesize) -> Inflater
 
         class Deflater
           include _Deflater
 
           @compressed_chunk: String
-          
+
           private
-          
+
           def initialize: () -> untyped
           def write: (string) -> void
           def compressed_chunk: () -> String

data/sig/plugins/compression.rbs

@@ -13,7 +13,7 @@ module HTTPX
       interface _Inflater
         def inflate: (string) -> String
 
-        def initialize: (Numeric bytesize) -> untyped
+        def initialize: (Integer | Float bytesize) -> untyped
       end
 
       def self.configure: (singleton(Session)) -> void

data/sig/plugins/multipart.rbs

@@ -61,7 +61,7 @@ module HTTPX
         @boundary: String
         @intermediate_boundary: String
 
-        def call: (Response response, untyped) -> Hash[String, untyped]
+        def call: (Response response, *untyped) -> Hash[String, untyped]
 
         private
 

data/sig/plugins/proxy/socks5.rbs

@@ -4,14 +4,15 @@ module HTTPX
   module Plugins
     module Proxy
       module Socks5
-      
+        VERSION: Integer
+
         module ConnectionMethods
           def __socks5_proxy_connect: () ->  void
           def __socks5_on_packet: (String packet) ->  void
           def __socks5_check_version: (int) -> void
           def __on_socks5_error: (string) -> void
         end
-        
+
         class SocksParser
           include Callbacks