Merge pull request #16 from QuantGeekDev/feature/rustfmt

chore: format code with updated rustfmt config

rustfmt.toml

@@ -0,0 +1,2 @@
+use_small_heuristics = "Max"
+merge_derives = false

src/auth/mod.rs

@@ -1 +1 @@
-pub mod user;
+pub mod user;

src/catchers/mod.rs

@@ -11,24 +11,15 @@ pub struct ErrorResponse {
 
 #[catch(401)]
 pub fn unauthorized(req: &Request) -> Json<ErrorResponse> {
-    Json(ErrorResponse {
-        status: 401,
-        message: format!("Unauthorized access to {}", req.uri()),
-    })
+    Json(ErrorResponse { status: 401, message: format!("Unauthorized access to {}", req.uri()) })
 }
 
 #[catch(404)]
 pub fn not_found(_req: &Request) -> Json<ErrorResponse> {
-    Json(ErrorResponse {
-        status: 404,
-        message: "Page not found".to_string(),
-    })
+    Json(ErrorResponse { status: 404, message: "Page not found".to_string() })
 }
 
 #[catch(500)]
 pub fn internal_server_error(_req: &Request) -> Json<ErrorResponse> {
-    Json(ErrorResponse {
-        status: 500,
-        message: "Internal Server Error".to_string(),
-    })
+    Json(ErrorResponse { status: 500, message: "Internal Server Error".to_string() })
 }

src/db.rs

@@ -3,8 +3,7 @@ use diesel::prelude::*;
 use std::env;
 
 pub fn establish_connection() -> PgConnection {
-    let database_url = env::var("DATABASE_URL")
-        .expect("DATABASE_URL must be set");
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
     PgConnection::establish(&database_url)
         .unwrap_or_else(|_| panic!("Error connecting to {}", database_url))
 }

src/main.rs

@@ -1,15 +1,17 @@
 extern crate dotenv;
 #[macro_use]
 extern crate rocket;
-mod routes;
-mod models;
 mod auth;
 mod catchers;
 mod db;
+mod models;
+mod routes;
 mod schema;
 
 use crate::routes::auth::{login, register};
-use crate::routes::relationship::{invite_project_manager, list_developers, list_snacks, respond_to_invite};
+use crate::routes::relationship::{
+    invite_project_manager, list_developers, list_snacks, respond_to_invite,
+};
 use crate::routes::snack::{create_snack, delete_snack, update_snack};
 use dotenv::dotenv;
 use rocket::*;
@@ -25,12 +27,28 @@ fn index() -> &'static str {
     |___|    |_______||_______||______|        |__| |__|       |______| |_______|  |___|  "
 }
 
-
 #[launch]
 fn rocket() -> _ {
     dotenv().ok();
 
-    rocket::build().mount("/", routes![index, invite_project_manager,list_developers, respond_to_invite, create_snack, list_snacks, update_snack, delete_snack, register, login]).register("/", catchers![catchers::unauthorized, catchers::not_found,
-     catchers::internal_server_error])
+    rocket::build()
+        .mount(
+            "/",
+            routes![
+                index,
+                invite_project_manager,
+                list_developers,
+                respond_to_invite,
+                create_snack,
+                list_snacks,
+                update_snack,
+                delete_snack,
+                register,
+                login
+            ],
+        )
+        .register(
+            "/",
+            catchers![catchers::unauthorized, catchers::not_found, catchers::internal_server_error],
+        )
 }
-

src/models/mod.rs

@@ -1,3 +1,3 @@
+pub(crate) mod relationship;
 pub mod snack;
 pub(crate) mod user;
-pub(crate) mod relationship;

src/models/relationship.rs

@@ -1,11 +1,9 @@
-// src/models/relationship.rs
 use crate::models::user::User;
+use crate::schema::dev_pm_relationships;
 use chrono::NaiveDateTime;
+use diesel::pg::Pg;
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
-use diesel::pg::Pg;
-use crate::schema::dev_pm_relationships;
-use crate::schema::dev_pm_relationships::dsl;
 
 #[derive(Queryable, Selectable, Serialize, Identifiable, Associations, Debug)]
 #[diesel(belongs_to(User, foreign_key = developer_id))]
@@ -37,37 +35,28 @@ pub struct RespondToInviteRequest {
     pub status: String,
 }
 
-// Query builders helper methods
 impl DevPmRelationship {
     pub fn for_developer(user_id: i32) -> dev_pm_relationships::BoxedQuery<'static, Pg> {
         use crate::schema::dev_pm_relationships::dsl::*;
 
-        dev_pm_relationships
-            .filter(developer_id.eq(user_id))
-            .into_boxed()
+        dev_pm_relationships.filter(developer_id.eq(user_id)).into_boxed()
     }
 
     pub fn for_project_manager(user_id: i32) -> dev_pm_relationships::BoxedQuery<'static, Pg> {
         use crate::schema::dev_pm_relationships::dsl::*;
 
-        dev_pm_relationships
-            .filter(project_manager_id.eq(user_id))
-            .into_boxed()
+        dev_pm_relationships.filter(project_manager_id.eq(user_id)).into_boxed()
     }
 
     pub fn pending() -> dev_pm_relationships::BoxedQuery<'static, Pg> {
         use crate::schema::dev_pm_relationships::dsl::*;
 
-        dev_pm_relationships
-            .filter(status.eq("pending"))
-            .into_boxed()
+        dev_pm_relationships.filter(status.eq("pending")).into_boxed()
     }
 
     pub fn accepted() -> dev_pm_relationships::BoxedQuery<'static, Pg> {
         use crate::schema::dev_pm_relationships::dsl::*;
 
-        dev_pm_relationships
-            .filter(status.eq("accepted"))
-            .into_boxed()
+        dev_pm_relationships.filter(status.eq("accepted")).into_boxed()
     }
-}
+}

src/models/snack.rs

@@ -49,4 +49,4 @@ impl CreateSnackRequest {
             user_id,
         }
     }
-}
+}

src/models/user.rs

@@ -18,4 +18,4 @@ pub struct NewUser {
     pub username: String,
     pub password_hash: String,
     pub role: String,
-}
+}

src/routes/auth.rs

@@ -30,14 +30,15 @@ pub struct TokenResponse {
 #[post("/register", data = "<info>")]
 pub fn register(info: Json<RegisterInfo>) -> Result<Json<User>, Status> {
     let conn = &mut db::establish_connection();
-    let hashed_password = hash(&info.password, DEFAULT_COST)
-        .map_err(|_| Status::InternalServerError)?;
+    let hashed_password =
+        hash(&info.password, DEFAULT_COST).map_err(|_| Status::InternalServerError)?;
 
     let user_role = match info.role.as_deref() {
         Some("developer") => "developer",
         Some("project_manager") => "project_manager",
-        _ => "developer"
-    }.to_string();
+        _ => "developer",
+    }
+    .to_string();
 
     let new_user = NewUser {
         username: info.username.clone(),
@@ -60,19 +61,12 @@ pub fn login(info: Json<LoginInfo>) -> Result<Json<TokenResponse>, Status> {
         .first::<User>(conn)
         .map_err(|_| Status::Unauthorized)?;
     if verify(&info.password, &user.password_hash).map_err(|_| Status::InternalServerError)? {
-        let claims = Claims {
-            sub: user.id,
-            role: user.role.clone(),
-            exp: 10000000000,
-        };
-        let token = encode(
-            &Header::default(),
-            &claims,
-            &EncodingKey::from_secret("SECRET".as_ref()),
-        )
-            .map_err(|_| Status::InternalServerError)?;
+        let claims = Claims { sub: user.id, role: user.role.clone(), exp: 10000000000 };
+        let token =
+            encode(&Header::default(), &claims, &EncodingKey::from_secret("SECRET".as_ref()))
+                .map_err(|_| Status::InternalServerError)?;
         Ok(Json(TokenResponse { token }))
     } else {
         Err(Status::Unauthorized)
     }
-}
+}

src/routes/mod.rs

@@ -1,3 +1,3 @@
-pub mod snack;
 pub mod auth;
-pub mod relationship;
+pub mod relationship;
+pub mod snack;

src/routes/relationship.rs

@@ -1,6 +1,8 @@
 use crate::auth::user::AuthenticatedUser;
 use crate::db;
-use crate::models::relationship::{DevPmRelationship, InvitePmRequest, NewDevPmRelationship, RespondToInviteRequest};
+use crate::models::relationship::{
+    DevPmRelationship, InvitePmRequest, NewDevPmRelationship, RespondToInviteRequest,
+};
 use crate::models::snack::Snack;
 use crate::models::user::User;
 use crate::schema::dev_pm_relationships::{self, developer_id, project_manager_id, status};
@@ -62,10 +64,10 @@ pub fn list_developers(user: AuthenticatedUser) -> Result<Json<Vec<User>>, Statu
 
     users::table
         .inner_join(
-            dev_pm_relationships::table
-                .on(developer_id.eq(users::id)
-                    .and(project_manager_id.eq(user.0.id))
-                    .and(status.eq("accepted")))
+            dev_pm_relationships::table.on(developer_id
+                .eq(users::id)
+                .and(project_manager_id.eq(user.0.id))
+                .and(status.eq("accepted"))),
         )
         .select(users::all_columns)
         .load::<User>(&mut conn)
@@ -78,38 +80,29 @@ pub fn list_snacks(user: AuthenticatedUser) -> Result<Json<Vec<Snack>>, Status>
     let mut conn = db::establish_connection();
 
     match user.0.role.as_str() {
-        "admin" => {
-            snacks::table
-                .limit(100)
-                .select(Snack::as_select())
-                .load(&mut conn)
-        }
-        "project_manager" => {
-            snacks::table
-                .inner_join(
-                    dev_pm_relationships::table
-                        .on(user_id.eq(developer_id)
-                            .and(project_manager_id.eq(user.0.id))
-                            .and(status.eq("accepted")))
-                )
-                .select(Snack::as_select())
-                .distinct()
-                .limit(100)
-                .load(&mut conn)
-        }
-        _ => {
-            snacks::table
-                .filter(user_id.eq(user.0.id))
-                .limit(100)
-                .select(Snack::as_select())
-                .load(&mut conn)
-        }
+        "admin" => snacks::table.limit(100).select(Snack::as_select()).load(&mut conn),
+        "project_manager" => snacks::table
+            .inner_join(
+                dev_pm_relationships::table.on(user_id
+                    .eq(developer_id)
+                    .and(project_manager_id.eq(user.0.id))
+                    .and(status.eq("accepted"))),
+            )
+            .select(Snack::as_select())
+            .distinct()
+            .limit(100)
+            .load(&mut conn),
+        _ => snacks::table
+            .filter(user_id.eq(user.0.id))
+            .limit(100)
+            .select(Snack::as_select())
+            .load(&mut conn),
     }
-        .map(Json)
-        .map_err(|err| {
-            println!("Database error: {:?}", err);
-            Status::InternalServerError
-        })
+    .map(Json)
+    .map_err(|err| {
+        println!("Database error: {:?}", err);
+        Status::InternalServerError
+    })
 }
 
 #[patch("/respond-to-invite/<relationship_id>", data = "<response_data>")]
@@ -138,4 +131,4 @@ pub fn respond_to_invite(
         .get_result(&mut conn)
         .map(Json)
         .map_err(|_| Status::InternalServerError)
-}
+}