Merge pull request #286 from JohnTitor/clean-up

Clean-up things

async_db/src/db.rs

@@ -1,8 +1,6 @@
 use actix_web::{web, Error as AWError};
 use failure::Error;
 use futures::{Future, TryFutureExt};
-use r2d2;
-use r2d2_sqlite;
 use rusqlite::{Statement, NO_PARAMS};
 use serde::{Deserialize, Serialize};
 use std::{thread::sleep, time::Duration};

async_db/src/main.rs

@@ -22,6 +22,7 @@ mod db;
 use db::{Pool, Queries};
 
 /// Version 1: Calls 4 queries in sequential order, as an asynchronous handler
+#[allow(clippy::eval_order_dependence)] // it's FP?
 async fn asyncio_weather(db: web::Data<Pool>) -> Result<HttpResponse, AWError> {
     let result = vec![
         db::execute(&db, Queries::GetTopTenHottestYears).await?,

async_ex2/src/handlers/parts.rs

@@ -2,18 +2,18 @@ use actix_web::{web, Error, HttpResponse};
 
 use crate::common::{Part, Product};
 
-pub async fn get_parts(query: web::Query<Option<Part>>) -> Result<HttpResponse, Error> {
+pub async fn get_parts(_query: web::Query<Option<Part>>) -> Result<HttpResponse, Error> {
     Ok(HttpResponse::Ok().finish())
 }
 
-pub async fn add_part(new_part: web::Json<Product>) -> Result<HttpResponse, Error> {
+pub async fn add_part(_new_part: web::Json<Product>) -> Result<HttpResponse, Error> {
     Ok(HttpResponse::Ok().finish())
 }
 
-pub async fn get_part_detail(id: web::Path<String>) -> Result<HttpResponse, Error> {
+pub async fn get_part_detail(_id: web::Path<String>) -> Result<HttpResponse, Error> {
     Ok(HttpResponse::Ok().finish())
 }
 
-pub async fn remove_part(id: web::Path<String>) -> Result<HttpResponse, Error> {
+pub async fn remove_part(_id: web::Path<String>) -> Result<HttpResponse, Error> {
     Ok(HttpResponse::Ok().finish())
 }

async_ex2/src/handlers/products.rs

@@ -3,22 +3,22 @@ use actix_web::{web, Error, HttpResponse};
 use crate::common::{Part, Product};
 
 pub async fn get_products(
-    query: web::Query<Option<Part>>,
+    _query: web::Query<Option<Part>>,
 ) -> Result<HttpResponse, Error> {
     Ok(HttpResponse::Ok().finish())
 }
 
 pub async fn add_product(
-    new_product: web::Json<Product>,
+    _new_product: web::Json<Product>,
 ) -> Result<HttpResponse, Error> {
     Ok(HttpResponse::Ok().finish())
 }
 
-pub async fn get_product_detail(id: web::Path<String>) -> Result<HttpResponse, Error> {
+pub async fn get_product_detail(_id: web::Path<String>) -> Result<HttpResponse, Error> {
     Ok(HttpResponse::Ok().finish())
 }
 
-pub async fn remove_product(id: web::Path<String>) -> Result<HttpResponse, Error> {
+pub async fn remove_product(_id: web::Path<String>) -> Result<HttpResponse, Error> {
     Ok(HttpResponse::Ok().finish())
 }
 

async_pg/src/main.rs

@@ -98,8 +98,7 @@ mod handlers {
     ) -> Result<HttpResponse, Error> {
         let user_info: User = user.into_inner();
 
-        let client: Client =
+        let client: Client = db_pool.get().await.map_err(MyError::PoolError)?;
-            db_pool.get().await.map_err(|err| MyError::PoolError(err))?;
 
         let new_user = db::add_user(&client, user_info).await?;
 

awc_https/src/main.rs

@@ -1,15 +1,17 @@
-use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, client::{Client, Connector}};
+use actix_web::{
+    client::{Client, Connector},
+    web, App, HttpRequest, HttpResponse, HttpServer,
+};
 use openssl::ssl::{SslConnector, SslMethod};
 
-
+async fn index(_req: HttpRequest) -> HttpResponse {
-async fn index(req: HttpRequest) -> HttpResponse {
+    let builder = SslConnector::builder(SslMethod::tls()).unwrap();
-	let builder = SslConnector::builder(SslMethod::tls()).unwrap();
 
     let client = Client::build()
         .connector(Connector::new().ssl(builder.build()).finish())
         .finish();
 
-	let now = std::time::Instant::now();
+    let now = std::time::Instant::now();
     let payload =
         client
         .get("https://upload.wikimedia.org/wikipedia/commons/f/ff/Pizigani_1367_Chart_10MB.jpg")
@@ -21,22 +23,20 @@ async fn index(req: HttpRequest) -> HttpResponse {
         .await
         .unwrap();
 
-    println!("awc time elapsed while reading bytes into memory: {} ms", now.elapsed().as_millis());
+    println!(
+        "awc time elapsed while reading bytes into memory: {} ms",
+        now.elapsed().as_millis()
+    );
 
-	HttpResponse::Ok()
+    HttpResponse::Ok().content_type("image/jpeg").body(payload)
-        .content_type("image/jpeg")
-        .body(payload)
 }
 
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
     let port = 3000;
 
-    HttpServer::new(|| {
+    HttpServer::new(|| App::new().service(web::resource("/").to(index)))
-        App::new()
+        .bind(("0.0.0.0", port))?
-            .service(web::resource("/").to(index))
+        .run()
-    })
+        .await
-    .bind(("0.0.0.0", port))?
-    .run()
-    .await
 }

docker_sample/src/main.rs

@@ -1,7 +1,7 @@
 #[macro_use]
 extern crate actix_web;
 
-use actix_web::{web, App, HttpResponse, HttpServer, Responder};
+use actix_web::{App, HttpResponse, HttpServer, Responder};
 
 #[get("/")]
 async fn index() -> impl Responder {
@@ -19,12 +19,8 @@ async fn again() -> impl Responder {
 async fn main() -> std::io::Result<()> {
     println!("Starting actix-web server");
 
-    HttpServer::new(|| {
+    HttpServer::new(|| App::new().service(index).service(again))
-        App::new()
+        .bind("0.0.0.0:5000")?
-            .service(index)
+        .run()
-            .service(again)
+        .await
-    })
-    .bind("0.0.0.0:5000")?
-    .run()
-    .await
 }

graphql-demo/src/db.rs

@@ -1,4 +1,3 @@
-use r2d2;
 use r2d2_mysql::mysql::{Opts, OptsBuilder};
 use r2d2_mysql::MysqlConnectionManager;
 

graphql-demo/src/schemas/product.rs

@@ -1,4 +1,3 @@
-use juniper;
 use mysql::{from_row, params, Error as DBError, Row};
 
 use crate::schemas::root::Context;

graphql-demo/src/schemas/root.rs

@@ -1,4 +1,3 @@
-use juniper;
 use juniper::{FieldError, FieldResult, RootNode};
 use mysql::{from_row, params, Error as DBError, Row};
 
@@ -109,9 +108,9 @@ impl MutationRoot {
         let insert: Result<Option<Row>, DBError> = conn.first_exec(
             "INSERT INTO user(id, name, email) VALUES(:id, :name, :email)",
             params! {
-                "id" => &new_id.to_owned(),
+                "id" => &new_id,
-                "name" => &user.name.to_owned(),
+                "name" => &user.name,
-                "email" => &user.email.to_owned(),
+                "email" => &user.email,
             },
         );
 
@@ -141,9 +140,9 @@ impl MutationRoot {
         let insert: Result<Option<Row>, DBError> = conn.first_exec(
             "INSERT INTO product(id, user_id, name, price) VALUES(:id, :user_id, :name, :price)",
             params! {
-                "id" => &new_id.to_owned(),
+                "id" => &new_id,
-                "user_id" => &product.user_id.to_owned(),
+                "user_id" => &product.user_id,
-                "name" => &product.name.to_owned(),
+                "name" => &product.name,
                 "price" => &product.price.to_owned(),
             },
         );

graphql-demo/src/schemas/user.rs

@@ -1,4 +1,3 @@
-use juniper;
 use mysql::{from_row, params};
 
 use crate::schemas::product::Product;
@@ -33,28 +32,27 @@ impl User {
 
     fn products(&self, context: &Context) -> Vec<Product> {
         let mut conn = context.dbpool.get().unwrap();
-        let products = conn
+
-            .prep_exec(
+        conn.prep_exec(
-                "select * from product where user_id=:user_id",
+            "select * from product where user_id=:user_id",
-                params! {
+            params! {
-                    "user_id" => &self.id
+                "user_id" => &self.id
-                },
+            },
-            )
+        )
-            .map(|result| {
+        .map(|result| {
-                result
+            result
-                    .map(|x| x.unwrap())
+                .map(|x| x.unwrap())
-                    .map(|mut row| {
+                .map(|mut row| {
-                        let (id, user_id, name, price) = from_row(row);
+                    let (id, user_id, name, price) = from_row(row);
-                        Product {
+                    Product {
-                            id,
+                        id,
-                            user_id,
+                        user_id,
-                            name,
+                        name,
-                            price,
+                        price,
-                        }
+                    }
-                    })
+                })
-                    .collect()
+                .collect()
-            })
+        })
-            .unwrap();
+        .unwrap()
-        products
     }
 }

jsonrpc/src/main.rs

@@ -1,3 +1,6 @@
+// Allow this lint since it's fine to use type directly in the short example.
+#![allow(clippy::type_complexity)]
+
 use std::error;
 use std::pin::Pin;
 use std::sync::{Arc, RwLock};
@@ -7,7 +10,6 @@ use actix_rt::time::delay_for;
 use actix_web::{middleware, web, App, Error, HttpResponse, HttpServer};
 use bytes::Bytes;
 use futures::{Future, FutureExt};
-use serde_json;
 use serde_json::Value;
 
 #[allow(dead_code)]

middleware/src/main.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::type_complexity)]
+
 use actix_service::Service;
 use actix_web::{web, App, HttpServer};
 use futures::future::FutureExt;

r2d2/src/main.rs

@@ -4,7 +4,6 @@ use std::io;
 use actix_web::{middleware, web, App, Error, HttpResponse, HttpServer};
 use r2d2::Pool;
 use r2d2_sqlite::SqliteConnectionManager;
-use uuid;
 
 /// Async request handler. Ddb pool is stored in application state.
 async fn index(

server-sent-events/src/main.rs

@@ -5,7 +5,6 @@ use std::time::Duration;
 
 use actix_web::web::{Bytes, Data, Path};
 use actix_web::{web, App, Error, HttpResponse, HttpServer, Responder};
-use env_logger;
 use futures::{Stream, StreamExt};
 use tokio::sync::mpsc::{channel, Receiver, Sender};
 use tokio::time::{interval_at, Instant};

shutdown-server/src/main.rs

@@ -2,7 +2,6 @@ use actix_web::{get, middleware, post, web, App, HttpResponse, HttpServer};
 use futures::executor;
 use std::{sync::mpsc, thread};
 
-
 #[get("/hello")]
 async fn hello() -> &'static str {
     "Hello world!"
@@ -23,7 +22,7 @@ async fn main() -> std::io::Result<()> {
 
     // create a channel
     let (tx, rx) = mpsc::channel::<()>();
-    let stopper = tx.clone();
+    let _stopper = tx.clone();
 
     let bind = "127.0.0.1:8080";
 

state/src/main.rs

@@ -54,6 +54,7 @@ async fn main() -> io::Result<()> {
     env_logger::init();
 
     // Create some global state prior to building the server
+    #[allow(clippy::mutex_atomic)] // it's intentional.
     let counter1 = web::Data::new(Mutex::new(0usize));
     let counter3 = web::Data::new(AtomicUsize::new(0usize));
 

todo/src/api.rs

@@ -27,7 +27,7 @@ pub async fn index(
 
     let rendered = tmpl
         .render("index.html.tera", &context)
-        .map_err(|e| error::ErrorInternalServerError(e))?;
+        .map_err(error::ErrorInternalServerError)?;
 
     Ok(HttpResponse::Ok().body(rendered))
 }

todo/src/model.rs

@@ -1,4 +1,3 @@
-use diesel;
 use diesel::pg::PgConnection;
 use diesel::prelude::*;
 use serde::Serialize;