httpx 0.20.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5a31aeffa012bd1eea19c1e892c8669624de0d21c9cd8911ae025375f0b93fb
-  data.tar.gz: 285707682eb2d1451106d28bc2d4a8ceb247d4237139c9e7d83bd5a0163b5a5c
+  metadata.gz: 0162427fe818aafee88a35a12a821cf4f1016701f4513835c91556a7e8579e9e
+  data.tar.gz: f559d77efcdbf0e557c28c9a012cb67f45a95de8f8c2fac521800679ea30dc31
 SHA512:
-  metadata.gz: 6f2c50aa8895c6f07ed0acbca1b1171343da2b55bc838ae7f2a0f7a44300c101ea0020938946bf630b80ad6b81bed3cb54910b0734576b6e7c000e058497128c
-  data.tar.gz: 83e19a86d841056821d9198c9a8e3e7b06ec354445289a1fd7d612d070b02b0a01aa9f45f5acdb0b35e4da413c2c3955646e5f55c5421db95879092a0a3aa377
+  metadata.gz: 1dd2fa825bdaef26137e8c5d993dcb426eab7897adc8570a343863e7842f3732948bdc827c58e1e361bb35b2c1d549b02d89051a592a836a51f39afb95a77263
+  data.tar.gz: 8a64f6fc512fd8fa60d7feeffff6447d3c8a4081fe6494873b4a527f425dad090ca84b810a2a91477b051a4dfeb0bbb12e0563ef37c20e8d5daab05f2a208138

data/LICENSE.txt

@@ -189,51 +189,3 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-
-
-* lib/httpx/domain_name.rb
-
-This file is derived from the implementation of punycode available at
-here:
-
-https://www.verisign.com/en_US/channel-resources/domain-registry-products/idn-sdks/index.xhtml
-
-Copyright (C) 2000-2002 Verisign Inc., All rights reserved.
-
-Redistribution and use in source and binary forms, with or
-without modification, are permitted provided that the following
-conditions are met:
-
- 1) Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
- 2) Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in
-    the documentation and/or other materials provided with the
-    distribution.
-
- 3) Neither the name of the VeriSign Inc. nor the names of its
-    contributors may be used to endorse or promote products derived
-    from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
-This software is licensed under the BSD open source license. For more
-information visit www.opensource.org.
-
-Authors:
- John Colosi (VeriSign)
- Srikanth Veeramachaneni (VeriSign)
- Nagesh Chigurupati (Verisign)
- Praveen Srinivasan(Verisign)

data/README.md

@@ -1,8 +1,8 @@
 # HTTPX: A Ruby HTTP library for tomorrow... and beyond!
 
 [![Gem Version](https://badge.fury.io/rb/httpx.svg)](http://rubygems.org/gems/httpx)
-[![pipeline status](https://gitlab.com/honeyryderchuck/httpx/badges/master/pipeline.svg)](https://gitlab.com/honeyryderchuck/httpx/pipelines?page=1&scope=all&ref=master)
-[![coverage report](https://gitlab.com/honeyryderchuck/httpx/badges/master/coverage.svg?job=coverage)](https://honeyryderchuck.gitlab.io/httpx/coverage/#_AllFiles)
+[![pipeline status](https://gitlab.com/os85/httpx/badges/master/pipeline.svg)](https://gitlab.com/os85/httpx/pipelines?page=1&scope=all&ref=master)
+[![coverage report](https://gitlab.com/os85/httpx/badges/master/coverage.svg?job=coverage)](https://os85.gitlab.io/httpx/coverage/#_AllFiles)
 
 HTTPX is an HTTP client library for the Ruby programming language.
 
@@ -19,13 +19,17 @@ And also:
 
 * Compression (gzip, deflate, brotli)
 * Streaming Requests
-* Authentication (Basic Auth, Digest Auth)
+* Auth (Basic Auth, Digest Auth, NTLM)
 * Expect 100-continue
 * Multipart Requests
-* Cookies
+* Advanced Cookie handling
 * HTTP/2 Server Push
-* H2C Upgrade
+* HTTP/1.1 Upgrade (support for "h2c", "h2")
 * Automatic follow redirects
+* GRPC
+* WebDAV
+* Circuit Breaker
+* HTTP-based response cache
 * International Domain Names
 
 ## How
@@ -36,7 +40,14 @@ Here are some simple examples:
 HTTPX.get("https://nghttp2.org").to_s #=> "<!DOCT...."
 ```
 
-And that's the simplest one there is.
+And that's the simplest one there is. But you can also do:
+
+```ruby
+HTTPX.post("http://example.com", form: { user: "john", password: "pass" })
+
+http = HTTPX.with(headers: { "x-my-name" => "joe" })
+http.patch("http://example.com/file", body: File.open("path/to/file")) # request body is streamed
+```
 
 If you want to do some more things with the response, you can get an `HTTPX::Response`:
 
@@ -73,76 +84,74 @@ and then just require it in your program:
 require "httpx"
 ```
 
-## Why Should I care?
+## What makes it the best ruby HTTP client
 
-In Ruby, HTTP client implementations are a known cheap commodity. Why this one?
 
-### Concurrency
+### Concurrency, HTTP/2 support
 
-This library supports HTTP/2 seamlessly (which means, if the request is secure, and the server support ALPN negotiation AND HTTP/2, the request will be made through HTTP/2). If you pass multiple URIs, and they can utilize the same connection, they will run concurrently in it.
+`httpx` supports HTTP/2 (for "https" requests, it'll automatically do ALPN negotiation). However if the server supports HTTP/1.1, it will use HTTP pipelining, falling back to 1 request at a time if the server doesn't support it either (and it'll use Keep-Alive connections, unless the server does not support).
 
-However if the server supports HTTP/1.1, it will try to use HTTP pipelining, falling back to 1 request at a time if the server doesn't support it (if the server support Keep-Alive connections, it will reuse the same connection).
+If you passed multiple URIs, it'll perform all of the requests concurrently, by mulitplexing on the necessary sockets (and it'll batch requests to the same socket when the origin is the same):
+
+```ruby
+HTTPX.get(
+  "https://news.ycombinator.com/news",
+  "https://news.ycombinator.com/news?p=2",
+  "https://google.com/q=me"
+) # first two requests will be multiplexed on the same socket.
+```
 
 ### Clean API
 
 `httpx` builds all functions around the `HTTPX` module, so that all calls can compose of each other. Here are a few examples:
 
 ```ruby
-response = HTTPX.get("https://www.google.com")
-response = HTTPX.post("https://www.nghttp2.org/httpbin/post", params: {name: "John", age: "22"})
-response = HTTPX.plugin(:basic_authentication)
-                .basic_authentication("user", "pass")
+response = HTTPX.get("https://www.google.com", params: { q: "me" })
+response = HTTPX.post("https://www.nghttp2.org/httpbin/post", form: { name: "John", age: "22" })
+response = HTTPX.plugin(:basic_auth)
+                .basic_auth("user", "pass")
                 .get("https://www.google.com")
+
+# more complex client objects can be cached, and are thread-safe
+http = HTTPX.plugin(:expect).with(headers: { "x-pvt-token" => "TOKEN" })
+http.get("https://example.com") # the above options will apply
+http.post("https://example2.com", form: { name: "John", age: "22" }) # same, plus the form POST body
 ```
 
 ### Lightweight
 
-It ships with a plugin system similar to the ones used by [sequel](https://github.com/jeremyevans/sequel), [roda](https://github.com/jeremyevans/roda) or [shrine](https://github.com/janko-m/shrine).
+It ships with most features published as a plugin, making vanilla `httpx` lightweight and dependency-free, while allowing you to "pay for what you use"
 
-It means that it loads the bare minimum to perform requests, and the user has to explicitly load the plugins, in order to get the features he/she needs.
+The plugin system is similar to the ones used by [sequel](https://github.com/jeremyevans/sequel), [roda](https://github.com/jeremyevans/roda) or [shrine](https://github.com/shrinerb/shrine).
 
-It also means that it ships with the minimum amount of dependencies.
+### Advanced DNS features
 
-### DNS-over-HTTPS
+`HTTPX` ships with custom DNS resolver implementations, including a native Happy Eyeballs resolver implementation, and a DNS-over-HTTPS resolver.
 
-`HTTPX` ships with custom DNS resolver implementations, including a DNS-over-HTTPS resolver.
+## User-driven test suite
 
-## Easy to test
-
-The test suite runs against [httpbin proxied over nghttp2](https://nghttp2.org/httpbin/), so there are no mocking/stubbing false positives. The test suite uses [minitest](https://github.com/seattlerb/minitest), but its matchers usage is (almost) limited to `#assert` (`assert` is all you need).
+The test suite runs against [httpbin proxied over nghttp2](https://nghttp2.org/httpbin/), so actual requests are performed during tests.
 
 ## Supported Rubies
 
-All Rubies greater or equal to 2.1, and always latest JRuby and Truffleruby.
+All Rubies greater or equal to 2.7, and always latest JRuby and Truffleruby.
 
-**Note**: This gem is tested against all latest patch versions, i.e. if you're using 2.2.0 and you experience some issue, please test it against 2.2.10 (latest patch version of 2.2) before creating an issue.
+**Note**: This gem is tested against all latest patch versions, i.e. if you're using 3.3.0 and you experience some issue, please test it against 3.3.$latest before creating an issue.
 
 ## Resources
-|               |                                                     |
-| ------------- | --------------------------------------------------- |
-| Website       | https://honeyryderchuck.gitlab.io/httpx/            |
-| Documentation | https://honeyryderchuck.gitlab.io/httpx/rdoc/       |
-| Wiki          | https://gitlab.com/honeyryderchuck/httpx/wikis/home |
-| CI            | https://gitlab.com/honeyryderchuck/httpx/pipelines  |
+|               |                                                        |
+| ------------- | ------------------------------------------------------ |
+| Website       | https://honeyryderchuck.gitlab.io/httpx/               |
+| Documentation | https://honeyryderchuck.gitlab.io/httpx/rdoc/          |
+| Wiki          | https://honeyryderchuck.gitlab.io/httpx/wiki/home.html |
+| CI            | https://gitlab.com/os85/httpx/pipelines                |
+| Rubygems      | https://rubygems.org/gems/httpx                        |
 
 ## Caveats
 
-### ALPN support
-
-`HTTPS` TLS backend is ruby's own `openssl` gem.
-
-If your requirement is to run requests over HTTP/2 and TLS, make sure you run a version of the gem which compiles OpenSSL 1.0.2 (Ruby 2.3 and higher are guaranteed to).
-
-In order to use HTTP/2 under JRuby, [check this link](https://gitlab.com/honeyryderchuck/httpx/-/wikis/JRuby-Truffleruby-Other-Rubies) to know what to do.
-
-### Known bugs
-
-* Doesn't work with ruby 2.4.0 for Windows (see [#36](https://gitlab.com/honeyryderchuck/httpx/issues/36)).
-* Using `total_timeout` along with the `:persistent` plugin [does not work as you might expect](https://gitlab.com/honeyryderchuck/httpx/-/wikis/Timeouts#total_timeout).
-
 ## Versioning Policy
 
-Although 0.x software, `httpx` is considered API-stable and production-ready, i.e. current API or options may be subject to deprecation and emit log warnings, but can only effectively be removed in a major version change.
+`httpx` follows Semantic Versioning.
 
 ## Contributing
 

data/doc/release_notes/0_10_0.md

@@ -15,7 +15,7 @@ http.get(stream_api_endpoint, stream: true).each_line do |line|
 end
 ```
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Stream
+https://gitlab.com/os85/httpx/-/wikis/Stream
 
 ### Rate Limiter
 
@@ -27,7 +27,7 @@ HTTPX.plugin(:rate_limiter).get(rate_limited_api_endpoint)
 # waits 3 seconds before retrying
 ```
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Rate-Limiter
+https://gitlab.com/os85/httpx/-/wikis/Rate-Limiter
 
 ### Ruby 3
 

data/doc/release_notes/0_11_0.md

@@ -21,7 +21,7 @@ stub_http_request(:get, "https://www.google.com").and_return(status: 200, body:
 
 ```
 
-Read more about it in the [webmock integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Webmock-Adapter).
+Read more about it in the [webmock integration documentation](https://os85.gitlab.io/httpx/wiki/Webmock-Adapter).
 
 ### Datadog Adapter
 
@@ -40,7 +40,7 @@ A trace will be emitted for every request, so this should be an interesting visu
 
 Customization options and traces are similar to what [the net-http adapter provides](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#nethttp).
 
-Read more about it in the [datadog integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Datadog-Adapter).
+Read more about it in the [datadog integration documentation](https://os85.gitlab.io/httpx/wiki/Datadog-Adapter).
 
 ## Improvements
 
@@ -52,7 +52,7 @@ Read more about it in the [datadog integration documentation](https://honeyryder
 HTTPX.plugin(:multipart).post(uri, form: {file: File.new("path/to/file")})
 ```
 
-Read more about it in the [multipart plugin documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Multipart-Uploads), including also about why this was made.
+Read more about it in the [multipart plugin documentation](https://os85.gitlab.io/httpx/wiki/Multipart-Uploads), including also about why this was made.
 
 ### Expect Plugin
 
@@ -72,5 +72,3 @@ response = session.get(proxy_ip, headers: { "host" => upstream_hostname }, ssl:
 ## Bugfixes
 
 A default 5 second timeout is in-place when using the DNS `:system` resolver, as it was found out that. when using the `resolv` library, the DNS query will not be retried otherwise. You can change this setting py passing `resolver_options: { timeouts: ANOTHER_TIMEOUT}`. In the future, this may become another timeout option, however.
-
-

data/doc/release_notes/0_12_0.md

@@ -6,19 +6,19 @@
 
 A new plugin, `:aws_sigv4`, is now shipped with `httpx`. It implements the [AWS Signature Version 4 request signing process](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html), a well documented way of authenticating requests to AWS services, which has since been adopted by other cloud providers, such as Google Cloud Storage.
 
-See how to use it here: https://gitlab.com/honeyryderchuck/httpx/-/wikis/AWS-Sigv4#sessionaws_sigv4_authentication
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#sessionaws_sigv4_authentication
 
 For convenience, there's a derivative plugin, `:aws_sdk_authentication`, which builds on top of `:aws_sigv4`, and integrates with the `aws-sdk-core` gem, maintained by AWS, to resolve the authentication credentials (p.ex. if you support ephemeral access keys).
 
-See how to use it here: https://gitlab.com/honeyryderchuck/httpx/-/wikis/AWS-Sigv4#sessionaws_sdk_authentication
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#sessionaws_sdk_authentication
 
-Other FAQ: https://gitlab.com/honeyryderchuck/httpx/-/wikis/AWS-Sigv4#faqs
+Other FAQ: https://gitlab.com/os85/httpx/-/wikis/AWS-Sigv4#faqs
 
 ### HTTP/2 support for JRuby
 
 `jruby-openssl` doesn't support ALPN protocol negotiation, nor are there plans to implement, which limited the seamless HTTP/2 usage in `httpx`. A new connection adapter was therefore added specifically for JRuby, where ssl/tls connections will be handled using ffi-based openssl bindings, provided you bundle `ffi-compiler` and `concurrent-ruby`, and install a TLS/1.2-compatible `openssl` package.
 
-See how to use it here: https://gitlab.com/honeyryderchuck/httpx/-/wikis/JRuby-Truffleruby-Other-Rubies#http2
+See how to use it here: https://gitlab.com/os85/httpx/-/wikis/JRuby-Truffleruby-Other-Rubies#http2
 
 ## Improvements
 
@@ -52,4 +52,4 @@ They all contributed to a massive performance improvement, itself reflected in t
 * Fixed TCP handshake Errno::INPROGRESS handling inside TLS connnections, which was causing the process to hang in a high handshake contention scenario;
 * Do not call the event loop if there's nothing to listen on (the DoH resolver was being listened on even if there was nothing to be request);
 * Fixed double event registry for DoH resolvers;
-* 
+*

data/doc/release_notes/0_13_0.md

@@ -4,9 +4,9 @@
 
 ### Upgrade plugin
 
-A new plugin, `:upgrade`, is now available. This plugin allows one to "hook" on HTTP/1.1's protocol upgrade mechanism (see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism), which is the mechanism that browsers use to initiate websockets (there is an example of how to use `httpx` to start a websocket client connection [in the tests](https://gitlab.com/honeyryderchuck/httpx/-/blob/master/test/support/requests/plugins/upgrade.rb))
+A new plugin, `:upgrade`, is now available. This plugin allows one to "hook" on HTTP/1.1's protocol upgrade mechanism (see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism), which is the mechanism that browsers use to initiate websockets (there is an example of how to use `httpx` to start a websocket client connection [in the tests](https://gitlab.com/os85/httpx/-/blob/master/test/support/requests/plugins/upgrade.rb))
 
-You can read more about the `:upgrade` plugin in the [wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Upgrade).
+You can read more about the `:upgrade` plugin in the [wiki](https://os85.gitlab.io/httpx/wiki/Connection-Upgrade).
 
 It's the basis of two plugins:
 
@@ -14,13 +14,13 @@ It's the basis of two plugins:
 
 This plugin was been rewritten on top of the `:upgrade` plugin, and handles upgrading a plaintext (non-"https") HTTP/1.1 connection, into an HTTP/2 connection.
 
-https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Upgrade#h2c
+https://os85.gitlab.io/httpx/wiki/Connection-Upgrade#h2c
 
 #### `:upgrade/h2`
 
 This plugin handles when a server responds to a request with an `Upgrade: h2` header, does the following requests to the same origin via HTTP/2 prior knowledge (bypassing the necessity for ALPN negotiation, which is the whole point of the feature).
 
-https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Upgrade#h2
+https://os85.gitlab.io/httpx/wiki/Connection-Upgrade#h2
 
 ### `:addresses` option
 
@@ -34,7 +34,7 @@ HTTPX.get("http://example.com", addresses: %w[172.5.3.1 172.5.3.2]))
 You should also use it to connect to HTTP servers bound to a UNIX socket, in which case you'll have to provide a path:
 
 ```ruby
-HTTPX.get("http://example.com", addresses: %w[/path/to/usocket]))
+HTTPX.get("http://example.com", transport: "unix", addresses: %w[/path/to/usocket]))
 ```
 
 The `:transport_options` are therefore deprecated, and will be moved in a major version.

data/doc/release_notes/0_14_0.md

@@ -17,7 +17,7 @@ helloworld_svc = helloworld_stub.rpc(:SayHello, HelloRequest, HelloReply)
 result = helloworld_svc.say_hello(HelloRequest.new(name: "Jack")) #=> HelloReply: "Hello Jack"
 ```
 
-You can read more about the `:grpc` plugin in the [wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/GRPC).
+You can read more about the `:grpc` plugin in the [wiki](https://os85.gitlab.io/httpx/wiki/GRPC).
 
 ### :origin
 
@@ -37,7 +37,7 @@ httpbin.get("/httpbin/get") #=> #<Response:5420 HTTP/2.0 @status=200 ....
 * setting an unexpected option will now raise an `HTTPX::Error` with an helpful message, instead of a confusing `NoMethodError`:
 
 ```ruby
-HTTPX.with(foo: "bar") 
+HTTPX.with(foo: "bar")
 # before
 #=> NoMethodError
 # after

data/doc/release_notes/0_16_0.md

@@ -16,7 +16,7 @@ response.body.to_s #=> ""
 
 The justification for this behaviour probably had to do with avoiding keeping huge payloads around, but it got a bit lost in git history. It became a feature, not a bug.
 
-However, I got an [issue report](https://gitlab.com/honeyryderchuck/httpx/-/issues/143) that made me change my mind about this behaviour (tl;dr: it broke pattern matching when matching against response bodies more than once).
+However, I got an [issue report](https://gitlab.com/os85/httpx/-/issues/143) that made me change my mind about this behaviour (tl;dr: it broke pattern matching when matching against response bodies more than once).
 
 So now, you can call `.to_s` how many times you want!
 
@@ -62,7 +62,7 @@ stub.get_feature(# ...
 
 ### OptionsMethods for plugins
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Custom-Plugins
+https://gitlab.com/os85/httpx/-/wikis/Custom-Plugins
 
 You can now define an `OptionsMethods` module under your custom plugin to define your own methods. The tl;dr is, that, given the following module below, a new `:bar` option will be available (and the method will be used to set it):
 
@@ -80,7 +80,7 @@ HTTPX.plugin(CustomPlugin).with(bar: 2)
 
 The behaviour of the cookies jar from the `:cookies` plugin was a bit unpredictable in certain conditions, for instance if a "Cookie" header would be passed directly via `.with(headers: {"Cookie" => "a=1"})` and there'd be a value for it already (in same cases, it'd be fully ignored). This would even get worse, if the session had a jar, and a specific set of cookies would be passed to a request(i.e.: `session_with_cookies.get("http://url.get", headers: {"Cookies" => "..."}`).
 
-The behaviour was fixed, and is now specced under https://gitlab.com/honeyryderchuck/httpx/-/blob/master/test/support/requests/plugins/cookies.rb .
+The behaviour was fixed, and is now specced under https://gitlab.com/os85/httpx/-/blob/master/test/support/requests/plugins/cookies.rb .
 
 ## Bugfixes
 

data/doc/release_notes/0_17_0.md

@@ -4,7 +4,7 @@
 
 ### Response mime type decoders (#json, #form)
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Response-Handling#response-decoding
+https://gitlab.com/os85/httpx/-/wikis/Response-Handling#response-decoding
 
 Two new methods, `#json` and `#form`, were added to `HTTPX::Response`. As the name implies, they'll decode the raw payload into ruby objects you can work with.
 

data/doc/release_notes/0_18_0.md

@@ -4,7 +4,7 @@
 
 ### Response Cache
 
-https://gitlab.com/honeyryderchuck/httpx/-/wikis/Response-Cache
+https://gitlab.com/os85/httpx/-/wikis/Response-Cache
 
 The `:response_cache` plugin handles transparent usage of HTTP caching and conditional requests to improve performance and bandwidth usage.
 
@@ -22,7 +22,7 @@ r1.body == r2.body #=> true
 
 On the `:retries` plugin, jitter calculation is now applied to the value in seconds defined by user after which a request should be retried (i.e. if `:retry_after` option is set to `2`, the retry interval may be `1.5422312` seconds, for example). This is important to avoid cases of synchronized "thundering herd", where server rejects requests, but they all get retried at the same time because the retry interval is exactly the same.
 
-You can override the jitter calculation function by using the [:retry_jitter](https://gitlab.com/honeyryderchuck/httpx/-/wikis/Retries#retry_jitter) option:
+You can override the jitter calculation function by using the [:retry_jitter](https://gitlab.com/os85/httpx/-/wikis/Retries#retry_jitter) option:
 
 ```ruby
 HTTPX.plugin(:retries, retry_after: 2, retry_jitter: ->(interval) { interval + rand }) # interval is 3
@@ -44,7 +44,7 @@ end
 
 ## Improvements
 
-* `webmock` adapter: added support for "stub_http_request#to_timeout" (https://gitlab.com/honeyryderchuck/httpx/-/merge_requests/165).
+* `webmock` adapter: added support for "stub_http_request#to_timeout" (https://gitlab.com/os85/httpx/-/merge_requests/165).
 
 ## timers not a dependency
 
@@ -57,7 +57,7 @@ The functionality provided by the `timers` gem was replaced by a simpler custom
 
 ## Bugfixes
 
-* Fixed Error class declaration on response decoders when mime type is invalid (https://gitlab.com/honeyryderchuck/httpx/-/merge_requests/166).
+* Fixed Error class declaration on response decoders when mime type is invalid (https://gitlab.com/os85/httpx/-/merge_requests/166).
 * `ErrorResponse#to_s` now removes ANSI escape sequences from error backtraces.
 * Persistent connections were kept around both in the pool and in the selector; the first is necessary, but the second caused busy loop scenarios all over; they are now removed when no requests are being handled.
 * Connections which failed connection handshake were removed from the pool, but not from the selector list, causing busy loop scenarios in a few cases; this has been fixed.

data/doc/release_notes/0_18_2.md

@@ -7,4 +7,4 @@
 
 ## Chore
 
-The quirk of using the `:persistent` plugin with `:total_timeout` has been documented: https://gitlab.com/honeyryderchuck/httpx/-/wikis/Timeouts#total_timeout.
+The quirk of using the `:persistent` plugin with `:total_timeout` has been documented: https://gitlab.com/os85/httpx/-/wikis/Timeouts#total_timeout.

data/doc/release_notes/0_19_0.md

@@ -28,7 +28,7 @@ Connection coalescing has also been enabled for proxied connections (also `CONNE
 
 ### curl-to-httpx
 
-widget in [project website](https://honeyryderchuck.gitlab.io/httpx/) to turn curl commands into the equivalent `httpx` code.
+widget in [project website](https://os85.gitlab.io/httpx/) to turn curl commands into the equivalent `httpx` code.
 
 ## Bugfixes
 

data/doc/release_notes/0_19_8.md

@@ -1,4 +1,4 @@
-# 0.19.7
+# 0.19.8
 
 ## Bugfixes
 

data/doc/release_notes/0_20_0.md

@@ -1,10 +1,10 @@
-# 0.19.0
+# 0.20.0
 
 ## Features
 
 ### Sentry integration
 
-Documentation: https://gitlab.com/honeyryderchuck/httpx/-/wikis/Sentry-Adapter
+Documentation: https://gitlab.com/os85/httpx/-/wikis/Sentry-Adapter
 
 `httpx` ships with integration for `sentry-ruby` to provide HTTP request specific breadcrumbs and tracing. It can be enabled via:
 

data/doc/release_notes/0_20_1.md

@@ -0,0 +1,5 @@
+# 0.20.1
+
+## Bugfixes
+
+* bugfix for unregistering connections when timing out on DNS resolving; this wasn't happening, leaving a few cases where requests to the same domain timing out on resolution would hang on the second request.

data/doc/release_notes/0_20_2.md

@@ -0,0 +1,7 @@
+# 0.20.2
+
+## Bugfixes
+
+* fix for selector timeout errors closing all connections and ignoring resolvers.
+
+Timeout errors on select were being propagated to all pooled connections, although not all of them were being selected on, and not all of them having timed out. plus, resolver timeouts were doing the same, making connections fail with connection timeout error, rather than resolve timeout error. A patch was implemented, where the selector now yields an error to the selected connections, rather than plain raising exception.

data/doc/release_notes/0_20_3.md

@@ -0,0 +1,6 @@
+# 0.20.3
+
+## Bugfixes
+
+* DoH resolver wasn't working for non-absolute (the large majority) of domains since v0.19.
+* Allowing a single IP string to be passed to the resolver option `:nameserver` (just like the `resolv` library does), besides the already supported list of IPs.

data/doc/release_notes/0_20_4.md

@@ -0,0 +1,17 @@
+# 0.20.4
+
+## Improvements
+
+The `:response_cache` plugin is now more compliant with how the RFC 2616 defines which behaviour caches shall have:
+
+* it caches only responses with one of the following status codes: 200, 203, 300, 301, 410.
+* it discards cached responses which become stale.
+* it supports "cache-control" header directives to decided when to cache, to store, what the response "age" is.
+* it can cache more than one response for the same request, provided that the request presents different header values for the headers declared in the "vary" response header (previously, it was only caching the first response, and discarding the remainder).
+
+
+
+## Bugfixes
+
+* fixed DNS resolution bug which caused a loop when a failed connection attempt would cause a new DNS request to be triggered for the same domain, filling up and giving preference to the very IP which failed the attempt.
+* response_cache: request verb is now taken into account, not causing HEAD/GET confusion for the same URL.

data/doc/release_notes/0_20_5.md

@@ -0,0 +1,3 @@
+# 0.20.5
+
+The `intersect?` refinement introduced in the previous version had a wrong variable name.

data/doc/release_notes/0_21_0.md

@@ -0,0 +1,96 @@
+# 0.21.0
+
+## Features
+
+### `:write_timeout`, `:read_timeout` and `:request_timeout`
+
+https://gitlab.com/os85/httpx/-/wikis/Timeouts
+
+The following timeouts are now supported:
+
+* `:write_timeout`: total time (in seconds) to write a request to the server;
+* `:read_timeout`: total time (in seconds) to read a response from the server;
+* `:request_timeout`: tracks both of the above (time to write the request and read a response);
+
+```ruby
+HTTPX.with(timeout: { request_timeout: 60}).get(...
+```
+
+Just like `:connect_timeout`, the new timeouts are deadline-oriented, rather than op-oriented, meaning that they do not reset on each socket operation (as most ruby HTTP clients do).
+
+None of them has a default value, in order not to break integrations, but that'll change in a future v1, where they'll become the default timeouts.
+
+### Circuit Breaker plugin
+
+https://gitlab.com/os85/httpx/-/wikis/Circuit-Breaker
+
+The `:circuit_breaker` plugin wraps around errors happening when performing HTTP requests, and support options for setting maximum number of attempts before circuit opens (`:circuit_breaker_max_attempts`), period after which attempts should be reset (`:circuit_breaker_reset_attempts_in`), timespan until circuit half-opens (`circuit_breaker_break_in`), respective half-open drip rate (`:circuit_breaker_half_open_drip_rate`), and a callback to do your own check on whether a response has failed, in case you want HTTP level errors to be marked as failed attempts (`:circuit_breaker_break_on`).
+
+Read the wiki for more info about the defaults.
+
+```ruby
+http = HTTPX.plugin(:circuit_breaker)
+# that's it!
+http.get(...
+```
+
+### WebDAV plugin
+
+https://gitlab.com/os85/httpx/-/wikis/WebDav
+
+The `:webdav` introduces some "convenience" methods to perform common WebDAV operations.
+
+```ruby
+webdav = HTTPX.plugin(:webdav, origin: "http://webdav-server")
+              .plugin(:digest_authentication).digest_auth("user", "pass")
+
+res = webdav.put("/file.html", body: "this is the file body")
+res = webdav.copy("/file.html", "/newdir/copy.html")
+# ...
+```
+
+### XML transcoder, `:xml` option and `response.xml`
+
+A new transcoder was added fot the XML mime type, which requires `"nokogiri"` to be installed. It can both serialize Nokogiri nodes in a request, and parse response content into nokogiri nodes:
+
+```ruby
+response = HTTPX.post("https://xml-server.com", xml: Nokogiri::XML("<xml ..."))
+response.xml #=> #(Document:0x16e4 { name = "document", children = ...
+```
+
+## Improvements
+
+### `:proxy` plugin: `:no_proxy` option
+
+Support was added, in the `:proxy` plugin, to declare domains, either via regexp patterns, or strings, for which requests should bypass the proxy.
+
+```ruby
+http = HTTPX.plugin(:proxy).with_proxy(
+    uri: "http://10.10.0.1:51432",
+    no_proxy: ["gitlab.local", /*.google.com/]
+)
+http.get("https://duckduckgo.com/?q=httpx") #=> proxied
+http.get("https://google.com/?q=httpx") #=> not proxied
+http.get("https://gitlab.com") #=> proxied
+http.get("https://gitlab.local") #=> not proxied
+```
+
+### OOTB support for other JSON libraries
+
+If one of `multi_json`, `oj` or `yajl` is available, all `httpx` operations doing JSON parsing or dumping will use it (the `json` standard library will be used otherwise).
+
+```ruby
+require "oj"
+require "httpx"
+
+response = HTTPX.post("https://somedomain.json", json: { "foo" => "bar" }) # will use "oj"
+puts response.json # will use "oj"
+```
+
+## Bugfixes
+
+* `:expect` plugin: `:expect_timeout` can accept floats (not just integers).
+
+## Chore
+
+* DoH `:https` resolver: support was removed for the "application/dns-json" mime-type (it was only supported in practice by the Google DoH resolver, which has since added support for the standardized "application/dns-message").