git log

Author: AxosoftBrandon

gitrs_server/src/dispatch/git_command/bisect/mod.rs

@@ -49,7 +49,7 @@ pub fn dispatch(connection_state: state::Connection, bad: String, good: String)
                 .and_then(|result| -> DispatchFuture {
                     println!("{:?}", result);
                     Box::new(future::ok(connection_state))
-                })
+                }),
         ),
         None => Box::new(send_message(
             connection_state,

gitrs_server/src/dispatch/git_command/bisect/parse.rs

@@ -1,5 +1,5 @@
 use nom::digit1;
-use util::parse::{parse_u32, sha};
+use util::parse::{sha, parse_u32};
 
 #[derive(Debug, Serialize)]
 pub struct BisectStep {

gitrs_server/src/dispatch/git_command/log/mod.rs

@@ -0,0 +1,59 @@
+mod parse;
+
+use self::parse::{parse_log, LogEntry};
+use futures::{future, Future};
+use state;
+use std::str;
+use tokio_process::CommandExt;
+use types::DispatchFuture;
+use util::git;
+use util::transport::send_message;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "reason")]
+pub enum ErrorReason {
+    RepoPathNotSet,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+pub enum OutboundMessage {
+    Success { log: Vec<LogEntry> },
+    Error(ErrorReason),
+}
+
+pub fn dispatch(connection_state: state::Connection) -> DispatchFuture {
+    use self::ErrorReason::RepoPathNotSet;
+    use error::protocol::{Error, ProcessError::{Encoding, Failed, Parsing}};
+
+    match connection_state.repo_path.clone() {
+        Some(repo_path) => Box::new(
+            git::new_command_with_repo_path(&repo_path)
+                .arg("log")
+                .output_async()
+                .map_err(|_| Error::Process(Failed))
+                .and_then(|output| match str::from_utf8(&output.stdout) {
+                    Ok(output) => future::ok(String::from(output)),
+                    Err(_) => future::err(Error::Process(Encoding)),
+                })
+                .and_then(|result| -> DispatchFuture {
+                    if result.len() == 0 {
+                        // TODO: more semantic error
+                        return Box::new(future::err(Error::Process(Parsing)));
+                    }
+
+                    match parse_log(&format!("{}\n", result)) {
+                        Ok((_, log)) => Box::new(send_message(
+                            connection_state,
+                            OutboundMessage::Success { log },
+                        )),
+                        Err(_) => Box::new(future::err(Error::Process(Parsing))),
+                    }
+                }),
+        ),
+        None => Box::new(send_message(
+            connection_state,
+            OutboundMessage::Error(RepoPathNotSet),
+        )),
+    }
+}

gitrs_server/src/dispatch/git_command/log/parse.rs

@@ -0,0 +1,45 @@
+use nom;
+use util::parse::sha;
+
+#[derive(Debug, Serialize)]
+pub struct LogEntry {
+    commit_sha: String,
+    author: String,
+    date: String,
+    commit_message: String,
+}
+
+/*
+* Each indent starts with 4 spaces
+* seperator line with no spaces
+*/
+named!(pub parse_log_entry<&str, LogEntry>,
+    do_parse!(
+        tag!("commit ") >>
+        commit_sha: sha >>
+        char!('\n') >>
+        tag!("Author: ") >>
+        author: take_until!("\n") >>
+        char!('\n') >>
+        tag!("Date:   ") >>
+        date: take_until!("\n") >>
+        tag!("\n\n    ") >>
+        commit_message: take_until!("\n\n") >>
+        (LogEntry {
+            commit_sha: String::from(commit_sha),
+            author: String::from(author),
+            date: String::from(date),
+            commit_message: String::from(commit_message),
+        })
+    )
+);
+
+named!(pub parse_log<&str, Vec<LogEntry>>,
+    do_parse!(
+        entries: separated_list!(
+            tag!("\n\n"),
+            complete!(parse_log_entry)
+        ) >>
+        (entries)
+    )
+);

gitrs_server/src/dispatch/git_command/mod.rs

@@ -1,4 +1,5 @@
 mod bisect;
+mod log;
 mod open_repo;
 mod status;
 
@@ -14,6 +15,7 @@ pub fn dispatch(
 
     match message {
         Inbound::Bisect { bad, good } => bisect::dispatch(connection_state, bad, good),
+        Inbound::Log => log::dispatch(connection_state),
         Inbound::OpenRepo { path } => open_repo::dispatch(connection_state, path),
         Inbound::Status => status::dispatch(connection_state),
     }

gitrs_server/src/message/git_command.rs

@@ -2,6 +2,7 @@ pub mod protocol {
     #[derive(Debug, Deserialize)]
     pub enum Inbound {
         Bisect { bad: String, good: String },
+        Log,
         OpenRepo { path: String },
         Status,
     }