formatted backend with nightly rustfmt

Author: hgzimmerman

backend/auth/src/banned_set.rs

@@ -1,6 +1,6 @@
 use std::{
  collections::HashSet,
- sync::RwLock
+ sync::RwLock,
 };
 
 use identifiers::user::UserUuid;
@@ -22,21 +22,15 @@ impl BannedSet {
  }
 
  pub fn ban_user(&self, user_uuid: UserUuid) {
- self.0.write().unwrap().insert(
- user_uuid,
- );
+ self.0.write().unwrap().insert(user_uuid);
  }
  /// True indicates that the user was unbanned.
  /// False indicates that the user was not in the banned set to begin with.
  pub fn unban_user(&self, user_uuid: &UserUuid) -> bool {
- self.0.write().unwrap().remove(
- user_uuid,
- )
+ self.0.write().unwrap().remove(user_uuid)
  }
 
  pub fn is_user_banned(&self, user_uuid: &UserUuid) -> bool {
- self.0.read().unwrap().contains(
- user_uuid,
- )
+ self.0.read().unwrap().contains(user_uuid)
  }
 }

backend/auth/src/jwt.rs

@@ -1,12 +1,12 @@
+use error::JwtError;
 use frank_jwt::{
- Algorithm,
+ decode,
  encode,
- decode
+ Algorithm,
 };
 use serde_json;
-use Secret;
-use error::JwtError;
 use wire::user::Jwt;
+use Secret;
 
 #[cfg(feature = "rocket_support")]
 pub use self::rocket_support::user_authorization;
@@ -49,18 +49,26 @@ impl ServerJwt {
  }
 }
 
-
 #[cfg(feature = "rocket_support")]
 pub mod rocket_support {
  use super::*;
- use rocket::State;
- use rocket::http::Status;
- use rocket::request::{self, Request, FromRequest};
- use rocket::Outcome;
+ use rocket::{
+ http::Status,
+ request::{
+ self,
+ FromRequest,
+ Request,
+ },
+ Outcome,
+ State,
+ };
 
- use identifiers::user::UserUuid;
- use wire::user::{UserRole, BEARER};
  use error::Error;
+ use identifiers::user::UserUuid;
+ use wire::user::{
+ UserRole,
+ BEARER,
+ };
 
  use chrono::Utc;
 
@@ -79,13 +87,9 @@ pub mod rocket_support {
  }
  }
 
-
  /// Given a request, extract the JWT struct from the headers in the request.
  fn extract_jwt_from_request(request: &Request) -> request::Outcome<ServerJwt, Error> {
- let keys: Vec<_> = request
- .headers()
- .get("Authorization")
- .collect();
+ let keys: Vec<_> = request.headers().get("Authorization").collect();
  if keys.len() != 1 {
  return Outcome::Failure((Status::Unauthorized, Error::MissingToken));
  };
@@ -101,10 +105,7 @@ pub mod rocket_support {
  }
  };
 
- let authorization_words: Vec<String> = key.to_string()
- .split_whitespace()
- .map(String::from)
- .collect();
+ let authorization_words: Vec<String> = key.to_string().split_whitespace().map(String::from).collect();
 
  if authorization_words.len() != 2 {
  return Outcome::Failure((Status::Unauthorized, Error::MalformedToken));
@@ -132,15 +133,13 @@ pub mod rocket_support {
  Outcome::Success(jwt)
  }
 
-
-
  pub mod user_authorization {
  use super::*;
 
  trait FromJwt {
  fn from_jwt(jwt: &Jwt) -> Result<Self, RoleError>
-  where
-  Self: Sized;
+ where
+ Self: Sized;
  fn get_uuid(&self) -> UserUuid;
  }
 
@@ -154,12 +153,9 @@ pub mod rocket_support {
 
  impl FromJwt for NormalUser {
  fn from_jwt(jwt: &Jwt) -> Result<NormalUser, RoleError> {
- if jwt.user_roles.contains(
- &UserRole::Unprivileged,
- )
- {
- Ok(NormalUser { user_uuid: jwt.sub })
- } else {
+ if jwt.user_roles.contains(&UserRole::Unprivileged) {
+ Ok(NormalUser { user_uuid: jwt.sub })
+ } else {
  Err(RoleError::InsufficientRights)
  }
  }
@@ -182,12 +178,9 @@ pub mod rocket_support {
 
  impl FromJwt for AdminUser {
  fn from_jwt(jwt: &Jwt) -> Result<AdminUser, RoleError> {
- if jwt.user_roles.contains(
- &UserRole::Admin,
- )
- {
- Ok(AdminUser { user_uuid: jwt.sub })
- } else {
+ if jwt.user_roles.contains(&UserRole::Admin) {
+ Ok(AdminUser { user_uuid: jwt.sub })
+ } else {
  Err(RoleError::InsufficientRights)
  }
  }
@@ -210,12 +203,9 @@ pub mod rocket_support {
 
  impl FromJwt for ModeratorUser {
  fn from_jwt(jwt: &Jwt) -> Result<ModeratorUser, RoleError> {
- if jwt.user_roles.contains(
- &UserRole::Moderator,
- )
- {
- Ok(ModeratorUser { user_uuid: jwt.sub })
- } else {
+ if jwt.user_roles.contains(&UserRole::Moderator) {
+ Ok(ModeratorUser { user_uuid: jwt.sub })
+ } else {
  Err(RoleError::InsufficientRights)
  }
  }
@@ -225,7 +215,6 @@ pub mod rocket_support {
  }
  }
 
-
  impl<'a, 'r> FromRequest<'a, 'r> for ModeratorUser {
  type Error = Error;
 
@@ -234,10 +223,9 @@ pub mod rocket_support {
  }
  }
 
-
  fn extract_role_from_request<T>(request: &Request) -> request::Outcome<T, Error>
-  where
-  T: FromJwt,
+ where
+ T: FromJwt,
  {
  // Get the jwt from the request's header
  let jwt: ServerJwt = extract_jwt_from_request(request)?;
@@ -246,7 +234,14 @@ pub mod rocket_support {
 
  let user = match T::from_jwt(&jwt.0) {
  Ok(user) => user,
- Err(_) => return Outcome::Failure((Status::Forbidden, Error::NotAuthorized { reason: "User does not have that role." })),
+ Err(_) => {
+ return Outcome::Failure((
+ Status::Forbidden,
+ Error::NotAuthorized {
+ reason: "User does not have that role.",
+ },
+ ))
+ }
  };
 
  // Check for stateful banned status

backend/auth/src/lib.rs

@@ -7,43 +7,39 @@
 //! They will only succeed in creating themselves if the JWT contains the role the user type corresponds to.
 //! By specifying one of these user types on a routable method, rocket will not route the request to it unless it can resolve the role in the JWT in the request header.
 
-
-
 #[cfg(feature = "rocket_support")]
 extern crate rocket;
 #[cfg(feature = "rocket_support")]
 extern crate rocket_contrib;
 
-extern crate wire;
+extern crate chrono;
 extern crate crypto;
 extern crate frank_jwt;
-extern crate chrono;
+extern crate wire;
 #[macro_use]
 extern crate serde_json;
 #[macro_use]
 extern crate log;
-extern crate simplelog;
-extern crate identifiers;
 extern crate error;
+extern crate identifiers;
 extern crate rand;
+extern crate simplelog;
 
+mod banned_set;
 mod jwt;
 mod password;
-mod banned_set;
 mod secret;
 
-
+pub use banned_set::BannedSet;
 pub use jwt::{
  user_authorization,
- ServerJwt
+ ServerJwt,
 };
 pub use password::{
  hash_password,
- verify_hash
+ verify_hash,
 };
-pub use banned_set::BannedSet;
 pub use secret::Secret;
 
-
 #[cfg(test)]
 mod test;

backend/auth/src/password.rs

@@ -1,5 +1,5 @@
-use std::io;
 use crypto::scrypt;
+use std::io;
 
 /// Hashes the password to a String that should be stored in the database.
 pub fn hash_password(password: &str) -> io::Result<String> {

backend/auth/src/secret.rs

@@ -1,6 +1,6 @@
 use rand::{
  self,
- Rng
+ Rng,
 };
 
 /// The secret contains a random string that is generated at startup.
@@ -12,20 +12,19 @@ pub struct Secret(pub String);
 
 impl Secret {
  pub fn generate() -> Secret {
- let key = rand::thread_rng()
- .gen_ascii_chars()
- .take(256)
- .collect::<String>();
+ let key = rand::thread_rng().gen_ascii_chars().take(256).collect::<String>();
  Secret(key)
  }
 
  pub fn from_user_supplied_string(key: &str) -> Secret {
  if key.len() <= 128 {
  panic!("The secret key must be equal to or greater than 128 characters.")
  } else if key.len() < 256 {
- warn!("The secret key should be longer than 256 characters. It is {} characters long", key.len());
+ warn!(
+ "The secret key should be longer than 256 characters. It is {} characters long",
+ key.len()
+ );
  }
  Secret(key.to_string())
  }
 }
-

backend/auth/src/test.rs

@@ -1,16 +1,13 @@
 use super::*;
-use wire::{
- user::{
- UserRole,
- Jwt
- }
-};
 use chrono::Utc;
+use wire::user::{
+ Jwt,
+ UserRole,
+};
 
 //use log::{info, warn};
 use identifiers::user::UserUuid;
 
-
 #[test]
 fn password_hash_and_verify() {
  let plaintext: &str = "12345";
@@ -32,7 +29,8 @@ fn jwt() {
  let jwt = ServerJwt(jwt);
 
  let jwt_string: String = jwt.encode_jwt_string(&secret).unwrap();
- let decoded_jwt: ServerJwt = ServerJwt::decode_jwt_string(&jwt_string, &secret).expect("JWT should be decoded from the provided string");
+ let decoded_jwt: ServerJwt =
+ ServerJwt::decode_jwt_string(&jwt_string, &secret).expect("JWT should be decoded from the provided string");
  assert_eq!(jwt, decoded_jwt);
 }
 
@@ -53,9 +51,7 @@ fn jwt_tampering_detected() {
  // alter the username of a copy of the accepted jwt
  let mut altered_jwt: ServerJwt = jwt.clone();
  altered_jwt.0.user_roles = vec![UserRole::Admin];
- let altered_jwt_string = altered_jwt
- .encode_jwt_string(&secret)
- .unwrap();
+ let altered_jwt_string = altered_jwt.encode_jwt_string(&secret).unwrap();
  // split the JWTs
  let split_jwt: Vec<&str> = jwt_string.split(".").collect();
  let split_altered_jwt: Vec<&str> = altered_jwt_string.split(".").collect();
@@ -69,4 +65,3 @@ fn jwt_tampering_detected() {
  panic!("Should not be able to decode this modified jwt.");
  }
 }
-

backend/db/src/calls/answer.rs

@@ -1,15 +1,17 @@
 use crate::{
- schema::answers,
- user::User,
- question::Question,
  calls::prelude::*,
- schema
+ question::Question,
+ schema::{
+ self,
+ answers,
+ },
+ user::User,
 };
 //use error::JoeResult;
-use uuid::Uuid;
 use diesel::pg::PgConnection;
 use error::BackendResult;
 use identifiers::answer::AnswerUuid;
+use uuid::Uuid;
 
 #[derive(Debug, Clone, Identifiable, Queryable, Associations, TypeName)]
 #[primary_key(uuid)]
@@ -39,13 +41,13 @@ pub struct AnswerData {
 }
 
 impl Answer {
- pub fn get_answer(uuid: AnswerUuid,conn: &PgConnection) -> BackendResult<Answer> {
- get_row::<Answer,_>(schema::answers::table, uuid.0, conn)
+ pub fn get_answer(uuid: AnswerUuid, conn: &PgConnection) -> BackendResult<Answer> {
+ get_row::<Answer, _>(schema::answers::table, uuid.0, conn)
  }
  pub fn delete_answer(uuid: AnswerUuid, conn: &PgConnection) -> BackendResult<Answer> {
- delete_row::<Answer,_>(schema::answers::table, uuid.0, conn)
+ delete_row::<Answer, _>(schema::answers::table, uuid.0, conn)
  }
  pub fn create_answer(new: NewAnswer, conn: &PgConnection) -> BackendResult<Answer> {
- create_row::<Answer, NewAnswer,_>(schema::answers::table, new, conn)
+ create_row::<Answer, NewAnswer, _>(schema::answers::table, new, conn)
  }
 }