Merge branch 'dependabot/cargo/base64-0.22' of https://github.com/swimos/swim-rust into unused-deps

Author: SirCipher

Cargo.toml

@@ -76,7 +76,7 @@ nom_locate = "4.0"
 tracing = "0.1"
 tracing-subscriber = "0.3"
 tracing-appender = "0.2"
-base64 = "0.13"
+base64 = "0.22"
 num-traits = "0.2"
 thiserror = "1.0"
 static_assertions = "1.1.0"

api/formats/swimos_recon/src/printer/mod.rs

@@ -16,6 +16,7 @@
 mod tests;
 
 use base64::display::Base64Display;
+use base64::engine::general_purpose::STANDARD;
 use std::borrow::Cow;
 use std::fmt::{Debug, Display, Formatter};
 use swimos_form::write::{
@@ -224,34 +225,18 @@ where
     fn write_blob_vec(self, blob: Vec<u8>) -> Result<Self::Repr, Self::Error> {
         let StructurePrinter { fmt, has_attr, .. } = self;
         if has_attr {
-            write!(
-                fmt,
-                " %{}",
-                Base64Display::with_config(blob.as_slice(), base64::STANDARD)
-            )
+            write!(fmt, " %{}", Base64Display::new(blob.as_slice(), &STANDARD))
         } else {
-            write!(
-                fmt,
-                "%{}",
-                Base64Display::with_config(blob.as_slice(), base64::STANDARD)
-            )
+            write!(fmt, "%{}", Base64Display::new(blob.as_slice(), &STANDARD))
         }
     }
 
     fn write_blob(self, value: &[u8]) -> Result<Self::Repr, Self::Error> {
         let StructurePrinter { fmt, has_attr, .. } = self;
         if has_attr {
-            write!(
-                fmt,
-                " %{}",
-                Base64Display::with_config(value, base64::STANDARD)
-            )
+            write!(fmt, " %{}", Base64Display::new(value, &STANDARD))
         } else {
-            write!(
-                fmt,
-                "%{}",
-                Base64Display::with_config(value, base64::STANDARD)
-            )
+            write!(fmt, "%{}", Base64Display::new(value, &STANDARD))
         }
     }
 }
@@ -612,7 +597,7 @@ where
             strategy,
             ..
         } = self;
-        let rep = Base64Display::with_config(blob.as_slice(), base64::STANDARD);
+        let rep = Base64Display::new(blob.as_slice(), &STANDARD);
         if delegated {
             if has_attr {
                 write!(fmt, " %{}{})", &rep, strategy.attr_body_padding())
@@ -638,7 +623,7 @@ where
             strategy,
             ..
         } = self;
-        let rep = Base64Display::with_config(value, base64::STANDARD);
+        let rep = Base64Display::new(value, &STANDARD);
         if delegated {
             if has_attr {
                 write!(fmt, " %{}{})", &rep, strategy.attr_body_padding())

api/formats/swimos_recon/src/recon_parser/tokens.rs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 use crate::parser::Span;
+use base64::{engine::general_purpose::STANDARD, Engine};
 use either::Either;
 use nom::branch::alt;
 use nom::combinator::{map, map_res, opt, peek, recognize};
@@ -333,7 +334,7 @@ macro_rules! token_mod {
             }
 
             pub fn blob(input: Span<'_>) -> IResult<Span<'_>, Vec<u8>> {
-                map_res(base64_literal, |span| base64::decode(*span))(input)
+                map_res(base64_literal, |span| STANDARD.decode(*span))(input)
             }
 
             pub fn comments(input: Span<'_>) -> IResult<Span<'_>, Vec<Span<'_>>> {

api/swimos_model/src/blob.rs

@@ -12,8 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use base64::write::EncoderWriter;
-use base64::{DecodeError, URL_SAFE};
+use base64::{engine::general_purpose::URL_SAFE, write::EncoderWriter, DecodeError, Engine};
 use core::fmt;
 use std::borrow::{Borrow, BorrowMut};
 use std::fmt::{Display, Formatter};
@@ -41,17 +40,17 @@ impl Blob {
 
     /// Attempts to encode this blob's data into the provided writer.
     pub fn encode_to_writer<W: Write>(&self, mut writer: W) -> io::Result<()> {
-        EncoderWriter::new(&mut writer, URL_SAFE).write_all(&self.data)
+        EncoderWriter::new(&mut writer, &URL_SAFE).write_all(&self.data)
     }
 
     /// Consumes this BLOB and returns the decoded data.
     pub fn into_decoded(self) -> Result<Vec<u8>, DecodeError> {
-        base64::decode_config(self.data, URL_SAFE)
+        URL_SAFE.decode(self.data)
     }
 
     /// Clone the underlying data and decode it.
     pub fn as_decoded(&self) -> Result<Vec<u8>, DecodeError> {
-        base64::decode_config(self.data.clone(), URL_SAFE)
+        URL_SAFE.decode(self.data.clone())
     }
 
     /// Attempts to decode the provided data. Returning a result containing either the decoded data
@@ -60,12 +59,12 @@ impl Blob {
     where
         T: AsRef<[u8]>,
     {
-        base64::decode_config(encoded.as_ref(), URL_SAFE).map(Blob::from_vec)
+        URL_SAFE.decode(encoded).map(Blob::from_vec)
     }
 
     /// Encodes the provided data into a [`Blob`].
     pub fn encode<T: AsRef<[u8]>>(input: T) -> Blob {
-        let encoded = base64::encode_config(input, URL_SAFE);
+        let encoded = URL_SAFE.encode(input);
         Blob {
             data: Vec::from(encoded.as_bytes()),
         }
@@ -114,8 +113,8 @@ mod tests {
 
     #[test]
     fn from_encoded() {
-        let encoded = base64::encode_config("swimming", URL_SAFE);
-        let decoded = base64::decode_config(encoded.as_bytes(), URL_SAFE).unwrap();
+        let encoded = URL_SAFE.encode("swimming");
+        let decoded = URL_SAFE.decode(encoded.as_bytes()).unwrap();
         let blob = Blob::from_encoded(Vec::from(encoded.as_bytes()));
 
         assert_eq!(decoded, blob.into_decoded().unwrap())

runtime/swimos_http/src/websocket.rs

@@ -1,9 +1,4 @@
-use std::{
-    collections::HashSet,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
+use base64::{engine::general_purpose::STANDARD, Engine};
 use bytes::{Bytes, BytesMut};
 use futures::{ready, Future, FutureExt};
 use http::{header::HeaderName, HeaderMap, HeaderValue, Method};
@@ -17,6 +12,11 @@ use ratchet::{
     WebSocketStream,
 };
 use sha1::{Digest, Sha1};
+use std::{
+    collections::HashSet,
+    pin::Pin,
+    task::{Context, Poll},
+};
 use thiserror::Error;
 
 const UPGRADE_STR: &str = "Upgrade";
@@ -125,7 +125,7 @@ where
     Digest::update(&mut digest, key);
     Digest::update(&mut digest, ACCEPT_KEY);
 
-    let sec_websocket_accept = base64::encode(digest.finalize());
+    let sec_websocket_accept = STANDARD.encode(digest.finalize());
     let mut builder = Response::builder()
         .status(http::StatusCode::SWITCHING_PROTOCOLS)
         .header(http::header::SEC_WEBSOCKET_ACCEPT, sec_websocket_accept)

server/swimos_server_app/src/server/http/tests.rs

@@ -119,7 +119,6 @@ impl Listener<DuplexStream> for TestListener {
 }
 
 async fn run_server(rx: mpsc::Receiver<DuplexStream>, find_tx: mpsc::Sender<FindNode>) {
-    println!("Server start");
     let listener = TestListener { rx };
 
     let config = HttpConfig {