clippy

Author: s0l0ist

examples/advanced-appconfig-feature-flags/src/main.rs

@@ -35,9 +35,9 @@ async fn function_handler<T: ConfigurationFetcher + Send + Sync>(
 
     // Use the feature flag
     let msg = if config.spanish_response {
-        format!("{}, in spanish.", quote)
+        format!("{quote}, in spanish.")
     } else {
-        format!("{}.", quote)
+        format!("{quote}.")
     };
 
     // Return `Response` (it will be serialized to JSON automatically by the runtime)

examples/advanced-sqs-partial-batch-failures/src/main.rs

@@ -55,7 +55,7 @@ where
     D: DeserializeOwned,
     R: Future<Output = Result<(), Error>>,
 {
-    run(service_fn(|e| batch_handler(|d| f(d), e))).await
+    run(service_fn(|e| batch_handler(&f, e))).await
 }
 
 /// Helper function to lift the user provided `f` function from message to batch of messages.
@@ -123,7 +123,7 @@ mod test {
     }
 
     #[tokio::test]
-    async fn test() -> () {
+    async fn test() {
         let msg_to_fail: SqsMessageObj<serde_json::Value> = serde_json::from_str(
             r#"{
                 "messageId": "1",

examples/basic-error-handling/src/main.rs

@@ -43,7 +43,7 @@ impl std::fmt::Display for CustomError {
     /// Display the error struct as a JSON string
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let err_as_json = json!(self).to_string();
-        write!(f, "{}", err_as_json)
+        write!(f, "{err_as_json}")
     }
 }
 
@@ -66,7 +66,7 @@ pub(crate) async fn func(event: LambdaEvent<Request>) -> Result<Response, Error>
     match event.event_type {
         EventType::SimpleError => {
             // generate a simple text message error using `simple_error` crate
-            return Err(Box::new(simple_error::SimpleError::new("A simple error as requested!")));
+            Err(Box::new(simple_error::SimpleError::new("A simple error as requested!")))
         }
         EventType::CustomError => {
             // generate a custom error using our own structure
@@ -75,7 +75,7 @@ pub(crate) async fn func(event: LambdaEvent<Request>) -> Result<Response, Error>
                 req_id: ctx.request_id,
                 msg: "A custom error as requested!".into(),
             };
-            return Err(Box::new(cust_err));
+            Err(Box::new(cust_err))
         }
         EventType::ExternalError => {
             // try to open a non-existent file to get an error and propagate it with `?`
@@ -94,7 +94,7 @@ pub(crate) async fn func(event: LambdaEvent<Request>) -> Result<Response, Error>
                 msg: "OK".into(),
             };
 
-            return Ok(resp);
+            Ok(resp)
         }
     }
 }

examples/basic-error-thiserror/src/main.rs

@@ -1,6 +1,5 @@
 use lambda_runtime::{service_fn, Diagnostic, Error, LambdaEvent};
 use serde::Deserialize;
-use thiserror;
 
 #[derive(Deserialize)]
 struct Request {}
@@ -21,7 +20,7 @@ impl From<ExecutionError> for Diagnostic {
         };
         Diagnostic {
             error_type: error_type.into(),
-            error_message: error_message.into(),
+            error_message,
         }
     }
 }

examples/basic-lambda-external-runtime/src/main.rs

@@ -53,7 +53,7 @@ fn main() -> Result<(), io::Error> {
     my_runtime(move || future::block_on(app_runtime_task(lambda_rx.clone(), shutdown_tx.clone())));
 
     // Block the main thread until a shutdown signal is received.
-    future::block_on(shutdown_rx.recv()).map_err(|err| io::Error::new(io::ErrorKind::Other, format!("{:?}", err)))
+    future::block_on(shutdown_rx.recv()).map_err(|err| io::Error::other(format!("{err:?}")))
 }
 
 pub(crate) async fn my_handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
@@ -63,7 +63,7 @@ pub(crate) async fn my_handler(event: LambdaEvent<Request>) -> Result<Response,
     // prepare the response
     let resp = Response {
         req_id: event.context.request_id,
-        msg: format!("Command {} executed.", command),
+        msg: format!("Command {command} executed."),
     };
 
     // return `Response` (it will be serialized to JSON automatically by the runtime)

examples/basic-lambda/src/main.rs

@@ -39,7 +39,7 @@ pub(crate) async fn my_handler(event: LambdaEvent<Request>) -> Result<Response,
     // prepare the response
     let resp = Response {
         req_id: event.context.request_id,
-        msg: format!("Command {} executed.", command),
+        msg: format!("Command {command} executed."),
     };
 
     // return `Response` (it will be serialized to JSON automatically by the runtime)

examples/basic-s3-object-lambda-thumbnail/src/main.rs

@@ -114,7 +114,7 @@ mod tests {
 
         mock.expect_send_file()
             .withf(|r, t, by| {
-                return r.eq("O_ROUTE") && t.eq("O_TOKEN") && by == "THUMBNAIL".as_bytes();
+                r.eq("O_ROUTE") && t.eq("O_TOKEN") && by == "THUMBNAIL".as_bytes()
             })
             .returning(|_1, _2, _3| Ok("File sent.".to_string()));
 
@@ -128,7 +128,7 @@ mod tests {
     }
 
     fn get_s3_event() -> S3ObjectLambdaEvent {
-        return S3ObjectLambdaEvent {
+        S3ObjectLambdaEvent {
             x_amz_request_id: ("ID".to_string()),
             head_object_context: (Some(HeadObjectContext::default())),
             list_objects_context: (Some(ListObjectsContext::default())),
@@ -146,6 +146,6 @@ mod tests {
                 supporting_access_point_arn: ("SAPRN".to_string()),
                 payload: (json!(null)),
             }),
-        };
+        }
     }
 }

examples/basic-s3-thumbnail/src/main.rs

@@ -174,22 +174,22 @@ mod tests {
 
         mock.expect_put_file()
             .withf(|bu, ke, by| {
-                return bu.eq("test-bucket-thumbs") && ke.eq(key) && by.eq("THUMBNAIL".as_bytes());
+                bu.eq("test-bucket-thumbs") && ke.eq(key) && by.eq("THUMBNAIL".as_bytes())
             })
             .return_const(Ok("Done".to_string()));
 
         let payload = get_s3_event("ObjectCreated", bucket, key);
         let event = LambdaEvent { payload, context };
 
-        let result = function_handler(event, 10, &mock).await.unwrap();
+        function_handler(event, 10, &mock).await.unwrap();
 
-        assert_eq!((), result);
+        assert_eq!((), ());
     }
 
     fn get_s3_event(event_name: &str, bucket_name: &str, object_key: &str) -> S3Event {
-        return S3Event {
+        S3Event {
             records: (vec![get_s3_event_record(event_name, bucket_name, object_key)]),
-        };
+        }
     }
 
     fn get_s3_event_record(event_name: &str, bucket_name: &str, object_key: &str) -> S3EventRecord {
@@ -213,7 +213,7 @@ mod tests {
             }),
         };
 
-        return S3EventRecord {
+        S3EventRecord {
             event_version: (Some(String::default())),
             event_source: (Some(String::default())),
             aws_region: (Some(String::default())),
@@ -227,6 +227,6 @@ mod tests {
             }),
             response_elements: (HashMap::new()),
             s3: (s3_entity),
-        };
+        }
     }
 }

examples/basic-s3-thumbnail/src/s3.rs

@@ -43,7 +43,7 @@ impl PutFile for S3Client {
         let result = self.put_object().bucket(bucket).key(key).body(bytes).send().await;
 
         match result {
-            Ok(_) => Ok(format!("Uploaded a file with key {} into {}", key, bucket)),
+            Ok(_) => Ok(format!("Uploaded a file with key {key} into {bucket}")),
             Err(err) => Err(err.into_service_error().meta().message().unwrap().to_string()),
         }
     }

examples/basic-sdk/src/main.rs

@@ -52,7 +52,7 @@ async fn my_handler<T: ListObjects>(event: LambdaEvent<Request>, client: &T) ->
     let objects_rsp = client.list_objects(&bucket).await?;
     let objects: Vec<_> = objects_rsp
         .contents()
-        .into_iter()
+        .iter()
         .filter_map(|o| o.key().map(|k| k.to_string()))
         .collect();