Make url as feature and bump version

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.22.0
+- Make `url` optional.
+- Add a builder for convenient headers and subprotocols construction.
+
 # 0.21.0
 - Fix read-predominant auto pong responses not flushing when hitting WouldBlock errors.
 - Improve `FrameHeader::format` write correctness.

Cargo.toml

@@ -7,9 +7,9 @@ authors = ["Alexey Galakhov", "Daniel Abramov"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 homepage = "https://github.com/snapview/tungstenite-rs"
-documentation = "https://docs.rs/tungstenite/0.21.0"
+documentation = "https://docs.rs/tungstenite/0.22.0"
 repository = "https://github.com/snapview/tungstenite-rs"
-version = "0.21.0"
+version = "0.22.0"
 edition = "2018"
 rust-version = "1.60"
 include = ["benches/**/*", "src/**/*", "examples/**/*", "LICENSE-*", "README.md", "CHANGELOG.md"]
@@ -19,7 +19,8 @@ all-features = true
 
 [features]
 default = ["handshake"]
-handshake = ["data-encoding", "http", "httparse", "sha1", "url"]
+handshake = ["data-encoding", "http", "httparse", "sha1"]
+url = ["dep:url"]
 native-tls = ["native-tls-crate"]
 native-tls-vendored = ["native-tls", "native-tls-crate/vendored"]
 rustls-tls-native-roots = ["__rustls-tls", "rustls-native-certs"]

examples/autobahn-client.rs

@@ -1,29 +1,25 @@
 use log::*;
-use url::Url;
 
 use tungstenite::{connect, Error, Message, Result};
 
 const AGENT: &str = "Tungstenite";
 
 fn get_case_count() -> Result<u32> {
-    let (mut socket, _) = connect(Url::parse("ws://localhost:9001/getCaseCount").unwrap())?;
+    let (mut socket, _) = connect("ws://localhost:9001/getCaseCount")?;
     let msg = socket.read()?;
     socket.close(None)?;
     Ok(msg.into_text()?.parse::<u32>().unwrap())
 }
 
 fn update_reports() -> Result<()> {
-    let (mut socket, _) = connect(
-        Url::parse(&format!("ws://localhost:9001/updateReports?agent={}", AGENT)).unwrap(),
-    )?;
+    let (mut socket, _) = connect(&format!("ws://localhost:9001/updateReports?agent={}", AGENT))?;
     socket.close(None)?;
     Ok(())
 }
 
 fn run_test(case: u32) -> Result<()> {
     info!("Running test case {}", case);
-    let case_url =
-        Url::parse(&format!("ws://localhost:9001/runCase?case={}&agent={}", case, AGENT)).unwrap();
+    let case_url = &format!("ws://localhost:9001/runCase?case={}&agent={}", case, AGENT);
     let (mut socket, _) = connect(case_url)?;
     loop {
         match socket.read()? {

examples/client.rs

@@ -1,11 +1,9 @@
 use tungstenite::{connect, Message};
-use url::Url;
 
 fn main() {
     env_logger::init();
 
-    let (mut socket, response) =
-        connect(Url::parse("ws://localhost:3012/socket").unwrap()).expect("Can't connect");
+    let (mut socket, response) = connect("ws://localhost:3012/socket").expect("Can't connect");
 
     println!("Connected to the server");
     println!("Response HTTP code: {}", response.status());

src/client.rs

@@ -10,8 +10,6 @@ use std::{
 use http::{request::Parts, HeaderName, Uri};
 use log::*;
 
-use url::Url;
-
 use crate::{
     handshake::client::{generate_key, Request, Response},
     protocol::WebSocketConfig,
@@ -182,7 +180,7 @@ where
 
 /// Trait for converting various types into HTTP requests used for a client connection.
 ///
-/// This trait is implemented by default for string slices, strings, `url::Url`, `http::Uri` and
+/// This trait is implemented by default for string slices, strings, `http::Uri` and
 /// `http::Request<()>`. Note that the implementation for `http::Request<()>` is trivial and will
 /// simply take your request and pass it as is further without altering any headers or URLs, so
 /// be aware of this. If you just want to connect to the endpoint with a certain URL, better pass
@@ -242,13 +240,15 @@ impl IntoClientRequest for Uri {
     }
 }
 
-impl<'a> IntoClientRequest for &'a Url {
+#[cfg(feature = "url")]
+impl<'a> IntoClientRequest for &'a url::Url {
     fn into_client_request(self) -> Result<Request> {
         self.as_str().into_client_request()
     }
 }
 
-impl IntoClientRequest for Url {
+#[cfg(feature = "url")]
+impl IntoClientRequest for url::Url {
     fn into_client_request(self) -> Result<Request> {
         self.as_str().into_client_request()
     }

tests/connection_reset.rs

@@ -12,7 +12,6 @@ use std::{
 
 use socket2::Socket;
 use tungstenite::{accept, connect, stream::MaybeTlsStream, Error, Message, WebSocket};
-use url::Url;
 
 type Sock = WebSocket<MaybeTlsStream<TcpStream>>;
 
@@ -33,8 +32,8 @@ where
         TcpListener::bind(("127.0.0.1", port)).expect("Can't listen, is port already in use?");
 
     let client_thread = spawn(move || {
-        let (client, _) = connect(Url::parse(&format!("ws://localhost:{}/socket", port)).unwrap())
-            .expect("Can't connect to port");
+        let (client, _) =
+            connect(&format!("ws://localhost:{}/socket", port)).expect("Can't connect to port");
 
         client_task(client);
     });

tests/no_send_after_close.rs

@@ -11,7 +11,6 @@ use std::{
 };
 
 use tungstenite::{accept, connect, error::ProtocolError, Error, Message};
-use url::Url;
 
 #[test]
 #[cfg(feature = "handshake")]
@@ -27,7 +26,7 @@ fn test_no_send_after_close() {
     let server = TcpListener::bind("127.0.0.1:3013").unwrap();
 
     let client_thread = spawn(move || {
-        let (mut client, _) = connect(Url::parse("ws://localhost:3013/socket").unwrap()).unwrap();
+        let (mut client, _) = connect("ws://localhost:3013/socket").unwrap();
 
         let message = client.read().unwrap(); // receive close from server
         assert!(message.is_close());

tests/receive_after_init_close.rs

@@ -11,8 +11,6 @@ use std::{
 };
 
 use tungstenite::{accept, connect, Error, Message};
-use url::Url;
-
 #[test]
 #[cfg(feature = "handshake")]
 fn test_receive_after_init_close() {
@@ -27,7 +25,7 @@ fn test_receive_after_init_close() {
     let server = TcpListener::bind("127.0.0.1:3013").unwrap();
 
     let client_thread = spawn(move || {
-        let (mut client, _) = connect(Url::parse("ws://localhost:3013/socket").unwrap()).unwrap();
+        let (mut client, _) = connect("ws://localhost:3013/socket").unwrap();
 
         client.send(Message::Text("Hello WebSocket".into())).unwrap();
 

tests/url_feature.rs

@@ -0,0 +1,46 @@
+#![cfg(feature = "handshake")]
+#![cfg(feature = "url")]
+
+use std::{
+    assert,
+    net::TcpListener,
+    println,
+    process::exit,
+    thread::{sleep, spawn},
+    time::Duration,
+};
+use tungstenite::{
+    accept_hdr, connect,
+    handshake::server::{Request, Response},
+};
+
+/// Test for write buffering and flushing behaviour.
+#[test]
+fn test_with_url() {
+    env_logger::init();
+    // notice the use of url::Url instead of a string
+    // notice the feature url is activated
+    let url = url::Url::parse("ws://127.0.0.1:3013").unwrap();
+
+    spawn(|| {
+        sleep(Duration::from_secs(5));
+        println!("Unit test executed too long, perhaps stuck on WOULDBLOCK...");
+        exit(1);
+    });
+
+    let server = TcpListener::bind("127.0.0.1:3013").unwrap();
+
+    let client_thread = spawn(move || {
+        let conn = connect(url);
+        assert!(conn.is_ok());
+    });
+
+    let client_handler = server.incoming().next().unwrap();
+
+    let closing =
+        accept_hdr(client_handler.unwrap(), |_: &Request, r: Response| Ok(r)).unwrap().close(None);
+    assert!(closing.is_ok());
+
+    let result = client_thread.join();
+    assert!(result.is_ok());
+}