Make ws::Message an enum for easier frame type matching (#116)

* feat(ws): make Message an enum to allow pattern matching

* fix(examples): update to new websockets `Message`

* fix(ws): remove wildcard imports

* fix(examples/chat): apply clippy's never_loop

* style: `cargo fmt`

* docs:add license notes above parts that are copied

* fix(ws): make CloseCode an alias to u16

* fix: move Message from src/ws/mod.rs to src/extract/ws.rs

* docs: add changelog entry about websocket messages

* fix: remove useless convertions to the same type

examples/chat.rs

@@ -59,17 +59,19 @@ async fn websocket(stream: WebSocket, state: Arc<AppState>) {
     let mut username = String::new();
 
     // Loop until a text message is found.
-    while let Some(Ok(msg)) = receiver.next().await {
-        if let Some(name) = msg.to_str() {
+    while let Some(Ok(message)) = receiver.next().await {
+        if let Message::Text(name) = message {
             // If username that is sent by client is not taken, fill username string.
-            check_username(&state, &mut username, name);
+            check_username(&state, &mut username, &name);
 
             // If not empty we want to quit the loop else we want to quit function.
             if !username.is_empty() {
                 break;
             } else {
                 // Only send our client that username is taken.
-                let _ = sender.send(Message::text("Username already taken.")).await;
+                let _ = sender
+                    .send(Message::Text(String::from("Username already taken.")))
+                    .await;
 
                 return;
             }
@@ -87,7 +89,7 @@ async fn websocket(stream: WebSocket, state: Arc<AppState>) {
     let mut send_task = tokio::spawn(async move {
         while let Ok(msg) = rx.recv().await {
             // In any websocket error, break loop.
-            if sender.send(Message::text(msg)).await.is_err() {
+            if sender.send(Message::Text(msg)).await.is_err() {
                 break;
             }
         }
@@ -99,11 +101,9 @@ async fn websocket(stream: WebSocket, state: Arc<AppState>) {
 
     // This task will receive messages from client and send them to broadcast subscribers.
     let mut recv_task = tokio::spawn(async move {
-        while let Some(Ok(msg)) = receiver.next().await {
-            if let Some(text) = msg.to_str() {
-                // Add username before message.
-                let _ = tx.send(format!("{}: {}", name, text));
-            }
+        while let Some(Ok(Message::Text(text))) = receiver.next().await {
+            // Add username before message.
+            let _ = tx.send(format!("{}: {}", name, text));
         }
     });
 

examples/websocket.rs

@@ -84,7 +84,11 @@ async fn handle_socket(mut socket: WebSocket) {
     }
 
     loop {
-        if socket.send(Message::text("Hi!")).await.is_err() {
+        if socket
+            .send(Message::Text(String::from("Hi!")))
+            .await
+            .is_err()
+        {
             println!("client disconnected");
             return;
         }