Remove version specific prefixes from builders

examples/http_proxy.rs

@@ -31,8 +31,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         tokio::task::spawn(async move {
             if let Err(err) = http1::Builder::new()
-                .http1_preserve_header_case(true)
-                .http1_title_case_headers(true)
+                .preserve_header_case(true)
+                .title_case_headers(true)
                 .serve_connection(stream, service_fn(proxy))
                 .with_upgrades()
                 .await
@@ -90,8 +90,8 @@ async fn proxy(
         let stream = TcpStream::connect(addr).await.unwrap();
 
         let (mut sender, conn) = Builder::new()
-            .http1_preserve_header_case(true)
-            .http1_title_case_headers(true)
+            .preserve_header_case(true)
+            .title_case_headers(true)
             .handshake(stream)
             .await?;
         tokio::task::spawn(async move {

src/client/conn/http1.rs

@@ -333,12 +333,10 @@ impl Builder {
     /// > of 400 (Bad Request). A proxy MUST remove any such whitespace from a
     /// > response message before forwarding the message downstream.
     ///
-    /// Note that this setting does not affect HTTP/2.
-    ///
     /// Default is false.
     ///
     /// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4
-    pub fn http1_allow_spaces_after_header_name_in_responses(
+    pub fn allow_spaces_after_header_name_in_responses(
         &mut self,
         enabled: bool,
     ) -> &mut Builder {
@@ -376,12 +374,10 @@ impl Builder {
     /// > obs-fold with one or more SP octets prior to interpreting the field
     /// > value.
     ///
-    /// Note that this setting does not affect HTTP/2.
-    ///
     /// Default is false.
     ///
     /// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4
-    pub fn http1_allow_obsolete_multiline_headers_in_responses(
+    pub fn allow_obsolete_multiline_headers_in_responses(
         &mut self,
         enabled: bool,
     ) -> &mut Builder {
@@ -396,10 +392,8 @@ impl Builder {
     /// name, or does not include a colon at all, the line will be silently ignored
     /// and no error will be reported.
     ///
-    /// Note that this setting does not affect HTTP/2.
-    ///
     /// Default is false.
-    pub fn http1_ignore_invalid_headers_in_responses(&mut self, enabled: bool) -> &mut Builder {
+    pub fn ignore_invalid_headers_in_responses(&mut self, enabled: bool) -> &mut Builder {
         self.h1_parser_config
             .ignore_invalid_headers_in_responses(enabled);
         self
@@ -417,18 +411,16 @@ impl Builder {
     ///
     /// Default is `auto`. In this mode hyper will try to guess which
     /// mode to use
-    pub fn http1_writev(&mut self, enabled: bool) -> &mut Builder {
+    pub fn writev(&mut self, enabled: bool) -> &mut Builder {
         self.h1_writev = Some(enabled);
         self
     }
 
     /// Set whether HTTP/1 connections will write header names as title case at
     /// the socket level.
     ///
-    /// Note that this setting does not affect HTTP/2.
-    ///
     /// Default is false.
-    pub fn http1_title_case_headers(&mut self, enabled: bool) -> &mut Builder {
+    pub fn title_case_headers(&mut self, enabled: bool) -> &mut Builder {
         self.h1_title_case_headers = enabled;
         self
     }
@@ -443,10 +435,8 @@ impl Builder {
     /// interact with the original cases. The only effect this can have now is
     /// to forward the cases in a proxy-like fashion.
     ///
-    /// Note that this setting does not affect HTTP/2.
-    ///
     /// Default is false.
-    pub fn http1_preserve_header_case(&mut self, enabled: bool) -> &mut Builder {
+    pub fn preserve_header_case(&mut self, enabled: bool) -> &mut Builder {
         self.h1_preserve_header_case = enabled;
         self
     }
@@ -457,21 +447,19 @@ impl Builder {
     /// ordering in a private extension on the `Response`. It will also look for and use
     /// such an extension in any provided `Request`.
     ///
-    /// Note that this setting does not affect HTTP/2.
-    ///
     /// Default is false.
     #[cfg(feature = "ffi")]
-    pub fn http1_preserve_header_order(&mut self, enabled: bool) -> &mut Builder {
+    pub fn preserve_header_order(&mut self, enabled: bool) -> &mut Builder {
         self.h1_preserve_header_order = enabled;
         self
     }
 
     /// Sets the exact size of the read buffer to *always* use.
     ///
-    /// Note that setting this option unsets the `http1_max_buf_size` option.
+    /// Note that setting this option unsets the `max_buf_size` option.
     ///
     /// Default is an adaptive read buffer.
-    pub fn http1_read_buf_exact_size(&mut self, sz: Option<usize>) -> &mut Builder {
+    pub fn read_buf_exact_size(&mut self, sz: Option<usize>) -> &mut Builder {
         self.h1_read_buf_exact_size = sz;
         self.h1_max_buf_size = None;
         self
@@ -481,12 +469,12 @@ impl Builder {
     ///
     /// Default is ~400kb.
     ///
-    /// Note that setting this option unsets the `http1_read_exact_buf_size` option.
+    /// Note that setting this option unsets the `read_exact_buf_size` option.
     ///
     /// # Panics
     ///
     /// The minimum value allowed is 8192. This method panics if the passed `max` is less than the minimum.
-    pub fn http1_max_buf_size(&mut self, max: usize) -> &mut Self {
+    pub fn max_buf_size(&mut self, max: usize) -> &mut Self {
         assert!(
             max >= proto::h1::MINIMUM_MAX_BUFFER_SIZE,
             "the max_buf_size cannot be smaller than the minimum that h1 specifies."

src/client/conn/http2.rs

@@ -278,7 +278,7 @@ impl Builder {
     /// If not set, hyper will use a default.
     ///
     /// [spec]: https://http2.github.io/http2-spec/#SETTINGS_INITIAL_WINDOW_SIZE
-    pub fn http2_initial_stream_window_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
+    pub fn initial_stream_window_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
         if let Some(sz) = sz.into() {
             self.h2_builder.adaptive_window = false;
             self.h2_builder.initial_stream_window_size = sz;
@@ -291,7 +291,7 @@ impl Builder {
     /// Passing `None` will do nothing.
     ///
     /// If not set, hyper will use a default.
-    pub fn http2_initial_connection_window_size(
+    pub fn initial_connection_window_size(
         &mut self,
         sz: impl Into<Option<u32>>,
     ) -> &mut Self {
@@ -305,9 +305,9 @@ impl Builder {
     /// Sets whether to use an adaptive flow control.
     ///
     /// Enabling this will override the limits set in
-    /// `http2_initial_stream_window_size` and
-    /// `http2_initial_connection_window_size`.
-    pub fn http2_adaptive_window(&mut self, enabled: bool) -> &mut Self {
+    /// `initial_stream_window_size` and
+    /// `initial_connection_window_size`.
+    pub fn adaptive_window(&mut self, enabled: bool) -> &mut Self {
         use proto::h2::SPEC_WINDOW_SIZE;
 
         self.h2_builder.adaptive_window = enabled;
@@ -323,7 +323,7 @@ impl Builder {
     /// Passing `None` will do nothing.
     ///
     /// If not set, hyper will use a default.
-    pub fn http2_max_frame_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
+    pub fn max_frame_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self {
         if let Some(sz) = sz.into() {
             self.h2_builder.max_frame_size = sz;
         }
@@ -336,7 +336,7 @@ impl Builder {
     /// Pass `None` to disable HTTP2 keep-alive.
     ///
     /// Default is currently disabled.
-    pub fn http2_keep_alive_interval(
+    pub fn keep_alive_interval(
         &mut self,
         interval: impl Into<Option<Duration>>,
     ) -> &mut Self {
@@ -347,10 +347,10 @@ impl Builder {
     /// Sets a timeout for receiving an acknowledgement of the keep-alive ping.
     ///
     /// If the ping is not acknowledged within the timeout, the connection will
-    /// be closed. Does nothing if `http2_keep_alive_interval` is disabled.
+    /// be closed. Does nothing if `keep_alive_interval` is disabled.
     ///
     /// Default is 20 seconds.
-    pub fn http2_keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self {
+    pub fn keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self {
         self.h2_builder.keep_alive_timeout = timeout;
         self
     }
@@ -359,11 +359,11 @@ impl Builder {
     ///
     /// If disabled, keep-alive pings are only sent while there are open
     /// request/responses streams. If enabled, pings are also sent when no
-    /// streams are active. Does nothing if `http2_keep_alive_interval` is
+    /// streams are active. Does nothing if `keep_alive_interval` is
     /// disabled.
     ///
     /// Default is `false`.
-    pub fn http2_keep_alive_while_idle(&mut self, enabled: bool) -> &mut Self {
+    pub fn keep_alive_while_idle(&mut self, enabled: bool) -> &mut Self {
         self.h2_builder.keep_alive_while_idle = enabled;
         self
     }
@@ -376,7 +376,7 @@ impl Builder {
     /// The default value is determined by the `h2` crate.
     ///
     /// [`h2::client::Builder::max_concurrent_reset_streams`]: https://docs.rs/h2/client/struct.Builder.html#method.max_concurrent_reset_streams
-    pub fn http2_max_concurrent_reset_streams(&mut self, max: usize) -> &mut Self {
+    pub fn max_concurrent_reset_streams(&mut self, max: usize) -> &mut Self {
         self.h2_builder.max_concurrent_reset_streams = Some(max);
         self
     }
@@ -388,7 +388,7 @@ impl Builder {
     /// # Panics
     ///
     /// The value must be no larger than `u32::MAX`.
-    pub fn http2_max_send_buf_size(&mut self, max: usize) -> &mut Self {
+    pub fn max_send_buf_size(&mut self, max: usize) -> &mut Self {
         assert!(max <= std::u32::MAX as usize);
         self.h2_builder.max_send_buffer_size = max;
         self

src/ext.rs

@@ -76,7 +76,7 @@ impl fmt::Debug for Protocol {
 /// A map from header names to their original casing as received in an HTTP message.
 ///
 /// If an HTTP/1 response `res` is parsed on a connection whose option
-/// [`http1_preserve_header_case`] was set to true and the response included
+/// [`preserve_header_case`] was set to true and the response included
 /// the following headers:
 ///
 /// ```ignore
@@ -93,7 +93,7 @@ impl fmt::Debug for Protocol {
 /// })
 /// ```
 ///
-/// [`http1_preserve_header_case`]: /client/struct.Client.html#method.http1_preserve_header_case
+/// [`preserve_header_case`]: /client/struct.Client.html#method.preserve_header_case
 #[derive(Clone, Debug)]
 pub(crate) struct HeaderCaseMap(HeaderMap<Bytes>);
 

src/ffi/client.rs

@@ -70,9 +70,9 @@ ffi_fn! {
 
             conn::http1::Builder::new()
                 .executor(options.exec.clone())
-                .http1_allow_obsolete_multiline_headers_in_responses(options.http1_allow_obsolete_multiline_headers_in_responses)
-                .http1_preserve_header_case(options.http1_preserve_header_case)
-                .http1_preserve_header_order(options.http1_preserve_header_order)
+                .allow_obsolete_multiline_headers_in_responses(options.http1_allow_obsolete_multiline_headers_in_responses)
+                .preserve_header_case(options.http1_preserve_header_case)
+                .preserve_header_order(options.http1_preserve_header_order)
                 .handshake::<_, crate::body::Incoming>(io)
                 .await
                 .map(|(tx, conn)| {

src/server/conn/http1.rs

@@ -224,26 +224,24 @@ impl Builder {
     /// detects an EOF in the middle of a request.
     ///
     /// Default is `false`.
-    pub fn http1_half_close(&mut self, val: bool) -> &mut Self {
+    pub fn half_close(&mut self, val: bool) -> &mut Self {
         self.h1_half_close = val;
         self
     }
 
     /// Enables or disables HTTP/1 keep-alive.
     ///
     /// Default is true.
-    pub fn http1_keep_alive(&mut self, val: bool) -> &mut Self {
+    pub fn keep_alive(&mut self, val: bool) -> &mut Self {
         self.h1_keep_alive = val;
         self
     }
 
     /// Set whether HTTP/1 connections will write header names as title case at
     /// the socket level.
     ///
-    /// Note that this setting does not affect HTTP/2.
-    ///
     /// Default is false.
-    pub fn http1_title_case_headers(&mut self, enabled: bool) -> &mut Self {
+    pub fn title_case_headers(&mut self, enabled: bool) -> &mut Self {
         self.h1_title_case_headers = enabled;
         self
     }
@@ -258,10 +256,8 @@ impl Builder {
     /// interact with the original cases. The only effect this can have now is
     /// to forward the cases in a proxy-like fashion.
     ///
-    /// Note that this setting does not affect HTTP/2.
-    ///
     /// Default is false.
-    pub fn http1_preserve_header_case(&mut self, enabled: bool) -> &mut Self {
+    pub fn preserve_header_case(&mut self, enabled: bool) -> &mut Self {
         self.h1_preserve_header_case = enabled;
         self
     }
@@ -270,7 +266,7 @@ impl Builder {
     /// transmit the entire header within this time, the connection is closed.
     ///
     /// Default is None.
-    pub fn http1_header_read_timeout(&mut self, read_timeout: Duration) -> &mut Self {
+    pub fn header_read_timeout(&mut self, read_timeout: Duration) -> &mut Self {
         self.h1_header_read_timeout = Some(read_timeout);
         self
     }
@@ -287,7 +283,7 @@ impl Builder {
     ///
     /// Default is `auto`. In this mode hyper will try to guess which
     /// mode to use
-    pub fn http1_writev(&mut self, val: bool) -> &mut Self {
+    pub fn writev(&mut self, val: bool) -> &mut Self {
         self.h1_writev = Some(val);
         self
     }