cargo fmt

5 files changed, 98 insertions, 66 deletions

diff --git a/src/db.rs b/src/db.rs
index 7e271bc..e9f651e 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -137,16 +137,14 @@ pub fn get_strava_token(
     Ok(token)
 }
 
-pub fn update_strava_token(
-    conn: &PgConnection,
-    token: &models::StravaToken) -> Result<(), Error> {
+pub fn update_strava_token(conn: &PgConnection, token: &models::StravaToken) -> Result<(), Error> {
     use crate::schema::strava_tokens;
-    diesel::update(strava_tokens::table).set(token)
+    diesel::update(strava_tokens::table)
+        .set(token)
         .execute(conn)?;
     Ok(())
 }
 
-
 pub fn insert_task(conn: &PgConnection, task: &models::NewTask) -> Result<i64, Error> {
     use crate::schema::tasks;
     let id = diesel::insert_into(tasks::table)
@@ -202,19 +200,27 @@ pub fn take_task(
     })
 }
 
-pub fn find_missing_data(conn: &PgConnection, username: &str, data_type: models::DataType, ids: &[i64])
-  -> Result<Vec<i64>, Error> {
-    use diesel::pg::expression::dsl::any;
+pub fn find_missing_data(
+    conn: &PgConnection,
+    username: &str,
+    data_type: models::DataType,
+    ids: &[i64],
+) -> Result<Vec<i64>, Error> {
     use crate::schema::raw_data;
+    use diesel::pg::expression::dsl::any;
     use std::collections::HashSet;
 
     let present: HashSet<i64> = raw_data::table
         .select(raw_data::id)
-        .filter(raw_data::username.eq(username)
+        .filter(
+            raw_data::username
+                .eq(username)
                 .and(raw_data::data_type.eq(data_type))
-                .and(raw_data::id.eq(any(ids))))
+                .and(raw_data::id.eq(any(ids))),
+        )
         .get_results::<i64>(conn)?
-        .into_iter().collect();
+        .into_iter()
+        .collect();
 
     let ids: HashSet<i64> = ids.iter().map(|v| *v).collect();
     let missing = ids.difference(&present);
diff --git a/src/importer.rs b/src/importer.rs
index a32a0ee..f5a8bf4 100644
--- a/src/importer.rs
+++ b/src/importer.rs
@@ -5,6 +5,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use serde_json::to_value;
 use serde_json::Value;
+use std::collections::HashSet;
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::sync::RwLock;
@@ -12,7 +13,6 @@ use std::thread;
 use std::time::Duration;
 use std::time::Instant;
 use threadpool::ThreadPool;
-use std::collections::HashSet;
 
 use crate::db;
 use crate::diesel::Connection;
@@ -27,7 +27,7 @@ pub const EMPTY_PARAMS: &[(&str, &str)] = &[];
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Command {
     ImportStravaUser { username: String },
-    ImportStravaActivity { username: String, id: i64, },
+    ImportStravaActivity { username: String, id: i64 },
     ProcessAllRawData,
     ProcessRawData(models::RawDataKey),
 }
@@ -67,8 +67,12 @@ fn handle_one_task<S: strava::StravaApi>(
     let command = serde_json::from_value(task.payload.clone())?;
 
     match command {
-        Command::ImportStravaUser { username } => import_strava_user(shared, task, username.as_str())?,
-        Command::ImportStravaActivity { username, id } => import_strava_activity(shared, task, username.as_str(), id)?,
+        Command::ImportStravaUser { username } => {
+            import_strava_user(shared, task, username.as_str())?
+        }
+        Command::ImportStravaActivity { username, id } => {
+            import_strava_activity(shared, task, username.as_str(), id)?
+        }
         Command::ProcessAllRawData => process_all_raw_data(shared, task.clone())?,
         Command::ProcessRawData(ref d) => process_raw_data(shared, d, task.clone())?,
     }
@@ -174,7 +178,7 @@ fn process_strava_activity<S: strava::StravaApi>(
         task.state = models::TaskState::SUCCESSFUL;
         let conn = &shared.conn.lock().unwrap();
         db::update_task(conn, task)?;
-        return Ok(())
+        return Ok(());
     }
 
     let json_error = || Error::UnexpectedJson(data.payload.clone());
@@ -187,7 +191,7 @@ fn process_strava_activity<S: strava::StravaApi>(
             task.state = models::TaskState::SUCCESSFUL;
             let conn = &shared.conn.lock().unwrap();
             db::update_task(conn, task)?;
-            return Ok(())
+            return Ok(());
         }
     }?;
     let entry_type = entry_payload["type"]
@@ -271,8 +275,8 @@ fn import_strava_activity<S: strava::StravaApi>(
     shared: Arc<ImporterSharedData<S>>,
     mut task: models::Task,
     username: &str,
-    id: i64
-    ) -> Result<(), Error> {
+    id: i64,
+) -> Result<(), Error> {
     let strava = shared.strava.read().unwrap();
     let user = db::get_user(&shared.conn.lock().unwrap(), username)?;
 
@@ -295,20 +299,21 @@ fn import_strava_activity<S: strava::StravaApi>(
                 payload: activity,
                 entry_type: None,
                 entry_id: None,
-            })?;
+            },
+        )?;
         db::insert_task(
             conn,
             &models::NewTask {
                 start_at: now,
                 state: models::TaskState::NEW,
                 username: username,
-                payload: &to_value(
-                    Command::ProcessRawData(models::RawDataKey {
-                        data_type: models::DataType::StravaActivity,
-                        id: id,
-                        username: username.to_string(),
-                    }))?
-            })?;
+                payload: &to_value(Command::ProcessRawData(models::RawDataKey {
+                    data_type: models::DataType::StravaActivity,
+                    id: id,
+                    username: username.to_string(),
+                }))?,
+            },
+        )?;
         task.state = models::TaskState::SUCCESSFUL;
         db::update_task(conn, task)?;
         Ok(())
@@ -354,7 +359,8 @@ fn import_strava_user<S: strava::StravaApi>(
             &shared.conn.lock().unwrap(),
             username,
             models::DataType::StravaActivity,
-            &activity_ids)?;
+            &activity_ids,
+        )?;
         missing_ids.extend(missing_on_page.iter());
 
         if missing_on_page.len() < per_page / 3 {
@@ -377,12 +383,12 @@ fn import_strava_user<S: strava::StravaApi>(
                     start_at: now + chrono::Duration::seconds(i as i64 * 10),
                     state: models::TaskState::NEW,
                     username: username,
-                    payload: &to_value(
-                        Command::ImportStravaActivity {
-                            username: username.to_string(),
-                            id: missing_id,
-                        })?,
-                })?;
+                    payload: &to_value(Command::ImportStravaActivity {
+                        username: username.to_string(),
+                        id: missing_id,
+                    })?,
+                },
+            )?;
         }
         task.state = models::TaskState::SUCCESSFUL;
         db::update_task(conn, task)?;
diff --git a/src/main.rs b/src/main.rs
index e21873a..ec292ea 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,13 +6,13 @@ extern crate log;
 extern crate diesel_migrations;
 
 use chrono::Utc;
-use structopt::StructOpt;
 use diesel::connection::Connection;
 use diesel::pg::PgConnection;
 use pjournal::db;
 use pjournal::importer;
 use pjournal::models;
 use serde_json::to_value;
+use structopt::StructOpt;
 
 embed_migrations!();
 
@@ -60,10 +60,7 @@ enum Command {
         strava_client_id: String,
     },
     /// Add a user account
-    AddUser {
-        username: String,
-        password: String,
-    },
+    AddUser { username: String, password: String },
     /// Create a ProcessAllRawData task
     ProcessAllData,
 }
@@ -128,7 +125,11 @@ fn main() {
     embedded_migrations::run(&conn).unwrap();
 
     match opt.cmd {
-        Some(Command::Init { rocket_secret_key, strava_client_secret, strava_client_id }) => {
+        Some(Command::Init {
+            rocket_secret_key,
+            strava_client_secret,
+            strava_client_id,
+        }) => {
             let config = models::Config {
                 strava_client_id,
                 strava_client_secret,
@@ -138,11 +139,11 @@ fn main() {
 
             db::create_config(&conn, &config).unwrap();
             info!("config created");
-        },
+        }
         Some(Command::AddUser { username, password }) => {
             db::adduser(&conn, &username, &password).unwrap();
             info!("added user {}", username);
-        },
+        }
         Some(Command::ProcessAllData) => {
             let command = importer::Command::ProcessAllRawData;
             db::insert_task(
@@ -154,17 +155,19 @@ fn main() {
                     payload: &to_value(command).unwrap(),
                 },
             )
-                .expect("insert");
+            .expect("insert");
             info!("ProcessAllRawData: task inserted");
-        },
+        }
         None => {
             info!("starting server with options {:?}", opt);
-            pjournal::server::start(conn,
-                                    &opt.database_url,
-                                    &opt.base_url,
-                                    &opt.static_path,
-                                    opt.port,
-                                    &opt.template_path);
+            pjournal::server::start(
+                conn,
+                &opt.database_url,
+                &opt.base_url,
+                &opt.static_path,
+                opt.port,
+                &opt.template_path,
+            );
         }
     }
 }
diff --git a/src/server.rs b/src/server.rs
index 8bed9db..4cf4135 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -92,8 +92,10 @@ fn index_logged_in(user: LoggedInUser) -> Redirect {
 #[get("/", rank = 2)]
 fn index() -> Result<Template, Error> {
     let mut context = default_context();
-    context.insert("message".to_string(),
-                   json!("Welcome to your practice journal"));
+    context.insert(
+        "message".to_string(),
+        json!("Welcome to your practice journal"),
+    );
     Ok(Template::render("index", context))
 }
 
@@ -188,7 +190,14 @@ fn link_strava(params: State<Params>) -> Redirect {
     ))
 }
 
-pub fn start(conn: diesel::PgConnection, db_url: &str, base_url: &str, static_path: &str, port: u16, template_path: &str) {
+pub fn start(
+    conn: diesel::PgConnection,
+    db_url: &str,
+    base_url: &str,
+    static_path: &str,
+    port: u16,
+    template_path: &str,
+) {
     let mut database_config = HashMap::new();
     let mut databases = HashMap::new();
     database_config.insert("url", Value::from(db_url));
diff --git a/src/template.rs b/src/template.rs
index 2f5da4e..1830584 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -1,10 +1,10 @@
 use crate::error::Error;
 use crate::models;
+use chrono::DateTime;
 use serde::Deserialize;
 use serde::Serialize;
 use serde_json::to_value;
 use serde_json::Value as Json;
-use chrono::DateTime;
 
 pub fn running_template() -> TemplateSpec {
     TemplateSpec::Table(vec![
@@ -140,11 +140,11 @@ mod function {
         let t = d.as_str();
         match t {
             None => Ok(json!(())),
-            Some(t) => {
-                format_timestamp(DateTime::parse_from_rfc3339(t)?.with_timezone(&chrono::Utc), opts)
-            }
+            Some(t) => format_timestamp(
+                DateTime::parse_from_rfc3339(t)?.with_timezone(&chrono::Utc),
+                opts,
+            ),
         }
-
     }
 
     fn display_unit(u: Unit, opts: &str, params: &Vec<FieldSpec>, d: &Json) -> Result<Json, Error> {
@@ -288,10 +288,13 @@ mod table {
                 index: 1,
                 columns: columns.iter().map(|c| json!(c.display_name)).collect(),
             },
-            rows: (2..).zip(rows.into_iter()).map(|(i, columns)| TableRow {
-                index: i,
-                columns: columns,
-            }).collect(),
+            rows: (2..)
+                .zip(rows.into_iter())
+                .map(|(i, columns)| TableRow {
+                    index: i,
+                    columns: columns,
+                })
+                .collect(),
         })
     }
 }
@@ -332,11 +335,16 @@ mod tests {
         ];
 
         let table = table::apply(&columns, &d).unwrap();
-        assert_eq!(table.headings.columns, vec!(json!("Name"), json!("Distance")));
-        assert_eq!(table.rows, vec!(
-            table::TableRow {
+        assert_eq!(
+            table.headings.columns,
+            vec!(json!("Name"), json!("Distance"))
+        );
+        assert_eq!(
+            table.rows,
+            vec!(table::TableRow {
                 index: 2,
                 columns: vec!(json!("Nick"), json!("2.0"))
-            }));
+            })
+        );
     }
 }