Rustfmt ALL the code!

src/configreader_yaml.rs

-use db_objects::{Contest, Taskgroup, Task};
+use db_objects::{Contest, Task, Taskgroup};
 
 use serde_yaml;
 
@@ -9,19 +9,22 @@ struct ContestYaml {
     participation_end: Option<String>,
     duration_minutes: Option<u32>,
     public_listing: Option<bool>,
-    
+
     tasks: Option<serde_yaml::Mapping>,
 }
 
-
-
-
 // The task path is stored relatively to the contest.yaml for easier identificationy
 // Concatenation happens in functions::show_task
 pub fn parse_yaml(content: &str, filename: &str, directory: &str) -> Option<Contest> {
     let config: ContestYaml = serde_yaml::from_str(&content).unwrap();
 
-    let mut contest = Contest::new(directory.to_string(), filename.to_string(), config.name?, config.duration_minutes?, config.public_listing.unwrap_or(false), None, None);
+    let mut contest = Contest::new(directory.to_string(),
+                                   filename.to_string(),
+                                   config.name?,
+                                   config.duration_minutes?,
+                                   config.public_listing.unwrap_or(false),
+                                   None,
+                                   None);
 
     for (name, info) in config.tasks? {
         if let serde_yaml::Value::String(name) = name {
@@ -30,46 +33,46 @@ pub fn parse_yaml(content: &str, filename: &str, directory: &str) -> Option<Cont
                 serde_yaml::Value::String(taskdir) => {
                     let mut task = Task::new(taskdir, 3);
                     taskgroup.tasks.push(task);
-                },
+                }
                 serde_yaml::Value::Sequence(taskdirs) => {
                     let mut stars = 2;
                     for taskdir in taskdirs {
                         if let serde_yaml::Value::String(taskdir) = taskdir {
                             let mut task = Task::new(taskdir, stars);
                             taskgroup.tasks.push(task);
-                        }
-                        else {
+                        } else {
                             panic!("Invalid contest YAML: {}{} (a)", directory, filename)
                         }
-                        
+
                         stars += 1;
                     }
                 }
                 serde_yaml::Value::Mapping(taskdirs) => {
                     let mut stars = 2;
                     for (taskdir, taskinfo) in taskdirs {
-                        if let (serde_yaml::Value::String(taskdir), serde_yaml::Value::Mapping(taskinfo)) = (taskdir, taskinfo) {
-                            if let Some(serde_yaml::Value::Number(cstars)) = taskinfo.get(&serde_yaml::Value::String("stars".to_string())) {
+                        if let (serde_yaml::Value::String(taskdir), serde_yaml::Value::Mapping(taskinfo)) =
+                            (taskdir, taskinfo)
+                        {
+                            if let Some(serde_yaml::Value::Number(cstars)) =
+                                taskinfo.get(&serde_yaml::Value::String("stars".to_string()))
+                            {
                                 stars = cstars.as_u64().unwrap() as u8;
                             }
                             let mut task = Task::new(taskdir, stars);
                             taskgroup.tasks.push(task);
                             stars += 1;
-                        }
-                        else {
+                        } else {
                             panic!("Invalid contest YAML: {}{} (b)", directory, filename)
                         }
                     }
                 }
-                _ => panic!("Invalid contest YAML: {}{} (c)", directory, filename)
+                _ => panic!("Invalid contest YAML: {}{} (c)", directory, filename),
             }
             contest.taskgroups.push(taskgroup);
-        }
-        else {
+        } else {
             panic!("Invalid contest YAML: {}{} (d)", directory, filename)
         }
     }
 
     Some(contest)
 }
-

src/db_apply_migrations.rs

@@ -3,22 +3,19 @@ use std::io::Read;
 
 use db_conn::MedalConnection;
 
-
 pub fn test<C: MedalConnection>(conn: &mut C) {
     let mut paths: Vec<_> =
-        fs::read_dir(format!("migrations/{}", conn.dbtype()))
-        .unwrap()
-        .map(|r| r.unwrap())
-        .filter(|r| r.path()
-                .display()
-                .to_string()
-                .ends_with(".sql"))
-        .collect();
+        fs::read_dir(format!("migrations/{}", conn.dbtype())).unwrap()
+                                                             .map(|r| r.unwrap())
+                                                             .filter(|r| {
+                                                                 r.path().display().to_string().ends_with(".sql")
+                                                             })
+                                                             .collect();
     paths.sort_by_key(|dir| dir.path());
 
-    for path in paths {        
+    for path in paths {
         let filename = path.file_name().into_string().unwrap();
-        if ! conn.migration_already_applied(&filename) {
+        if !conn.migration_already_applied(&filename) {
             let mut file = fs::File::open(path.path()).unwrap();
             let mut contents = String::new();
             file.read_to_string(&mut contents).unwrap();
@@ -28,8 +25,5 @@ pub fn test<C: MedalConnection>(conn: &mut C) {
         /*else { // TODO: Show in high debug level only
             println!("Found: {}. Already applied", path.path().display());
         }*/
-
-
-
     }
 }

src/db_conn.rs

 use db_objects::*;
-use ::functions;
-use std::path::{Path};
+use functions;
+use std::path::Path;
 
 pub trait MedalConnection {
     fn create(file: &Path) -> Self;
@@ -19,21 +19,24 @@ pub trait MedalConnection {
 
     //fn login(&self, session: &SessionUser, username: String, password: String) -> Result<String,()>;
 
-    fn login(&self, session: Option<&str>, username: &str, password: &str) -> Result<String,()>;
-    fn login_with_code(&self, session: Option<&str>, logincode: &str) -> Result<String,()>;
-    fn login_foreign(&self, session: Option<&str>, foreign_id: u32, foreign_type: functions::UserType, firstname: &str, lastname:&str) -> Result<String,()>;
-    fn create_user_with_groupcode(&self, session: Option<&str>, groupcode: &str) -> Result<String,()>;
+    fn login(&self, session: Option<&str>, username: &str, password: &str) -> Result<String, ()>;
+    fn login_with_code(&self, session: Option<&str>, logincode: &str) -> Result<String, ()>;
+    fn login_foreign(&self, session: Option<&str>, foreign_id: u32, foreign_type: functions::UserType,
+                     firstname: &str, lastname: &str)
+                     -> Result<String, ()>;
+    fn create_user_with_groupcode(&self, session: Option<&str>, groupcode: &str) -> Result<String, ()>;
     fn logout(&self, session: &str);
 
     fn load_submission(&self, session: &SessionUser, task: u32, subtask: Option<&str>) -> Option<Submission>;
     fn submit_submission(&self, submission: Submission);
     fn get_grade_by_submission(&self, submission_id: u32) -> Grade;
-    fn get_contest_groups_grades(&self, session_id: u32, contest_id: u32) -> (Vec<String>, Vec<(Group, Vec<(UserInfo, Vec<Grade>)>)>);
+    fn get_contest_groups_grades(&self, session_id: u32, contest_id: u32)
+                                 -> (Vec<String>, Vec<(Group, Vec<(UserInfo, Vec<Grade>)>)>);
     fn get_contest_user_grades(&self, session: String, contest_id: u32) -> Vec<Grade>;
 
     fn get_contest_list(&self) -> Vec<Contest>;
     fn get_contest_by_id(&self, contest_id: u32) -> Contest;
-    fn get_contest_by_id_complete(&self, contest_id :u32) -> Contest;
+    fn get_contest_by_id_complete(&self, contest_id: u32) -> Contest;
     fn get_participation(&self, session: &str, contest_id: u32) -> Option<Participation>;
     fn new_participation(&self, session: &str, contest_id: u32) -> Result<Participation, ()>;
     fn get_task_by_id(&self, task_id: u32) -> Task;
@@ -48,7 +51,6 @@ pub trait MedalConnection {
     fn get_group_complete(&self, group_id: u32) -> Option<Group>;
 }
 
-
 pub trait MedalObject<T: MedalConnection> {
     fn save(&mut self, conn: &T);
 }

src/db_objects.rs

-
 extern crate time;
 
-use self::time::{Timespec, Duration};
+use self::time::{Duration, Timespec};
 
 #[derive(Clone)]
 pub struct SessionUser {
@@ -11,7 +10,7 @@ pub struct SessionUser {
     pub last_login: Option<Timespec>,
     pub last_activity: Option<Timespec>,
     pub permanent_login: bool,
-    
+
     pub username: Option<String>,
     pub password: Option<String>,
     pub salt: Option<String>,
@@ -51,7 +50,7 @@ pub struct Group {
     pub groupcode: String,
     pub tag: String,
     pub admin: u32,
-    pub members: Vec<SessionUser>
+    pub members: Vec<SessionUser>,
 }
 
 pub struct Contest {
@@ -66,7 +65,6 @@ pub struct Contest {
     pub taskgroups: Vec<Taskgroup>,
 }
 
-
 pub struct Taskgroup {
     pub id: Option<u32>,
     pub contest: u32,
@@ -81,7 +79,6 @@ pub struct Task {
     pub stars: u8,
 }
 
-
 pub struct Submission {
     pub id: Option<u32>,
     pub session_user: u32,
@@ -109,63 +106,78 @@ pub struct Participation {
     pub start: Timespec,
 }
 
-pub trait HasId { fn get_id(&self) -> Option<u32>; fn set_id(&mut self, id: u32); }
-impl HasId for Submission { fn get_id(&self) -> Option<u32> { self.id } fn set_id(&mut self, id: u32) { self.id = Some(id);} }
-impl HasId for Task { fn get_id(&self) -> Option<u32> { self.id } fn set_id(&mut self, id: u32) { self.id = Some(id);} }
-impl HasId for Taskgroup { fn get_id(&self) -> Option<u32> { self.id } fn set_id(&mut self, id: u32) { self.id = Some(id);} }
-impl HasId for Contest { fn get_id(&self) -> Option<u32> { self.id } fn set_id(&mut self, id: u32) { self.id = Some(id);} }
-impl HasId for Group { fn get_id(&self) -> Option<u32> { self.id } fn set_id(&mut self, id: u32) { self.id = Some(id);} }
-
+pub trait HasId {
+    fn get_id(&self) -> Option<u32>;
+    fn set_id(&mut self, id: u32);
+}
+impl HasId for Submission {
+    fn get_id(&self) -> Option<u32> { self.id }
+    fn set_id(&mut self, id: u32) { self.id = Some(id); }
+}
+impl HasId for Task {
+    fn get_id(&self) -> Option<u32> { self.id }
+    fn set_id(&mut self, id: u32) { self.id = Some(id); }
+}
+impl HasId for Taskgroup {
+    fn get_id(&self) -> Option<u32> { self.id }
+    fn set_id(&mut self, id: u32) { self.id = Some(id); }
+}
+impl HasId for Contest {
+    fn get_id(&self) -> Option<u32> { self.id }
+    fn set_id(&mut self, id: u32) { self.id = Some(id); }
+}
+impl HasId for Group {
+    fn get_id(&self) -> Option<u32> { self.id }
+    fn set_id(&mut self, id: u32) { self.id = Some(id); }
+}
 
 impl Contest {
-    pub fn new(location: String, filename: String, name: String, duration: u32, public: bool, start: Option<Timespec>, end: Option<Timespec>) -> Self {
-        Contest {
-            id: None,
-            location: location,
-            filename: filename,
-            name: name,
-            duration: duration,
-            public: public,
-            start: start,
-            end: end,
-            taskgroups: Vec::new(),
-            
-        }
-    }    
+    pub fn new(location: String, filename: String, name: String, duration: u32, public: bool,
+               start: Option<Timespec>, end: Option<Timespec>)
+               -> Self
+    {
+        Contest { id: None,
+                  location: location,
+                  filename: filename,
+                  name: name,
+                  duration: duration,
+                  public: public,
+                  start: start,
+                  end: end,
+                  taskgroups: Vec::new() }
+    }
 }
 
 impl SessionUser {
     pub fn minimal(id: u32, session_token: String, csrf_token: String) -> Self {
-        SessionUser {
-            id: id,
-            session_token: Some(session_token),
-            csrf_token: csrf_token,
-            last_login: None,
-            last_activity: None, // now?
-            // müssen die überhaupt außerhalb der datenbankabstraktion sichtbar sein?
-            permanent_login: false,
-            
-            username: None,
-            password: None,
-            salt: None,
-            logincode: None,
-            email: None,
-            email_unconfirmed: None,
-            email_confirmationcode: None,
-            
-            firstname: None,
-            lastname: None,
-            street: None,
-            zip: None,
-            city: None,
-            nation: None,
-            grade: 0,
-            
-            is_teacher: false,
-            managed_by: None,
-            pms_id: None,
-            pms_school_id: None,
-        }
+        SessionUser { id: id,
+                      session_token: Some(session_token),
+                      csrf_token: csrf_token,
+                      last_login: None,
+                      last_activity: None, // now?
+                      // müssen die überhaupt außerhalb der datenbankabstraktion sichtbar sein?
+                      permanent_login: false,
+
+                      username: None,
+                      password: None,
+                      salt: None,
+                      logincode: None,
+                      email: None,
+                      email_unconfirmed: None,
+                      email_confirmationcode: None,
+
+                      firstname: None,
+                      lastname: None,
+                      street: None,
+                      zip: None,
+                      city: None,
+                      nation: None,
+                      grade: 0,
+
+                      is_teacher: false,
+                      managed_by: None,
+                      pms_id: None,
+                      pms_school_id: None }
     }
 
     pub fn ensure_alive(self) -> Option<Self> {
@@ -173,41 +185,26 @@ impl SessionUser {
         let now = time::get_time();
         if now - self.last_activity? < duration {
             Some(self)
-        }
-        else {
+        } else {
             None
-        }                                     
+        }
     }
 
     pub fn ensure_logged_in(self) -> Option<Self> {
         if self.password.is_some() || self.logincode.is_some() || self.pms_id.is_some() {
             self.ensure_alive()
-        }                                     
-        else {    
+        } else {
             None
         }
     }
 }
 
 impl Taskgroup {
-    pub fn new(name: String) -> Self {
-        Taskgroup {
-            id: None,
-            contest: 0,
-            name: name,
-            tasks: Vec::new(),
-        }
-    }    
+    pub fn new(name: String) -> Self { Taskgroup { id: None, contest: 0, name: name, tasks: Vec::new() } }
 }
 
 impl Task {
     pub fn new(location: String, stars: u8) -> Self {
-        Task {
-            id: None,
-            taskgroup: 0,
-            location: location,
-            stars: stars,
-        }
-    }    
+        Task { id: None, taskgroup: 0, location: location, stars: stars }
+    }
 }
-

src/main.rs

@@ -7,44 +7,44 @@ extern crate router;
 #[macro_use]
 extern crate serde_derive;
 
-extern crate structopt;
-extern crate rusqlite;
+extern crate handlebars_iron;
 extern crate iron_sessionstorage;
-extern crate urlencoded;
-extern crate time;
-extern crate persistent;
-extern crate rand;
 extern crate mount;
-extern crate staticfile;
-extern crate handlebars_iron;
-extern crate serde_json;
 extern crate params;
+extern crate persistent;
+extern crate rand;
 extern crate reqwest;
+extern crate rusqlite;
+extern crate serde_json;
 extern crate serde_yaml;
+extern crate staticfile;
+extern crate structopt;
+extern crate time;
+extern crate urlencoded;
 
 use rusqlite::Connection;
 
 mod db_apply_migrations;
-mod db_conn_sqlite;
 mod db_conn;
+mod db_conn_sqlite;
 mod db_objects;
 
-use functions::SetPassword; // TODO: Refactor, so we don't need to take this from there!
 use db_conn::{MedalConnection, MedalObject};
+use functions::SetPassword; // TODO: Refactor, so we don't need to take this from there!
 
 use db_objects::*;
 
-mod webfw_iron;
 mod configreader_yaml;
+mod webfw_iron;
 
 use webfw_iron::start_server;
 
 mod functions;
 
-use std::path;
 use std::fs;
+use std::path;
 
-use std::path::{Path,PathBuf};
+use std::path::{Path, PathBuf};
 use structopt::StructOpt;
 
 #[derive(Serialize, Deserialize, Clone, Default)]
@@ -65,7 +65,7 @@ fn read_config_from_file(file: &Path) -> Config {
 
     println!("Reading configuration file '{}'", file.to_str().unwrap_or("<Encoding error>"));
 
-    let mut config : Config = if let Ok(mut file) = fs::File::open(file) {
+    let mut config: Config = if let Ok(mut file) = fs::File::open(file) {
         let mut contents = String::new();
         file.read_to_string(&mut contents).unwrap();