From 34e98c922313f5baaae67ae8649397ea4190d2ca Mon Sep 17 00:00:00 2001 From: Daniel Abramov Date: Tue, 17 Nov 2020 11:58:42 +0100 Subject: [PATCH 1/8] chore: apply `fmt` to the whole project --- examples/autobahn-client.rs | 25 +++++++++------------- examples/autobahn-server.rs | 4 +--- examples/client.rs | 6 ++---- examples/echo-server.rs | 12 +++-------- examples/interval-server.rs | 13 ++++++------ examples/server.rs | 22 +++++--------------- rustfmt.toml | 7 +++++++ src/compat.rs | 26 ++++++++--------------- src/connect.rs | 19 ++++++++--------- src/handshake.rs | 33 +++++++++++++++-------------- src/lib.rs | 41 ++++++++++--------------------------- src/stream.rs | 6 ++++-- tests/communication.rs | 31 +++++++++------------------- tests/handshakes.rs | 8 ++------ 14 files changed, 96 insertions(+), 157 deletions(-) create mode 100644 rustfmt.toml diff --git a/examples/autobahn-client.rs b/examples/autobahn-client.rs index 8eba000e..86b765b0 100644 --- a/examples/autobahn-client.rs +++ b/examples/autobahn-client.rs @@ -1,6 +1,9 @@ use futures_util::{SinkExt, StreamExt}; use log::*; -use tokio_tungstenite::{connect_async, tungstenite::Error, tungstenite::Result}; +use tokio_tungstenite::{ + connect_async, + tungstenite::{Error, Result}, +}; use url::Url; const AGENT: &str = "Tungstenite"; @@ -12,19 +15,13 @@ async fn get_case_count() -> Result { .await?; let msg = socket.next().await.expect("Can't fetch case count")?; socket.close(None).await?; - Ok(msg - .into_text()? - .parse::() - .expect("Can't parse case count")) + Ok(msg.into_text()?.parse::().expect("Can't parse case count")) } async fn update_reports() -> Result<()> { let (mut socket, _) = connect_async( - Url::parse(&format!( - "ws://localhost:9001/updateReports?agent={}", - AGENT - )) - .expect("Can't update reports"), + Url::parse(&format!("ws://localhost:9001/updateReports?agent={}", AGENT)) + .expect("Can't update reports"), ) .await?; socket.close(None).await?; @@ -33,11 +30,9 @@ async fn update_reports() -> Result<()> { async 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 - )) - .expect("Bad testcase URL"); + let case_url = + Url::parse(&format!("ws://localhost:9001/runCase?case={}&agent={}", case, AGENT)) + .expect("Bad testcase URL"); let (mut ws_stream, _) = connect_async(case_url).await?; while let Some(msg) = ws_stream.next().await { diff --git a/examples/autobahn-server.rs b/examples/autobahn-server.rs index 1beacb0b..f79e16dd 100644 --- a/examples/autobahn-server.rs +++ b/examples/autobahn-server.rs @@ -38,9 +38,7 @@ async fn main() { info!("Listening on: {}", addr); while let Ok((stream, _)) = listener.accept().await { - let peer = stream - .peer_addr() - .expect("connected streams should have a peer address"); + let peer = stream.peer_addr().expect("connected streams should have a peer address"); info!("Peer address: {}", peer); tokio::spawn(accept_connection(peer, stream)); diff --git a/examples/client.rs b/examples/client.rs index cae0f44c..58fa960e 100644 --- a/examples/client.rs +++ b/examples/client.rs @@ -16,12 +16,10 @@ use futures_util::{future, pin_mut, StreamExt}; use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio_tungstenite::{connect_async, tungstenite::protocol::Message}; - #[tokio::main] async fn main() { - let connect_addr = env::args() - .nth(1) - .unwrap_or_else(|| panic!("this program requires at least one argument")); + let connect_addr = + env::args().nth(1).unwrap_or_else(|| panic!("this program requires at least one argument")); let url = url::Url::parse(&connect_addr).unwrap(); diff --git a/examples/echo-server.rs b/examples/echo-server.rs index ecdf29b1..2cb4f5f8 100644 --- a/examples/echo-server.rs +++ b/examples/echo-server.rs @@ -17,9 +17,7 @@ use tokio::net::{TcpListener, TcpStream}; #[tokio::main] async fn main() -> Result<(), Error> { let _ = env_logger::try_init(); - let addr = env::args() - .nth(1) - .unwrap_or_else(|| "127.0.0.1:8080".to_string()); + let addr = env::args().nth(1).unwrap_or_else(|| "127.0.0.1:8080".to_string()); // Create the event loop and TCP listener we'll accept connections on. let try_socket = TcpListener::bind(&addr).await; @@ -34,9 +32,7 @@ async fn main() -> Result<(), Error> { } async fn accept_connection(stream: TcpStream) { - let addr = stream - .peer_addr() - .expect("connected streams should have a peer address"); + let addr = stream.peer_addr().expect("connected streams should have a peer address"); info!("Peer address: {}", addr); let ws_stream = tokio_tungstenite::accept_async(stream) @@ -46,7 +42,5 @@ async fn accept_connection(stream: TcpStream) { info!("New WebSocket connection: {}", addr); let (write, read) = ws_stream.split(); - read.forward(write) - .await - .expect("Failed to forward message") + read.forward(write).await.expect("Failed to forward message") } diff --git a/examples/interval-server.rs b/examples/interval-server.rs index 8dd5cbaf..dd985529 100644 --- a/examples/interval-server.rs +++ b/examples/interval-server.rs @@ -1,8 +1,9 @@ -use futures_util::future::{select, Either}; -use futures_util::{SinkExt, StreamExt}; +use futures_util::{ + future::{select, Either}, + SinkExt, StreamExt, +}; use log::*; -use std::net::SocketAddr; -use std::time::Duration; +use std::{net::SocketAddr, time::Duration}; use tokio::net::{TcpListener, TcpStream}; use tokio_tungstenite::{accept_async, tungstenite::Error}; use tungstenite::{Message, Result}; @@ -63,9 +64,7 @@ async fn main() { info!("Listening on: {}", addr); while let Ok((stream, _)) = listener.accept().await { - let peer = stream - .peer_addr() - .expect("connected streams should have a peer address"); + let peer = stream.peer_addr().expect("connected streams should have a peer address"); info!("Peer address: {}", peer); tokio::spawn(accept_connection(peer, stream)); diff --git a/examples/server.rs b/examples/server.rs index 421b86f8..c76e2df2 100644 --- a/examples/server.rs +++ b/examples/server.rs @@ -25,12 +25,8 @@ use std::{ sync::{Arc, Mutex}, }; -use futures_util::{ - future, pin_mut, - stream::TryStreamExt, - StreamExt, -}; use futures_channel::mpsc::{unbounded, UnboundedSender}; +use futures_util::{future, pin_mut, stream::TryStreamExt, StreamExt}; use tokio::net::{TcpListener, TcpStream}; use tungstenite::protocol::Message; @@ -53,18 +49,12 @@ async fn handle_connection(peer_map: PeerMap, raw_stream: TcpStream, addr: Socke let (outgoing, incoming) = ws_stream.split(); let broadcast_incoming = incoming.try_for_each(|msg| { - println!( - "Received a message from {}: {}", - addr, - msg.to_text().unwrap() - ); + println!("Received a message from {}: {}", addr, msg.to_text().unwrap()); let peers = peer_map.lock().unwrap(); // We want to broadcast the message to everyone except ourselves. - let broadcast_recipients = peers - .iter() - .filter(|(peer_addr, _)| peer_addr != &&addr) - .map(|(_, ws_sink)| ws_sink); + let broadcast_recipients = + peers.iter().filter(|(peer_addr, _)| peer_addr != &&addr).map(|(_, ws_sink)| ws_sink); for recp in broadcast_recipients { recp.unbounded_send(msg.clone()).unwrap(); @@ -84,9 +74,7 @@ async fn handle_connection(peer_map: PeerMap, raw_stream: TcpStream, addr: Socke #[tokio::main] async fn main() -> Result<(), IoError> { - let addr = env::args() - .nth(1) - .unwrap_or_else(|| "127.0.0.1:8080".to_string()); + let addr = env::args().nth(1).unwrap_or_else(|| "127.0.0.1:8080".to_string()); let state = PeerMap::new(Mutex::new(HashMap::new())); diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 00000000..db7f39d7 --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1,7 @@ +# This project uses rustfmt to format source code. Run `cargo +nightly fmt [-- --check]. +# https://github.com/rust-lang/rustfmt/blob/master/Configurations.md + +# Break complex but short statements a bit less. +use_small_heuristics = "Max" + +merge_imports = true diff --git a/src/compat.rs b/src/compat.rs index 393fa032..6bbd0e68 100644 --- a/src/compat.rs +++ b/src/compat.rs @@ -1,7 +1,9 @@ use log::*; -use std::io::{Read, Write}; -use std::pin::Pin; -use std::task::{Context, Poll}; +use std::{ + io::{Read, Write}, + pin::Pin, + task::{Context, Poll}, +}; use futures_util::task; use std::sync::Arc; @@ -147,11 +149,7 @@ where trace!("{}:{} Read.read", file!(), line!()); let mut buf = ReadBuf::new(buf); match self.with_context(ContextWaker::Read, |ctx, stream| { - trace!( - "{}:{} Read.with_context read -> poll_read", - file!(), - line!() - ); + trace!("{}:{} Read.with_context read -> poll_read", file!(), line!()); stream.poll_read(ctx, &mut buf) }) { Poll::Ready(Ok(_)) => Ok(buf.filled().len()), @@ -168,11 +166,7 @@ where fn write(&mut self, buf: &[u8]) -> std::io::Result { trace!("{}:{} Write.write", file!(), line!()); match self.with_context(ContextWaker::Write, |ctx, stream| { - trace!( - "{}:{} Write.with_context write -> poll_write", - file!(), - line!() - ); + trace!("{}:{} Write.with_context write -> poll_write", file!(), line!()); stream.poll_write(ctx, buf) }) { Poll::Ready(r) => r, @@ -183,11 +177,7 @@ where fn flush(&mut self) -> std::io::Result<()> { trace!("{}:{} Write.flush", file!(), line!()); match self.with_context(ContextWaker::Write, |ctx, stream| { - trace!( - "{}:{} Write.with_context flush -> poll_flush", - file!(), - line!() - ); + trace!("{}:{} Write.with_context flush -> poll_flush", file!(), line!()); stream.poll_flush(ctx) }) { Poll::Ready(r) => r, diff --git a/src/connect.rs b/src/connect.rs index f85b11fc..0587cf2f 100644 --- a/src/connect.rs +++ b/src/connect.rs @@ -1,11 +1,12 @@ //! Connection helper. -use tokio::io::{AsyncRead, AsyncWrite}; -use tokio::net::TcpStream; +use tokio::{ + io::{AsyncRead, AsyncWrite}, + net::TcpStream, +}; -use tungstenite::client::uri_mode; -use tungstenite::handshake::client::Response; -use tungstenite::protocol::WebSocketConfig; -use tungstenite::Error; +use tungstenite::{ + client::uri_mode, handshake::client::Response, protocol::WebSocketConfig, Error, +}; use super::{client_async_with_config, IntoClientRequest, Request, WebSocketStream}; @@ -16,8 +17,7 @@ pub(crate) mod encryption { use tokio::io::{AsyncRead, AsyncWrite}; - use tungstenite::stream::Mode; - use tungstenite::Error; + use tungstenite::{stream::Mode, Error}; use crate::stream::Stream as StreamSwitcher; @@ -63,8 +63,7 @@ pub use self::encryption::TlsConnector; pub(crate) mod encryption { use tokio::io::{AsyncRead, AsyncWrite}; - use tungstenite::stream::Mode; - use tungstenite::Error; + use tungstenite::{stream::Mode, Error}; pub type AutoStream = S; diff --git a/src/handshake.rs b/src/handshake.rs index 8020a617..a0c52dfd 100644 --- a/src/handshake.rs +++ b/src/handshake.rs @@ -1,16 +1,23 @@ -use crate::compat::{AllowStd, SetWaker}; -use crate::WebSocketStream; +use crate::{ + compat::{AllowStd, SetWaker}, + WebSocketStream, +}; use log::*; use pin_project::pin_project; -use std::future::Future; -use std::io::{Read, Write}; -use std::pin::Pin; -use std::task::{Context, Poll}; +use std::{ + future::Future, + io::{Read, Write}, + pin::Pin, + task::{Context, Poll}, +}; use tokio::io::{AsyncRead, AsyncWrite}; -use tungstenite::handshake::client::Response; -use tungstenite::handshake::server::Callback; -use tungstenite::handshake::{HandshakeError as Error, HandshakeRole, MidHandshake as WsHandshake}; -use tungstenite::{ClientHandshake, ServerHandshake, WebSocket}; +use tungstenite::{ + handshake::{ + client::Response, server::Callback, HandshakeError as Error, HandshakeRole, + MidHandshake as WsHandshake, + }, + ClientHandshake, ServerHandshake, WebSocket, +}; pub(crate) async fn without_handshake(stream: S, f: F) -> WebSocketStream where @@ -39,11 +46,7 @@ where type Output = WebSocket>; fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll { - let inner = self - .get_mut() - .0 - .take() - .expect("future polled after completion"); + let inner = self.get_mut().0.take().expect("future polled after completion"); trace!("Setting context when skipping handshake"); let stream = AllowStd::new(inner.stream, ctx.waker()); diff --git a/src/lib.rs b/src/lib.rs index 1d0019a5..bfb6741f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -8,13 +8,7 @@ //! Each WebSocket stream implements the required `Stream` and `Sink` traits, //! so the socket is just a stream of messages coming in and going out. -#![deny( - missing_docs, - unused_must_use, - unused_mut, - unused_imports, - unused_import_braces -)] +#![deny(missing_docs, unused_must_use, unused_mut, unused_imports, unused_import_braces)] pub use tungstenite; @@ -33,8 +27,10 @@ use futures_util::{ stream::Stream, }; use log::*; -use std::pin::Pin; -use std::task::{Context, Poll}; +use std::{ + pin::Pin, + task::{Context, Poll}, +}; use tokio::io::{AsyncRead, AsyncWrite}; use tungstenite::{ @@ -51,10 +47,7 @@ use tungstenite::{ #[cfg(feature = "connect")] pub use connect::{ - client_async_tls, - client_async_tls_with_config, - connect_async, - connect_async_with_config, + client_async_tls, client_async_tls_with_config, connect_async, connect_async_with_config, TlsConnector, }; @@ -103,10 +96,7 @@ where }); f.await.map_err(|e| match e { HandshakeError::Failure(e) => e, - e => WsError::Io(std::io::Error::new( - std::io::ErrorKind::Other, - e.to_string(), - )), + e => WsError::Io(std::io::Error::new(std::io::ErrorKind::Other, e.to_string())), }) } @@ -169,10 +159,7 @@ where }); f.await.map_err(|e| match e { HandshakeError::Failure(e) => e, - e => WsError::Io(std::io::Error::new( - std::io::ErrorKind::Other, - e.to_string(), - )), + e => WsError::Io(std::io::Error::new(std::io::ErrorKind::Other, e.to_string())), }) } @@ -254,8 +241,7 @@ impl WebSocketStream { } /// Returns a reference to the configuration of the tungstenite stream. - pub fn get_config(&self) -> &WebSocketConfig - { + pub fn get_config(&self) -> &WebSocketConfig { self.inner.get_config() } @@ -278,11 +264,7 @@ where fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { trace!("{}:{} Stream.poll_next", file!(), line!()); match futures_util::ready!(self.with_context(Some((ContextWaker::Read, cx)), |s| { - trace!( - "{}:{} Stream.with_context poll_next -> read_message()", - file!(), - line!() - ); + trace!("{}:{} Stream.with_context poll_next -> read_message()", file!(), line!()); cvt(s.read_message()) })) { Ok(v) => Poll::Ready(Some(Ok(v))), @@ -337,10 +319,9 @@ where #[cfg(test)] mod tests { - use crate::compat::AllowStd; #[cfg(feature = "connect")] use crate::connect::encryption::AutoStream; - use crate::WebSocketStream; + use crate::{compat::AllowStd, WebSocketStream}; use std::io::{Read, Write}; use tokio::io::{AsyncReadExt, AsyncWriteExt}; diff --git a/src/stream.rs b/src/stream.rs index 29b740c0..989ab1d0 100644 --- a/src/stream.rs +++ b/src/stream.rs @@ -4,8 +4,10 @@ //! `native_tls` or `openssl` will work as long as there is a TLS stream supporting standard //! `Read + Write` traits. use pin_project::pin_project; -use std::pin::Pin; -use std::task::{Context, Poll}; +use std::{ + pin::Pin, + task::{Context, Poll}, +}; use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; diff --git a/tests/communication.rs b/tests/communication.rs index db69685e..f17cd418 100644 --- a/tests/communication.rs +++ b/tests/communication.rs @@ -1,7 +1,9 @@ use futures_util::{SinkExt, StreamExt}; use log::*; -use tokio::io::{AsyncRead, AsyncWrite}; -use tokio::net::{TcpListener, TcpStream}; +use tokio::{ + io::{AsyncRead, AsyncWrite}, + net::{TcpListener, TcpStream}, +}; use tokio_tungstenite::{accept_async, client_async, WebSocketStream}; use tungstenite::Message; @@ -45,20 +47,13 @@ async fn communication() { info!("Waiting for server to be ready"); con_rx.await.expect("Server not ready"); - let tcp = TcpStream::connect("0.0.0.0:12345") - .await - .expect("Failed to connect"); + let tcp = TcpStream::connect("0.0.0.0:12345").await.expect("Failed to connect"); let url = "ws://localhost:12345/"; - let (mut stream, _) = client_async(url, tcp) - .await - .expect("Client failed to connect"); + let (mut stream, _) = client_async(url, tcp).await.expect("Client failed to connect"); for i in 1..10 { info!("Sending message"); - stream - .send(Message::Text(format!("{}", i))) - .await - .expect("Failed to send message"); + stream.send(Message::Text(format!("{}", i))).await.expect("Failed to send message"); } stream.close(None).await.expect("Failed to close"); @@ -91,20 +86,14 @@ async fn split_communication() { info!("Waiting for server to be ready"); con_rx.await.expect("Server not ready"); - let tcp = TcpStream::connect("0.0.0.0:12346") - .await - .expect("Failed to connect"); + let tcp = TcpStream::connect("0.0.0.0:12346").await.expect("Failed to connect"); let url = url::Url::parse("ws://localhost:12345/").unwrap(); - let (stream, _) = client_async(url, tcp) - .await - .expect("Client failed to connect"); + let (stream, _) = client_async(url, tcp).await.expect("Client failed to connect"); let (mut tx, _rx) = stream.split(); for i in 1..10 { info!("Sending message"); - tx.send(Message::Text(format!("{}", i))) - .await - .expect("Failed to send message"); + tx.send(Message::Text(format!("{}", i))).await.expect("Failed to send message"); } tx.close().await.expect("Failed to close"); diff --git a/tests/handshakes.rs b/tests/handshakes.rs index b4001e2b..a22842cd 100644 --- a/tests/handshakes.rs +++ b/tests/handshakes.rs @@ -17,11 +17,7 @@ async fn handshakes() { tokio::spawn(f); rx.await.expect("Failed to wait for server to be ready"); - let tcp = TcpStream::connect("0.0.0.0:12345") - .await - .expect("Failed to connect"); + let tcp = TcpStream::connect("0.0.0.0:12345").await.expect("Failed to connect"); let url = url::Url::parse("ws://localhost:12345/").unwrap(); - let _stream = client_async(url, tcp) - .await - .expect("Client failed to connect"); + let _stream = client_async(url, tcp).await.expect("Client failed to connect"); } From 1a3ed2fc6f5fb54a10bb690f2f5c35341eeada90 Mon Sep 17 00:00:00 2001 From: Daniel Abramov Date: Mon, 23 Nov 2020 17:57:59 +0100 Subject: [PATCH 2/8] actions: try to format the code --- .github/workflows/ci.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9b900249..ffd57a8a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -35,6 +35,9 @@ jobs: - name: Test run: cargo test --release + - name: Format + run: cargo +nightly fmt + autobahn: name: Autobahn tests runs-on: ubuntu-latest From 488dd5c9edb7d4bed20bc5f316084e83a7635803 Mon Sep 17 00:00:00 2001 From: Daniel Abramov Date: Mon, 23 Nov 2020 18:24:43 +0100 Subject: [PATCH 3/8] Update .github/workflows/ci.yml MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Matěj Laitl --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ffd57a8a..c20fdb60 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -36,7 +36,7 @@ jobs: run: cargo test --release - name: Format - run: cargo +nightly fmt + run: cargo +nightly fmt -- --check autobahn: name: Autobahn tests From f038217e0ce292f24550fa7401a8a7bd1f91a3be Mon Sep 17 00:00:00 2001 From: Daniel Abramov Date: Mon, 23 Nov 2020 18:38:57 +0100 Subject: [PATCH 4/8] actions: remove `+nightly` --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c20fdb60..08073bcf 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -36,7 +36,7 @@ jobs: run: cargo test --release - name: Format - run: cargo +nightly fmt -- --check + run: cargo fmt -- --check autobahn: name: Autobahn tests From 2e75e7693c172c91411f007128e1831caee10c96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Oliveira?= Date: Thu, 26 Nov 2020 17:08:21 +0000 Subject: [PATCH 5/8] actions: re-enable +nightly fmt check --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 08073bcf..c20fdb60 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -36,7 +36,7 @@ jobs: run: cargo test --release - name: Format - run: cargo fmt -- --check + run: cargo +nightly fmt -- --check autobahn: name: Autobahn tests From 6b0d4e20b02ea640abeb1a56f508dc015005e265 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Oliveira?= Date: Thu, 26 Nov 2020 17:13:04 +0000 Subject: [PATCH 6/8] actions: move formatting up in the pipeline so that runs before tests --- .github/workflows/ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c20fdb60..03b6ffb7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -29,15 +29,15 @@ jobs: - name: Check default-features run: cargo check + - name: Format + run: cargo +nightly fmt -- --check + - name: Check tls run: cargo check --features tls - name: Test run: cargo test --release - - name: Format - run: cargo +nightly fmt -- --check - autobahn: name: Autobahn tests runs-on: ubuntu-latest From fb9a31e5776fc67cb77fa570aec48b7460883118 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Oliveira?= Date: Thu, 26 Nov 2020 18:39:18 +0000 Subject: [PATCH 7/8] actions: take formatting into a different step --- .github/workflows/ci.yml | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 03b6ffb7..07261d11 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -3,6 +3,20 @@ name: CI on: [push, pull_request] jobs: + fmt: + name: Format + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + toolchain: nightly + override: true + - uses: actions-rs/cargo@v1 + with: + command: fmt + args: --all -- --check + test: name: Test runs-on: ubuntu-latest @@ -29,9 +43,6 @@ jobs: - name: Check default-features run: cargo check - - name: Format - run: cargo +nightly fmt -- --check - - name: Check tls run: cargo check --features tls From 518ad040f6a17a7f82c1275f99f78c9296622d69 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Oliveira?= Date: Thu, 26 Nov 2020 18:41:37 +0000 Subject: [PATCH 8/8] actions: add rustfmt to components --- .github/workflows/ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 07261d11..ac0bbe21 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -11,6 +11,7 @@ jobs: - uses: actions-rs/toolchain@v1 with: toolchain: nightly + components: rustfmt override: true - uses: actions-rs/cargo@v1 with: