requests_ruby 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 308045ed13c88c9a9eb1f89a483692c177b605e6aaac49e4eafa7aa0de2a3a74
-  data.tar.gz: 7f62813cf1d17285f51b10a79bd4b5f08ea1f91e71172b7b50a9ab416330bcfd
+  metadata.gz: 8b4146e6fbead1e412259712bcd0939b7971d542bd94a41007e210c9c51de37c
+  data.tar.gz: bbc39cd987b00d948be87f9b02251d2e058016123c6ad2fda16724d921575f24
 SHA512:
-  metadata.gz: a26999d7ae3f856351a416736f08ff8d1ebd5fb21addd94bcee508d30f3d49de7af9e09c8ea52dc4d4c61bd81126ad884bb3203c5349552863930f2e33cc7a82
-  data.tar.gz: f199826c39a900bab90eba7445218b0c9c0f8830a7e33f588591667551c58f53f2c206c26424fcaae51cb207652611baba2ec70648c1138487b9c8ab66f89dc9
+  metadata.gz: 658ca79dbadae76f08300daa6ef77b5302bf8c8b2a42877659b490ffdc8359cc07f4c61ff79b56e181f3a4173d9474f5447170420198ee3bb8ded744404f58d1
+  data.tar.gz: 37e529b01d2a6406e86332e1ce10835c1b124b7076ceba696da237c215a0e3dab48a570e526dd75b614a95bce426bd1ce87c2a76035867d78fd45f33fa2fef5e

data/CHANGELOG.md

@@ -1,7 +1,36 @@
 # Changelog
 
-<<<<<<< HEAD
-=======
+## 1.0.4
+
+Adds real HTTP/2 support and rounds off a handful of gaps that showed up
+against Python's `requests` (and `requests`+`urllib3`) feature set.
+
+### Added
+- **HTTP/2 support**, implemented from scratch on top of stdlib
+  `Socket`/`OpenSSL` (ALPN negotiation, HPACK header compression with
+  Huffman coding, frame multiplexing, flow control) - no external gems.
+  `Requests::Http2Adapter` is a drop-in `HTTPAdapter` replacement:
+  `Requests::Session.new(http2: true)`, `session.http2!`, or per-call
+  `http2: true` on any request/`download`. Transparently falls back to
+  HTTP/1.1 for plain `http://` URLs, proxied requests, or servers that
+  don't negotiate `h2` over ALPN.
+- `Session#trust_env` (default `true`) - proxies are now picked up from
+  `HTTP_PROXY`/`HTTPS_PROXY`/`NO_PROXY` (and lowercase variants) when no
+  explicit `proxies:` is set, matching python `requests`' default
+  behavior. Set `session.trust_env = false` to opt out.
+- Retry backoff now honors a server's `Retry-After` header (seconds or
+  HTTP-date) when retrying a status in `status_forcelist`, instead of
+  always using the fixed `backoff_factor * attempt` formula.
+- `Session#head!` / `#options!` and module-level `Requests.get!` /
+  `#post!` / `#put!` / `#patch!` / `#delete!` / `#head!` / `#options!` -
+  the raise-on-error helpers now cover every verb at both levels.
+- `Requests.session(**opts)` now forwards keyword args (e.g.
+  `Requests.session(http2: true)`) instead of always building a bare
+  `Session.new`.
+
+### Fixed
+- Resolved a leftover unresolved git merge conflict in this file.
+
 ## 1.0.3
 
 Focused on the two things people actually hit walls on with a stdlib-only
@@ -40,7 +69,6 @@ behave like cookies instead of a flat global hash.
   `backoff_factor`, or `status_forcelist` no longer gets silently
   overwritten back to the session's defaults on the next request.
 
->>>>>>> cf89f78 (v1.0.3)
 ## 1.0.2
 
 Big cleanup pass. Split the single `lib/requests.rb` file into a proper

data/README.md

@@ -4,6 +4,7 @@ A zero-dependency, stdlib-only HTTP client for Ruby, modeled closely on Python's
 
 [![Gem Version](https://img.shields.io/badge/gem-requests__ruby-red?logo=rubygems)](https://rubygems.org/gems/requests_ruby)
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.7-CC342D?logo=ruby)](https://www.ruby-lang.org)
+[![Gem Downloads](https://img.shields.io/gem/dt/requests_ruby)](https://rubygems.org/gems/requests_ruby)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Zero Dependencies](https://img.shields.io/badge/dependencies-zero-brightgreen)](requests_ruby.gemspec)
 
@@ -29,6 +30,7 @@ A zero-dependency, stdlib-only HTTP client for Ruby, modeled closely on Python's
   - [Streaming & downloads](#streaming--downloads)
   - [Downloading big files in chunks](#downloading-big-files-in-chunks)
   - [Connection pooling](#connection-pooling)
+  - [HTTP/2](#http2)
   - [Custom transport adapters](#custom-transport-adapters)
   - [Status codes](#status-codes)
 - [API reference](#-api-reference)
@@ -221,13 +223,18 @@ Requests.get(url, timeout: [3, 10])    # [connect, read]
 # retry transient connection errors on idempotent methods (GET/HEAD/OPTIONS/PUT/DELETE)
 s = Requests::Session.new
 s.retries = 3
-s.backoff_factor = 0.5   # sleeps 0.5s, 1s, 1.5s between attempts
+s.backoff_factor = 0.5   # sleeps 0.5s, 1s, 1.5s between attempts, unless...
+s.status_forcelist = [429, 502, 503, 504] # ...also retry these response codes
 s.get(url)
 
 # or per-request
 Requests.get(url, retries: 3)
 ```
 
+A response in `status_forcelist` that comes back with a `Retry-After`
+header (seconds or an HTTP date) is retried after that delay instead of
+the `backoff_factor` formula.
+
 ### Proxies & SSL
 
 ```ruby
@@ -236,6 +243,12 @@ Requests.get(url, verify: false)               # skip cert verification (careful
 Requests.get(url, verify: '/path/to/ca.pem')   # custom CA bundle
 ```
 
+By default (`session.trust_env = true`), a `Session` without an explicit
+`proxies:` picks one up from the `HTTP_PROXY`/`HTTPS_PROXY`/`NO_PROXY`
+environment variables (lowercase names also work), same as python
+`requests`. Set `session.trust_env = false` to ignore the environment
+entirely.
+
 A bundled `cacert.pem` (Mozilla's CA bundle) ships with the gem and is used by default. Override it globally with the `REQUESTS_CA_FILE` environment variable.
 
 ### Cookies
@@ -332,6 +345,28 @@ it's transparently dropped and reopened on the next request; combined with
 `retries`/`backoff_factor` this makes long-lived sessions much more resilient
 than opening a fresh connection per call.
 
+### HTTP/2
+
+As of 1.0.4, `Requests::Http2Adapter` speaks HTTP/2 directly over
+`Socket`/`OpenSSL` - ALPN negotiation, HPACK header compression, and
+stream multiplexing/flow control, all stdlib, no external gem:
+
+```ruby
+s = Requests::Session.new(http2: true)
+s.get('https://api.example.com/a') # negotiates h2 over ALPN, reuses the connection
+s.get('https://api.example.com/b') # same connection, new stream
+
+# or opt in per call on a plain session
+Requests.get('https://api.example.com', http2: true)
+resp = Requests::Session.new.tap(&:http2!).get('https://api.example.com')
+```
+
+If the server doesn't advertise `h2` during the TLS handshake, or the URL
+is plain `http://`, or a proxy is configured, requests on that host
+transparently fall back to the regular `HTTPAdapter` (HTTP/1.1) - you get
+the same `Response` object either way and don't need to know which
+transport actually served the request.
+
 ### Custom transport adapters
 
 Loosely inspired by Python's `Session.mount()` / `HTTPAdapter`:
@@ -362,15 +397,16 @@ Requests.codes.im_a_teapot # 418, yes really
 |---|---|---|
 | `Requests.get/post/put/patch/delete/head/options` | `session.get/post/put/patch/delete/head/options` | `status_code`, `status` |
 | `Requests.request(method, url, **opts)` | `session.request(method, url, **opts)` | `ok?`, `redirect?` |
-| `Requests.session` → new `Session` | `session.get!/post!/put!/patch!/delete!` (raise on error) | `text`, `content`, `json` |
-| `Requests.download(url, to:, chunk_size:, resume:, progress:)` | `session.download(url, to:, ...)` (same, but reuses the session's pool/auth/headers) | `headers`, `cookies` |
-| `Requests.codes` | `session.mount(prefix, adapter)`, `session.close` | `elapsed`, `history`, `url` |
-|  | `session.hooks[:response]` | `raise_for_status`, `save_to`, `links` |
-|  | `session.headers`, `.cookies`, `.auth`, `.proxies`, `.retries`, `.backoff_factor`, `.status_forcelist` |  |
+| `Requests.get!/post!/put!/patch!/delete!/head!/options!` (raise on error) | `session.get!/post!/put!/patch!/delete!/head!/options!` (raise on error) | `text`, `content`, `json` |
+| `Requests.session(**opts)` → new `Session` | `session.mount(prefix, adapter)`, `session.close` | `headers`, `cookies` |
+| `Requests.download(url, to:, chunk_size:, resume:, progress:)` | `session.download(url, to:, ...)` (same, but reuses the session's pool/auth/headers) | `elapsed`, `history`, `url` |
+| `Requests.codes` | `session.http2!`, `Session.new(http2: true)`, or `http2: true` per request | `raise_for_status`, `save_to`, `links` |
+|  | `session.hooks[:response]` |  |
+|  | `session.headers`, `.cookies`, `.auth`, `.proxies`, `.trust_env`, `.retries`, `.backoff_factor`, `.status_forcelist` |  |
 |  | `Requests::Jar#save(path)` / `Requests::Jar.load(path)` |  |
-|  | `HTTPAdapter.new(max_retries:, backoff_factor:, status_forcelist:)` |  |
+|  | `HTTPAdapter.new(max_retries:, backoff_factor:, status_forcelist:)`, `Http2Adapter.new(...)` |  |
 
-Every request-level method accepts: `params`, `data`, `json`, `headers`, `cookies`, `files`, `auth`, `timeout`, `allow_redirects`, `proxies`, `verify`, `cert`, `hooks`, `retries`.
+Every request-level method accepts: `params`, `data`, `json`, `headers`, `cookies`, `files`, `auth`, `timeout`, `allow_redirects`, `proxies`, `verify`, `cert`, `hooks`, `retries`, `http2`.
 
 ## Python parity cheat sheet
 
@@ -397,15 +433,22 @@ Every request-level method accepts: `params`, `data`, `json`, `headers`, `cookie
 - `iter_content`/`iter_lines` on a regular response read the whole body up
   front rather than lazily streaming it off the socket — `download` (added
   in 1.0.3) is the one that streams for real, use that for big files.
-- No HTTP/2, no automatic NTLM/Kerberos/OAuth — bring your own `auth:`
-  object (anything with `#call(headers)` works) if you need those.
+- HTTP/2 (1.0.4) only applies to direct `https://` connections - there's
+  no `h2c` (cleartext HTTP/2) support, and requests through a proxy always
+  use HTTP/1.1. No automatic NTLM/Kerberos/OAuth either — bring your own
+  `auth:` object (anything with `#call(headers)` works) if you need those.
+- The HTTP/2 adapter applies `timeout:` as one coarse deadline around the
+  whole request/response exchange rather than resetting it on every
+  individual socket read the way the HTTP/1.1 adapter's `Net::HTTP`
+  read-timeout does.
 - `verify: '/path/to/ca.pem'` accepts a single bundle file, not a
   directory of certs (`Net::HTTP` itself only takes `ca_file` or
   `ca_path`, and this gem only wires up the former today).
-- The connection pool added in 1.0.3 is per-`Session`/per-`HTTPAdapter`
-  instance and isn't thread-safe for concurrent requests on the *same*
-  `Session` object — use one `Session` per thread, or one connection per
-  thread, same advice as most connection-pooling HTTP clients.
+- The connection pool added in 1.0.3 (HTTP/1.1 and HTTP/2 alike) is per-
+  `Session`/per-adapter instance and isn't thread-safe for concurrent
+  requests on the *same* `Session` object — use one `Session` per thread,
+  or one connection per thread, same advice as most connection-pooling
+  HTTP clients.
 
 
 ## 🔧 Development
@@ -428,6 +471,10 @@ Bug reports and pull requests are welcome. A few ground rules:
 2. Add a test in `spec/requests_spec.rb` for anything you fix or add.
 3. Keep the Python-parity naming where it makes sense, but don't force it where it doesn't fit Ruby idiom (`?`-suffixed predicates, etc.).
 
+## Support the project
+
+If requests_ruby helped you, consider starring the repository ⭐
+
 ## License
 
 [MIT](LICENSE)

data/lib/requests/adapters.rb

@@ -5,6 +5,7 @@ require 'openssl'
 require 'uri'
 require 'zlib'
 require 'stringio'
+require 'time'
 
 module Requests
   class HTTPAdapter
@@ -30,7 +31,7 @@ module Requests
           r = do_send(meth, url, hdrs, body, timeout, proxies, verify, cert, auth)
           if @status_forcelist.include?(r.code.to_i) && attempt < @max_retries
             attempt += 1
-            sleep(@backoff_factor * attempt) if @backoff_factor.to_f > 0
+            sleep(retry_delay(r, attempt))
             next
           end
           return r
@@ -104,6 +105,19 @@ module Requests
     def idempotent?(meth)
       %w[GET HEAD OPTIONS PUT DELETE].include?(meth.to_s.upcase)
     end
+    def retry_delay(resp, attempt)
+      ra = resp['retry-after']
+      if ra
+        return ra.to_i if ra =~ /\A\d+\z/
+        begin
+          d = Time.httpdate(ra) - Time.now
+          return d.positive? ? d : 0
+        rescue ArgumentError
+          nil
+        end
+      end
+      @backoff_factor.to_f > 0 ? @backoff_factor * attempt : 0
+    end
     def do_send(meth, url, hdrs, body, timeout, proxies, verify, cert, auth)
       u = URI.parse(url)
       auth.call(hdrs) if auth.respond_to?(:call) && !auth.is_a?(Requests::DigestAuth)

data/lib/requests/api.rb

@@ -14,8 +14,15 @@ module Requests
     kw[:allow_redirects] = kw.fetch(:allow_redirects, false)
     request('HEAD', url, **kw)
   end
-  def self.session
-    Session.new
+  def self.get!(url, **kw); get(url, **kw).raise_for_status; end
+  def self.post!(url, **kw); post(url, **kw).raise_for_status; end
+  def self.put!(url, **kw); put(url, **kw).raise_for_status; end
+  def self.patch!(url, **kw); patch(url, **kw).raise_for_status; end
+  def self.delete!(url, **kw); delete(url, **kw).raise_for_status; end
+  def self.head!(url, **kw); head(url, **kw).raise_for_status; end
+  def self.options!(url, **kw); options(url, **kw).raise_for_status; end
+  def self.session(**kw)
+    Session.new(**kw)
   end
   def self.download(url, to:, **kw)
     Session.new.download(url, to: to, **kw)

data/lib/requests/hpack.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Requests
+  module HPACK
+    STATIC_TABLE = [
+      [':authority', ''],[':method', 'GET'],[':method', 'POST'],[':path', '/'],
+      [':path', '/index.html'],[':scheme', 'http'],[':scheme', 'https'],[':status', '200'],
+      [':status', '204'],[':status', '206'],[':status', '304'],[':status', '400'],
+      [':status', '404'],[':status', '500'],['accept-charset', ''],['accept-encoding', 'gzip, deflate'],
+      ['accept-language', ''],['accept-ranges', ''],['accept', ''],['access-control-allow-origin', ''],
+      ['age', ''],['allow', ''],['authorization', ''],['cache-control', ''],
+      ['content-disposition', ''],['content-encoding', ''],['content-language', ''],['content-length', ''],
+      ['content-location', ''],['content-range', ''],['content-type', ''],['cookie', ''],
+      ['date', ''],['etag', ''],['expect', ''],['expires', ''],
+      ['from', ''],['host', ''],['if-match', ''],['if-modified-since', ''],
+      ['if-none-match', ''],['if-range', ''],['if-unmodified-since', ''],['last-modified', ''],
+      ['link', ''],['location', ''],['max-forwards', ''],['proxy-authenticate', ''],
+      ['proxy-authorization', ''],['range', ''],['referer', ''],['refresh', ''],
+      ['retry-after', ''],['server', ''],['set-cookie', ''],['strict-transport-security', ''],
+      ['transfer-encoding', ''],['user-agent', ''],['vary', ''],['via', ''],
+      ['www-authenticate', '']
+    ].freeze
+
+    module Huffman
+      CODES = [
+        [0x1ff8, 13],[0x7fffd8, 23],[0xfffffe2, 28],[0xfffffe3, 28],[0xfffffe4, 28],[0xfffffe5, 28],
+        [0xfffffe6, 28],[0xfffffe7, 28],[0xfffffe8, 28],[0xffffea, 24],[0x3ffffffc, 30],[0xfffffe9, 28],
+        [0xfffffea, 28],[0x3ffffffd, 30],[0xfffffeb, 28],[0xfffffec, 28],[0xfffffed, 28],[0xfffffee, 28],
+        [0xfffffef, 28],[0xffffff0, 28],[0xffffff1, 28],[0xffffff2, 28],[0x3ffffffe, 30],[0xffffff3, 28],
+        [0xffffff4, 28],[0xffffff5, 28],[0xffffff6, 28],[0xffffff7, 28],[0xffffff8, 28],[0xffffff9, 28],
+        [0xffffffa, 28],[0xffffffb, 28],[0x14, 6],[0x3f8, 10],[0x3f9, 10],[0xffa, 12],
+        [0x1ff9, 13],[0x15, 6],[0xf8, 8],[0x7fa, 11],[0x3fa, 10],[0x3fb, 10],
+        [0xf9, 8],[0x7fb, 11],[0xfa, 8],[0x16, 6],[0x17, 6],[0x18, 6],
+        [0x0, 5],[0x1, 5],[0x2, 5],[0x19, 6],[0x1a, 6],[0x1b, 6],
+        [0x1c, 6],[0x1d, 6],[0x1e, 6],[0x1f, 6],[0x5c, 7],[0xfb, 8],
+        [0x7ffc, 15],[0x20, 6],[0xffb, 12],[0x3fc, 10],[0x1ffa, 13],[0x21, 6],
+        [0x5d, 7],[0x5e, 7],[0x5f, 7],[0x60, 7],[0x61, 7],[0x62, 7],
+        [0x63, 7],[0x64, 7],[0x65, 7],[0x66, 7],[0x67, 7],[0x68, 7],
+        [0x69, 7],[0x6a, 7],[0x6b, 7],[0x6c, 7],[0x6d, 7],[0x6e, 7],
+        [0x6f, 7],[0x70, 7],[0x71, 7],[0x72, 7],[0xfc, 8],[0x73, 7],
+        [0xfd, 8],[0x1ffb, 13],[0x7fff0, 19],[0x1ffc, 13],[0x3ffc, 14],[0x22, 6],
+        [0x7ffd, 15],[0x3, 5],[0x23, 6],[0x4, 5],[0x24, 6],[0x5, 5],
+        [0x25, 6],[0x26, 6],[0x27, 6],[0x6, 5],[0x74, 7],[0x75, 7],
+        [0x28, 6],[0x29, 6],[0x2a, 6],[0x7, 5],[0x2b, 6],[0x76, 7],
+        [0x2c, 6],[0x8, 5],[0x9, 5],[0x2d, 6],[0x77, 7],[0x78, 7],
+        [0x79, 7],[0x7a, 7],[0x7b, 7],[0x7ffe, 15],[0x7fc, 11],[0x3ffd, 14],
+        [0x1ffd, 13],[0xffffffc, 28],[0xfffe6, 20],[0x3fffd2, 22],[0xfffe7, 20],[0xfffe8, 20],
+        [0x3fffd3, 22],[0x3fffd4, 22],[0x3fffd5, 22],[0x7fffd9, 23],[0x3fffd6, 22],[0x7fffda, 23],
+        [0x7fffdb, 23],[0x7fffdc, 23],[0x7fffdd, 23],[0x7fffde, 23],[0xffffeb, 24],[0x7fffdf, 23],
+        [0xffffec, 24],[0xffffed, 24],[0x3fffd7, 22],[0x7fffe0, 23],[0xffffee, 24],[0x7fffe1, 23],
+        [0x7fffe2, 23],[0x7fffe3, 23],[0x7fffe4, 23],[0x1fffdc, 21],[0x3fffd8, 22],[0x7fffe5, 23],
+        [0x3fffd9, 22],[0x7fffe6, 23],[0x7fffe7, 23],[0xffffef, 24],[0x3fffda, 22],[0x1fffdd, 21],
+        [0xfffe9, 20],[0x3fffdb, 22],[0x3fffdc, 22],[0x7fffe8, 23],[0x7fffe9, 23],[0x1fffde, 21],
+        [0x7fffea, 23],[0x3fffdd, 22],[0x3fffde, 22],[0xfffff0, 24],[0x1fffdf, 21],[0x3fffdf, 22],
+        [0x7fffeb, 23],[0x7fffec, 23],[0x1fffe0, 21],[0x1fffe1, 21],[0x3fffe0, 22],[0x1fffe2, 21],
+        [0x7fffed, 23],[0x3fffe1, 22],[0x7fffee, 23],[0x7fffef, 23],[0xfffea, 20],[0x3fffe2, 22],
+        [0x3fffe3, 22],[0x3fffe4, 22],[0x7ffff0, 23],[0x3fffe5, 22],[0x3fffe6, 22],[0x7ffff1, 23],
+        [0x3ffffe0, 26],[0x3ffffe1, 26],[0xfffeb, 20],[0x7fff1, 19],[0x3fffe7, 22],[0x7ffff2, 23],
+        [0x3fffe8, 22],[0x1ffffec, 25],[0x3ffffe2, 26],[0x3ffffe3, 26],[0x3ffffe4, 26],[0x7ffffde, 27],
+        [0x7ffffdf, 27],[0x3ffffe5, 26],[0xfffff1, 24],[0x1ffffed, 25],[0x7fff2, 19],[0x1fffe3, 21],
+        [0x3ffffe6, 26],[0x7ffffe0, 27],[0x7ffffe1, 27],[0x3ffffe7, 26],[0x7ffffe2, 27],[0xfffff2, 24],
+        [0x1fffe4, 21],[0x1fffe5, 21],[0x3ffffe8, 26],[0x3ffffe9, 26],[0xffffffd, 28],[0x7ffffe3, 27],
+        [0x7ffffe4, 27],[0x7ffffe5, 27],[0xfffec, 20],[0xfffff3, 24],[0xfffed, 20],[0x1fffe6, 21],
+        [0x3fffe9, 22],[0x1fffe7, 21],[0x1fffe8, 21],[0x7ffff3, 23],[0x3fffea, 22],[0x3fffeb, 22],
+        [0x1ffffee, 25],[0x1ffffef, 25],[0xfffff4, 24],[0xfffff5, 24],[0x3ffffea, 26],[0x7ffff4, 23],
+        [0x3ffffeb, 26],[0x7ffffe6, 27],[0x3ffffec, 26],[0x3ffffed, 26],[0x7ffffe7, 27],[0x7ffffe8, 27],
+        [0x7ffffe9, 27],[0x7ffffea, 27],[0x7ffffeb, 27],[0xffffffe, 28],[0x7ffffec, 27],[0x7ffffed, 27],
+        [0x7ffffee, 27],[0x7ffffef, 27],[0x7fffff0, 27],[0x3ffffee, 26],[0x3fffffff, 30]
+      ].freeze
+      EOS = 256
+      ENCODE_TABLE = CODES.map { |c, l| [c].pack('N').unpack1('B*')[-l..-1] }.freeze
+      def self.build_tree
+        root = {}
+        CODES.each_with_index do |(code, len), sym|
+          node = root
+          (len - 1).downto(0) do |i|
+            bit = (code >> i) & 1
+            node = (node[bit] ||= {})
+          end
+          node[:sym] = sym
+        end
+        root
+      end
+      DECODE_TREE = build_tree
+      def self.encode(str)
+        bits = String.new
+        str.each_byte { |b| bits << ENCODE_TABLE[b] }
+        pad = (8 - bits.size % 8) % 8
+        bits << ('1' * pad) if pad > 0
+        [bits].pack('B*')
+      end
+      def self.decode(bytes)
+        out = String.new(encoding: Encoding::BINARY)
+        node = DECODE_TREE
+        bitcount = bytes.bytesize * 8
+        pos = 0
+        bytes.each_byte do |byte|
+          7.downto(0) do |i|
+            pos += 1
+            bit = (byte >> i) & 1
+            nxt = node[bit]
+            unless nxt
+              raise Requests::ContentDecodingError, 'invalid huffman padding' if pos > bitcount - 8 || pos < bitcount
+              return out
+            end
+            node = nxt
+            if node.key?(:sym)
+              sym = node[:sym]
+              raise Requests::ContentDecodingError, 'unexpected huffman EOS' if sym == EOS
+              out << sym.chr(Encoding::BINARY)
+              node = DECODE_TREE
+            end
+          end
+        end
+        out
+      end
+    end
+
+    module Integer
+      module_function
+      def encode(value, prefix_bits, first_byte = 0)
+        max = (1 << prefix_bits) - 1
+        if value < max
+          [first_byte | value].pack('C')
+        else
+          out = [first_byte | max].pack('C')
+          value -= max
+          while value >= 128
+            out << [(value % 128) | 128].pack('C')
+            value /= 128
+          end
+          out << [value].pack('C')
+        end
+      end
+      def decode(bytes, pos, prefix_bits)
+        max = (1 << prefix_bits) - 1
+        value = bytes.getbyte(pos) & max
+        pos += 1
+        if value == max
+          m = 0
+          loop do
+            b = bytes.getbyte(pos)
+            raise Requests::ContentDecodingError, 'truncated hpack integer' if b.nil?
+            pos += 1
+            value += (b & 127) * (2**m)
+            m += 7
+            break if b & 128 == 0
+          end
+        end
+        [value, pos]
+      end
+    end
+
+    class Encoder
+      def encode(headers)
+        out = String.new(encoding: Encoding::BINARY)
+        headers.each { |name, value| out << encode_field(name.to_s.downcase, value.to_s) }
+        out
+      end
+      private
+      def encode_field(name, value)
+        exact = STATIC_TABLE.index { |n, v| n == name && v == value }
+        return Integer.encode(exact + 1, 7, 0x80) if exact
+        name_idx = STATIC_TABLE.index { |n, _| n == name }
+        head = name_idx ? Integer.encode(name_idx + 1, 4, 0x00) : Integer.encode(0, 4, 0x00) + literal(name)
+        head + literal(value)
+      end
+      def literal(str)
+        h = Huffman.encode(str)
+        if h.bytesize < str.bytesize
+          Integer.encode(h.bytesize, 7, 0x80) + h
+        else
+          Integer.encode(str.bytesize, 7, 0x00) + str.dup.force_encoding(Encoding::BINARY)
+        end
+      end
+    end
+
+    class Decoder
+      def initialize(max_size: 4096)
+        @dynamic = []
+        @max_size = max_size
+        @size = 0
+      end
+      def decode(bytes)
+        pos = 0
+        out = []
+        while pos < bytes.bytesize
+          byte = bytes.getbyte(pos)
+          if byte & 0x80 != 0
+            idx, pos = Integer.decode(bytes, pos, 7)
+            out << lookup(idx)
+          elsif byte & 0x40 != 0
+            name, value, pos = read_literal(bytes, pos, 6)
+            add_dynamic(name, value)
+            out << [name, value]
+          elsif byte & 0x20 != 0
+            size, pos = Integer.decode(bytes, pos, 5)
+            @max_size = size
+            evict
+          else
+            name, value, pos = read_literal(bytes, pos, 4)
+            out << [name, value]
+          end
+        end
+        out
+      end
+      private
+      def lookup(idx)
+        return STATIC_TABLE[idx - 1] if idx <= STATIC_TABLE.size
+        d = @dynamic[idx - STATIC_TABLE.size - 1]
+        raise Requests::ContentDecodingError, "invalid hpack index #{idx}" unless d
+        d
+      end
+      def read_literal(bytes, pos, prefix_bits)
+        idx, pos = Integer.decode(bytes, pos, prefix_bits)
+        name, pos = idx.zero? ? read_string(bytes, pos) : [lookup(idx)[0], pos]
+        value, pos = read_string(bytes, pos)
+        [name, value, pos]
+      end
+      def read_string(bytes, pos)
+        huff = bytes.getbyte(pos) & 0x80 != 0
+        len, pos = Integer.decode(bytes, pos, 7)
+        raw = bytes.byteslice(pos, len)
+        pos += len
+        [huff ? Huffman.decode(raw) : raw, pos]
+      end
+      def add_dynamic(name, value)
+        entry_size = name.bytesize + value.bytesize + 32
+        @dynamic.unshift([name, value])
+        @size += entry_size
+        evict
+      end
+      def evict
+        while @size > @max_size && !@dynamic.empty?
+          name, value = @dynamic.pop
+          @size -= name.bytesize + value.bytesize + 32
+        end
+      end
+    end
+  end
+end

data/lib/requests/http2.rb

@@ -0,0 +1,469 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'openssl'
+require 'uri'
+require 'zlib'
+require 'timeout'
+require 'time'
+
+module Requests
+  class Http2Response
+    def initialize(header_pairs, body)
+      @status = nil
+      @fields = Hash.new { |h, k| h[k] = [] }
+      @headers = CIHash.new
+      header_pairs.each do |k, v|
+        if k == ':status'
+          @status = v
+        else
+          @fields[k.downcase] << v
+          @headers[k] = v
+        end
+      end
+      @body = body
+    end
+    def code
+      @status
+    end
+    def message
+      (Requests::STATUS_CODES[@status.to_i] || :unknown).to_s.split('_').map(&:capitalize).join(' ')
+    end
+    def [](k)
+      @headers[k]
+    end
+    def each_header
+      return enum_for(:each_header) unless block_given?
+      @headers.each { |k, v| yield k, v }
+    end
+    def get_fields(name)
+      f = @fields[name.to_s.downcase]
+      f.empty? ? nil : f
+    end
+    def body
+      @body
+    end
+  end
+
+  class Http2Connection
+    TYPE_DATA = 0x0
+    TYPE_HEADERS = 0x1
+    TYPE_PRIORITY = 0x2
+    TYPE_RST_STREAM = 0x3
+    TYPE_SETTINGS = 0x4
+    TYPE_PUSH_PROMISE = 0x5
+    TYPE_PING = 0x6
+    TYPE_GOAWAY = 0x7
+    TYPE_WINDOW_UPDATE = 0x8
+    TYPE_CONTINUATION = 0x9
+    FLAG_END_STREAM = 0x1
+    FLAG_ACK = 0x1
+    FLAG_END_HEADERS = 0x4
+    FLAG_PADDED = 0x8
+    FLAG_PRIORITY = 0x20
+    PREFACE = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+    DEFAULT_WINDOW = 65_535
+
+    def initialize(socket)
+      @socket = socket
+      @next_stream_id = 1
+      @encoder = HPACK::Encoder.new
+      @decoder = HPACK::Decoder.new
+      @send_window = DEFAULT_WINDOW
+      @conn_recv_window = DEFAULT_WINDOW
+      @peer_max_frame_size = 16_384
+      @peer_initial_window = DEFAULT_WINDOW
+      @streams = {}
+      @closed = false
+      handshake!
+    end
+    def alive?
+      !@closed && !@socket.closed?
+    end
+    def close
+      write_frame(TYPE_GOAWAY, 0, 0, [0, 0].pack('NN')) if alive?
+    rescue StandardError
+      nil
+    ensure
+      @closed = true
+      @socket.close unless @socket.closed?
+    end
+    def request(method, uri, header_list, body, io: nil, progress: nil)
+      raise Requests::ConnectionError, 'http/2 connection is closed' unless alive?
+      stream_id = @next_stream_id
+      @next_stream_id += 2
+      @streams[stream_id] = { send_window: @peer_initial_window, recv_window: DEFAULT_WINDOW }
+      end_stream = body.nil? || body.to_s.empty?
+      send_headers(stream_id, header_list, end_stream)
+      send_body(stream_id, body) unless end_stream
+      read_response(stream_id, io: io, progress: progress)
+    ensure
+      @streams.delete(stream_id) if stream_id
+    end
+    private
+    def handshake!
+      @socket.write(PREFACE)
+      write_frame(TYPE_SETTINGS, 0, 0, '')
+      loop do
+        type, flags, sid, payload = read_frame
+        case type
+        when TYPE_SETTINGS
+          if flags & FLAG_ACK == 0
+            apply_settings(payload)
+            write_frame(TYPE_SETTINGS, FLAG_ACK, 0, '')
+          end
+          break
+        when TYPE_WINDOW_UPDATE
+          apply_window_update(sid, payload)
+        end
+      end
+    end
+    def send_headers(stream_id, header_list, end_stream)
+      blob = @encoder.encode(header_list)
+      offset = 0
+      first = true
+      loop do
+        chunk = blob.byteslice(offset, @peer_max_frame_size) || ''
+        offset += chunk.bytesize
+        last = offset >= blob.bytesize
+        flags = 0
+        flags |= FLAG_END_HEADERS if last
+        flags |= FLAG_END_STREAM if last && end_stream
+        write_frame(first ? TYPE_HEADERS : TYPE_CONTINUATION, flags, stream_id, chunk)
+        first = false
+        break if last
+      end
+    end
+    def send_body(stream_id, body)
+      pos = 0
+      st = @streams[stream_id]
+      body = body.dup.force_encoding(Encoding::BINARY)
+      loop do
+        avail = [st[:send_window], @send_window, @peer_max_frame_size].min
+        if avail <= 0
+          type, flags, sid, payload = read_frame
+          dispatch_control_frame(type, flags, sid, payload)
+          next
+        end
+        chunk = body.byteslice(pos, [avail, body.bytesize - pos].min)
+        pos += chunk.bytesize
+        st[:send_window] -= chunk.bytesize
+        @send_window -= chunk.bytesize
+        last = pos >= body.bytesize
+        write_frame(TYPE_DATA, last ? FLAG_END_STREAM : 0, stream_id, chunk)
+        break if last
+      end
+    end
+    def read_response(stream_id, io: nil, progress: nil)
+      header_blob = String.new(encoding: Encoding::BINARY)
+      headers = nil
+      body = io ? nil : String.new(encoding: Encoding::BINARY)
+      decoder = nil
+      total = 0
+      content_length = nil
+      done = false
+      until done
+        type, flags, sid, payload = read_frame
+        case type
+        when TYPE_HEADERS, TYPE_CONTINUATION
+          next unless sid == stream_id || headers.nil?
+          block = type == TYPE_HEADERS ? strip_header_padding(payload, flags) : payload
+          header_blob << block
+          if flags & FLAG_END_HEADERS != 0
+            headers = @decoder.decode(header_blob)
+            if io
+              hdrs = CIHash.new
+              headers.each { |k, v| hdrs[k] = v unless k == ':status' }
+              decoder = stream_decoder(hdrs)
+              content_length = hdrs['content-length']&.to_i
+            end
+          end
+          done = true if sid == stream_id && flags & FLAG_END_STREAM != 0
+        when TYPE_DATA
+          if sid == stream_id
+            chunk = strip_data_padding(payload, flags)
+            update_recv_window(stream_id, payload.bytesize)
+            if io
+              piece = decoder == :raw ? chunk : decoder.inflate(chunk)
+              io.write(piece)
+              total += piece.bytesize
+              progress.call(total, content_length) if progress
+            else
+              body << chunk
+            end
+          end
+          done = true if sid == stream_id && flags & FLAG_END_STREAM != 0
+        else
+          dispatch_control_frame(type, flags, sid, payload)
+          done = true if type == TYPE_RST_STREAM && sid == stream_id
+        end
+      end
+      Http2Response.new(headers || [], body)
+    end
+    def dispatch_control_frame(type, flags, sid, payload)
+      case type
+      when TYPE_WINDOW_UPDATE
+        apply_window_update(sid, payload)
+      when TYPE_SETTINGS
+        if flags & FLAG_ACK == 0
+          apply_settings(payload)
+          write_frame(TYPE_SETTINGS, FLAG_ACK, 0, '')
+        end
+      when TYPE_PING
+        write_frame(TYPE_PING, FLAG_ACK, 0, payload) if flags & FLAG_ACK == 0
+      when TYPE_GOAWAY
+        @closed = true
+      when TYPE_RST_STREAM
+        raise Requests::ConnectionError, 'stream reset by server'
+      when TYPE_PUSH_PROMISE
+        psid = payload.byteslice(0, 4).unpack1('N') & 0x7fffffff
+        write_frame(TYPE_RST_STREAM, 0, psid, [0x8].pack('N'))
+      end
+    end
+    def apply_settings(payload)
+      i = 0
+      while i + 6 <= payload.bytesize
+        id = payload.byteslice(i, 2).unpack1('n')
+        val = payload.byteslice(i + 2, 4).unpack1('N')
+        @peer_initial_window = val if id == 4
+        @peer_max_frame_size = val if id == 5
+        i += 6
+      end
+    end
+    def apply_window_update(sid, payload)
+      inc = payload.unpack1('N') & 0x7fffffff
+      if sid == 0
+        @send_window += inc
+      else
+        (@streams[sid] ||= { send_window: @peer_initial_window, recv_window: DEFAULT_WINDOW })[:send_window] += inc
+      end
+    end
+    def update_recv_window(stream_id, n)
+      st = @streams[stream_id]
+      return unless st
+      st[:recv_window] -= n
+      @conn_recv_window -= n
+      if st[:recv_window] < 32_768
+        inc = DEFAULT_WINDOW - st[:recv_window]
+        write_frame(TYPE_WINDOW_UPDATE, 0, stream_id, [inc].pack('N'))
+        st[:recv_window] += inc
+      end
+      return unless @conn_recv_window < 32_768
+      inc = DEFAULT_WINDOW - @conn_recv_window
+      write_frame(TYPE_WINDOW_UPDATE, 0, 0, [inc].pack('N'))
+      @conn_recv_window += inc
+    end
+    def stream_decoder(hdrs)
+      case hdrs['content-encoding'].to_s.downcase
+      when 'gzip', 'x-gzip' then Zlib::Inflate.new(32 + Zlib::MAX_WBITS)
+      when 'deflate' then Zlib::Inflate.new
+      else :raw
+      end
+    end
+    def strip_header_padding(payload, flags)
+      pos = 0
+      padlen = 0
+      if flags & FLAG_PADDED != 0
+        padlen = payload.getbyte(0)
+        pos += 1
+      end
+      pos += 5 if flags & FLAG_PRIORITY != 0
+      payload.byteslice(pos, payload.bytesize - pos - padlen)
+    end
+    def strip_data_padding(payload, flags)
+      return payload if flags & FLAG_PADDED == 0
+      padlen = payload.getbyte(0)
+      payload.byteslice(1, payload.bytesize - 1 - padlen)
+    end
+    def read_frame
+      hdr = read_exactly(9)
+      length = (hdr.getbyte(0) << 16) | (hdr.getbyte(1) << 8) | hdr.getbyte(2)
+      type = hdr.getbyte(3)
+      flags = hdr.getbyte(4)
+      sid = hdr.byteslice(5, 4).unpack1('N') & 0x7fffffff
+      payload = length.positive? ? read_exactly(length) : ''
+      [type, flags, sid, payload]
+    end
+    def write_frame(type, flags, stream_id, payload)
+      len = payload.bytesize
+      hdr = [(len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff, type, flags].pack('C5') + [stream_id & 0x7fffffff].pack('N')
+      @socket.write(hdr + payload)
+    end
+    def read_exactly(n)
+      buf = String.new(encoding: Encoding::BINARY)
+      while buf.bytesize < n
+        chunk = @socket.read(n - buf.bytesize)
+        raise Requests::ConnectionError, 'connection closed by peer' if chunk.nil?
+        buf << chunk
+      end
+      buf
+    end
+  end
+
+  class Http2Adapter
+    attr_accessor :max_retries, :backoff_factor, :status_forcelist
+    def initialize(max_retries: 0, backoff_factor: 0, status_forcelist: [])
+      @max_retries = max_retries
+      @backoff_factor = backoff_factor
+      @status_forcelist = status_forcelist
+      @pool = {}
+      @alpn = {}
+      @fallback = HTTPAdapter.new(max_retries: max_retries, backoff_factor: backoff_factor, status_forcelist: status_forcelist)
+    end
+    def send_once(meth, url, hdrs, body, timeout, proxies, verify, cert, auth)
+      u = URI.parse(url)
+      sync_fallback!
+      return @fallback.send_once(meth, url, hdrs, body, timeout, proxies, verify, cert, auth) unless usable?(u, proxies)
+      conn = conn_for(u, verify, cert, timeout)
+      return @fallback.send_once(meth, url, hdrs, body, timeout, proxies, verify, cert, auth) if conn == :http1
+      attempt = 0
+      loop do
+        begin
+          auth.call(hdrs) if auth.respond_to?(:call) && !auth.is_a?(Requests::DigestAuth)
+          resp = perform(conn, meth, u, hdrs, body, timeout)
+          if @status_forcelist.include?(resp.code.to_i) && attempt < @max_retries
+            attempt += 1
+            sleep(retry_delay(resp, attempt))
+            conn = conn_for(u, verify, cert, timeout)
+            next
+          end
+          return resp
+        rescue Requests::ConnectionError, Requests::ConnectTimeout => e
+          drop_conn(u)
+          attempt += 1
+          raise e unless attempt <= @max_retries && idempotent?(meth)
+          sleep(@backoff_factor * attempt) if @backoff_factor.to_f > 0
+          conn = conn_for(u, verify, cert, timeout)
+          return @fallback.send_once(meth, url, hdrs, body, timeout, proxies, verify, cert, auth) if conn == :http1
+        end
+      end
+    end
+    def stream_to(meth, url, hdrs, body, timeout, proxies, verify, cert, auth, io, chunk_size: 65_536, progress: nil)
+      u = URI.parse(url)
+      sync_fallback!
+      unless usable?(u, proxies)
+        return @fallback.stream_to(meth, url, hdrs, body, timeout, proxies, verify, cert, auth, io, chunk_size: chunk_size, progress: progress)
+      end
+      conn = conn_for(u, verify, cert, timeout)
+      if conn == :http1
+        return @fallback.stream_to(meth, url, hdrs, body, timeout, proxies, verify, cert, auth, io, chunk_size: chunk_size, progress: progress)
+      end
+      auth.call(hdrs) if auth.respond_to?(:call) && !auth.is_a?(Requests::DigestAuth)
+      begin
+        header_list = build_headers(meth, u, hdrs)
+        _open_t, read_t = split_timeout(timeout)
+        with_timeout(read_t) { conn.request(meth, u, header_list, body, io: io, progress: progress) }
+      rescue Requests::ConnectionError, Requests::ConnectTimeout => e
+        drop_conn(u)
+        raise e
+      end
+    end
+    def decode_body(net_resp)
+      @fallback.decode_body(net_resp)
+    end
+    def close_pool
+      @pool.each_value { |c| c.close }
+      @pool.clear
+      @fallback.close_pool
+    end
+    private
+    def perform(conn, meth, u, hdrs, body, timeout)
+      header_list = build_headers(meth, u, hdrs)
+      _open_t, read_t = split_timeout(timeout)
+      with_timeout(read_t) { conn.request(meth, u, header_list, body) }
+    end
+    def with_timeout(read_t, &blk)
+      return blk.call unless read_t
+      ::Timeout.timeout(read_t, Requests::ReadTimeout, &blk)
+    end
+    def sync_fallback!
+      @fallback.max_retries = @max_retries
+      @fallback.backoff_factor = @backoff_factor
+      @fallback.status_forcelist = @status_forcelist
+    end
+    def idempotent?(meth)
+      %w[GET HEAD OPTIONS PUT DELETE].include?(meth.to_s.upcase)
+    end
+    def retry_delay(resp, attempt)
+      ra = resp['retry-after']
+      if ra
+        return ra.to_i if ra =~ /\A\d+\z/
+        begin
+          d = Time.httpdate(ra) - Time.now
+          return d.positive? ? d : 0
+        rescue ArgumentError
+          nil
+        end
+      end
+      @backoff_factor.to_f > 0 ? @backoff_factor * attempt : 0
+    end
+    def usable?(u, proxies)
+      return false unless u.scheme == 'https'
+      return false if proxies && !proxies.empty? && (proxies[u.scheme] || proxies[u.scheme.to_sym])
+      true
+    end
+    def build_headers(meth, u, hdrs)
+      port = u.port && u.port != 443 ? ":#{u.port}" : ''
+      list = [[':method', meth.to_s.upcase], [':scheme', 'https'], [':path', u.request_uri], [':authority', "#{u.host}#{port}"]]
+      hdrs.each { |k, v| list << [k.to_s, v.to_s] unless k.to_s.downcase == 'host' }
+      list
+    end
+    def key_for(u)
+      "#{u.host}:#{u.port}"
+    end
+    def conn_for(u, verify, cert, timeout)
+      k = key_for(u)
+      cached = @pool[k]
+      return cached if cached && cached.alive?
+      @pool.delete(k)
+      return :http1 if @alpn[k] == 'http1'
+      sock = open_tls(u, verify, cert, timeout)
+      if sock.alpn_protocol == 'h2'
+        @alpn[k] = 'h2'
+        @pool[k] = Http2Connection.new(sock)
+      else
+        @alpn[k] = 'http1'
+        sock.close rescue nil
+        :http1
+      end
+    end
+    def drop_conn(u)
+      c = @pool.delete(key_for(u))
+      c.close if c
+    end
+    def open_tls(u, verify, cert, timeout)
+      open_t, _read_t = split_timeout(timeout)
+      tcp = open_t ? Socket.tcp(u.host, u.port, connect_timeout: open_t) : Socket.tcp(u.host, u.port)
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.alpn_protocols = ['h2', 'http/1.1']
+      if verify == false
+        ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      else
+        ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        ctx.ca_file = verify.is_a?(String) ? verify : Requests::CA_FILE
+      end
+      if cert
+        ctx.cert = OpenSSL::X509::Certificate.new(File.read(cert[0]))
+        ctx.key = OpenSSL::PKey::RSA.new(File.read(cert[1]))
+      end
+      ssl = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
+      ssl.hostname = u.host
+      ssl.sync_close = true
+      ssl.connect
+      ssl
+    rescue Errno::ETIMEDOUT, IO::TimeoutError
+      raise Requests::ConnectTimeout, "connect timeout: #{u}"
+    rescue OpenSSL::SSL::SSLError => e
+      raise Requests::SSLError, e.message
+    rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET => e
+      raise Requests::ConnectionError, e.message
+    end
+    def split_timeout(t)
+      case t
+      when nil then [nil, nil]
+      when Array then [t[0], t[1]]
+      else [t, t]
+      end
+    end
+  end
+end

data/lib/requests/sessions.rb

@@ -6,8 +6,8 @@ require 'time'
 module Requests
   class Session
     attr_accessor :headers, :cookies, :auth, :params, :proxies, :verify,
-                  :cert, :max_redirects, :timeout, :retries, :backoff_factor, :status_forcelist
-    def initialize
+                  :cert, :max_redirects, :timeout, :retries, :backoff_factor, :status_forcelist, :trust_env
+    def initialize(http2: false)
       @headers = Requests::Utils.default_headers
       @cookies = Jar.new
       @auth = nil
@@ -20,9 +20,11 @@ module Requests
       @retries = 0
       @backoff_factor = 0
       @status_forcelist = []
+      @trust_env = true
       @hooks = { response: [] }
-      @adapters = { 'https://' => HTTPAdapter.new, 'http://' => HTTPAdapter.new }
+      @adapters = { 'https://' => http2 ? Http2Adapter.new : HTTPAdapter.new, 'http://' => HTTPAdapter.new }
       @default_adapters = @adapters.values.dup
+      @http2_adapter = http2 ? @adapters['https://'] : nil
     end
     def hooks
       @hooks
@@ -31,6 +33,12 @@ module Requests
       @adapters[prefix] = adapter
       self
     end
+    def http2!
+      @http2_adapter ||= Http2Adapter.new
+      @adapters['https://'] = @http2_adapter
+      @default_adapters = @adapters.values.dup
+      self
+    end
     def get(url, **kw); request('GET', url, **kw); end
     def post(url, **kw); request('POST', url, **kw); end
     def put(url, **kw); request('PUT', url, **kw); end
@@ -46,12 +54,14 @@ module Requests
     def put!(url, **kw); put(url, **kw).raise_for_status; end
     def patch!(url, **kw); patch(url, **kw).raise_for_status; end
     def delete!(url, **kw); delete(url, **kw).raise_for_status; end
+    def head!(url, **kw); head(url, **kw).raise_for_status; end
+    def options!(url, **kw); options(url, **kw).raise_for_status; end
     def close
       @adapters.values.uniq.each { |a| a.close_pool if a.respond_to?(:close_pool) }
       true
     end
     def download(url, to:, chunk_size: 65536, resume: false, progress: nil, headers: nil, params: nil,
-                 timeout: nil, proxies: nil, verify: nil, cert: nil, auth: nil)
+                 timeout: nil, proxies: nil, verify: nil, cert: nil, auth: nil, http2: nil)
       validate_url!(url)
       full_url = build_url(url, merge_hash(@params, params))
       hdrs = CIHash.new(@headers.to_h)
@@ -61,13 +71,13 @@ module Requests
         hdrs['Range'] = "bytes=#{File.size(to)}-"
         mode = 'ab'
       end
-      adapter = adapter_for(full_url)
+      adapter = pick_adapter(full_url, http2)
       adapter.max_retries = @retries
       adapter.backoff_factor = @backoff_factor
       use_auth = auth || @auth
       use_auth.call(hdrs) if use_auth.respond_to?(:call) && !use_auth.is_a?(DigestAuth)
       File.open(to, mode) do |f|
-        net_resp = adapter.stream_to('GET', full_url, hdrs, nil, timeout || @timeout, proxies || @proxies,
+        net_resp = adapter.stream_to('GET', full_url, hdrs, nil, timeout || @timeout, effective_proxies(full_url, proxies),
                                       verify.nil? ? @verify : verify, cert || @cert, nil, f,
                                       chunk_size: chunk_size, progress: progress)
         unless [200, 206].include?(net_resp.code.to_i)
@@ -78,7 +88,7 @@ module Requests
     end
     def request(method, url, params: nil, data: nil, json: nil, headers: nil, cookies: nil, files: nil,
                 auth: nil, timeout: nil, allow_redirects: true, proxies: nil, verify: nil, stream: false,
-                cert: nil, hooks: nil, retries: nil)
+                cert: nil, hooks: nil, retries: nil, http2: nil)
       validate_url!(url)
       use_auth = auth || @auth
       merged_params = merge_hash(@params, params)
@@ -97,13 +107,14 @@ module Requests
         ck = @cookies.to_header(cur_url)
         ck = [ck, cookies.map { |k, v| "#{k}=#{v}" }.join('; ')].reject { |x| x.nil? || x.empty? }.join('; ') if cookies
         hdrs['Cookie'] = ck unless ck.empty?
-        adapter = adapter_for(cur_url)
+        adapter = pick_adapter(cur_url, http2)
         adapter.max_retries = retries unless retries.nil?
         adapter.max_retries = @retries if @retries.to_i > 0 && retries.nil? && default_adapter?(adapter)
         adapter.backoff_factor = @backoff_factor if @backoff_factor.to_f > 0 && default_adapter?(adapter)
         adapter.status_forcelist = @status_forcelist if !@status_forcelist.empty? && adapter.respond_to?(:status_forcelist=) && default_adapter?(adapter)
+        eff_proxies = effective_proxies(cur_url, proxies)
         t0 = Time.now
-        net_resp = adapter.send_once(cur_method, cur_url, hdrs, body, timeout || @timeout,proxies || @proxies, verify.nil? ? @verify : verify,cert || @cert, use_auth)
+        net_resp = adapter.send_once(cur_method, cur_url, hdrs, body, timeout || @timeout, eff_proxies, verify.nil? ? @verify : verify,cert || @cert, use_auth)
         elapsed = Time.now - t0
         resp = to_response(adapter, net_resp, cur_url, elapsed, cur_method, hdrs, body)
         @cookies.update(net_resp, cur_url)
@@ -111,7 +122,7 @@ module Requests
         if use_auth.is_a?(DigestAuth) && resp.status_code == 401 && redirs.zero? && hist.empty?
           use_auth.call(hdrs, meth: cur_method, url: cur_url, prev_resp: resp)
           t1 = Time.now
-          net_resp = adapter.send_once(cur_method, cur_url, hdrs, body, timeout || @timeout,proxies || @proxies, verify.nil? ? @verify : verify,cert || @cert, nil)
+          net_resp = adapter.send_once(cur_method, cur_url, hdrs, body, timeout || @timeout, eff_proxies, verify.nil? ? @verify : verify,cert || @cert, nil)
           resp = to_response(adapter, net_resp, cur_url, Time.now - t1, cur_method, hdrs, body)
           @cookies.update(net_resp, cur_url)
           resp.cookies = @cookies
@@ -149,6 +160,19 @@ module Requests
       match = @adapters.keys.select { |prefix| url.start_with?(prefix) }.max_by(&:length)
       match ? @adapters[match] : @adapters['https://']
     end
+    def pick_adapter(url, http2)
+      return adapter_for(url) unless http2 == true
+      unless @http2_adapter
+        @http2_adapter = Http2Adapter.new
+        @default_adapters << @http2_adapter
+      end
+      @http2_adapter
+    end
+    def effective_proxies(url, proxies)
+      p = proxies || @proxies
+      return p if p && !p.empty?
+      @trust_env ? Requests::Utils.env_proxies(url) : (p || {})
+    end
     def merge_hash(a, b)
       return b unless a
       return a unless b

data/lib/requests/utils.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'uri'
+
 module Requests
   module Utils
     module_function
@@ -51,5 +53,21 @@ module Requests
     def looks_like_html?(str)
       !!(str.to_s.lstrip =~ /\A(<!DOCTYPE html|<html)/i)
     end
+    def env_proxies(url)
+      host = URI.parse(url).host.to_s
+      no_proxy = ENV['NO_PROXY'] || ENV['no_proxy']
+      if no_proxy
+        list = no_proxy.split(',').map { |s| s.strip.downcase }.reject(&:empty?)
+        return {} if list.include?('*') || list.any? { |p| host.downcase == p || host.downcase.end_with?(".#{p.sub(/\A\./, '')}") }
+      end
+      out = {}
+      http = ENV['HTTP_PROXY'] || ENV['http_proxy']
+      https = ENV['HTTPS_PROXY'] || ENV['https_proxy']
+      out['http'] = http if http && !http.empty?
+      out['https'] = https if https && !https.empty?
+      out
+    rescue URI::InvalidURIError
+      {}
+    end
   end
 end

data/lib/requests/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Requests
-  VERSION = '1.0.3'
+  VERSION = '1.0.4'
 end

data/lib/requests.rb

@@ -15,5 +15,7 @@ require_relative 'requests/auth'
 require_relative 'requests/utils'
 require_relative 'requests/models'
 require_relative 'requests/adapters'
+require_relative 'requests/hpack'
+require_relative 'requests/http2'
 require_relative 'requests/sessions'
 require_relative 'requests/api'

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: requests_ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - monji024
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-30 00:00:00.000000000 Z
+date: 2026-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -26,6 +27,7 @@ dependencies:
 description: A stdlib-only Ruby HTTP client modeled after python's requests library.
   Sessions, cookies, redirects, auth (Basic/Bearer/Digest), multipart uploads, streaming
   responses, hooks, and a friendly exception hierarchy - no external gems required.
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -40,6 +42,8 @@ files:
 - lib/requests/auth.rb
 - lib/requests/cookies.rb
 - lib/requests/exceptions.rb
+- lib/requests/hpack.rb
+- lib/requests/http2.rb
 - lib/requests/models.rb
 - lib/requests/sessions.rb
 - lib/requests/status_codes.rb
@@ -56,6 +60,7 @@ metadata:
   changelog_uri: https://github.com/monji024/requests_ruby/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/monji024/requests_ruby/issues
   documentation_uri: https://rubydoc.info/gems/requests_ruby
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -70,7 +75,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.3.15
+signing_key:
 specification_version: 4
 summary: Requests is a simple, yet elegant, HTTP library.
 test_files: []