commit details in log (#107)

Author: Stephan Dilly

.github/workflows/cd.yml

@@ -10,20 +10,28 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        rust: [stable]
+  
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2
     - name: Get version
       id: get_version
       run: echo ::set-output name=version::${GITHUB_REF/refs\/tags\//}
+
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        profile: minimal
+        components: clippy
+
     - name: Build
       run: cargo build
     - name: Run tests
       run: make test
     - name: Run clippy
       run: |
-        rustup component add clippy
+        cargo clean
         make clippy
 
     - name: Setup MUSL

.github/workflows/ci.yml

@@ -13,19 +13,29 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        rust: [stable]
 
     runs-on: ${{ matrix.os }}
 
     steps:
     - uses: actions/checkout@v2
+
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        profile: minimal
+        components: clippy
+
     - name: Build Debug
-      run: cargo build
+      run: |
+        rustc --version
+        cargo build
+
     - name: Run tests
       run: make test
+
     - name: Run clippy
       run: |
-        rustup component add clippy
         cargo clean
         make clippy
     - name: Build Release
@@ -35,9 +45,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        profile: minimal
+        target: x86_64-unknown-linux-musl
+
     - name: Setup MUSL
       run: |
-        rustup target add x86_64-unknown-linux-musl
         sudo apt-get -qq install musl-tools
     - name: Build Debug
       run: cargo build --target=x86_64-unknown-linux-musl
@@ -51,7 +67,10 @@ jobs:
     steps:
     - uses: actions/checkout@master
     - name: Install Rust
-      run: rustup update stable && rustup default stable && rustup component add rustfmt
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        components: rustfmt
     - run: cargo fmt -- --check
 
   sec:

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - New `Stage all [a]`/`Unstage all [a]` in changes lists ([#82](https://github.com/extrawurst/gitui/issues/82))
 - add `-d`, `--directory` options to set working directory ([#73](https://github.com/extrawurst/gitui/issues/73))
+- commit detail view in revlog ([#80](https://github.com/extrawurst/gitui/issues/80))
 
 ### Fixed
 - app closes when staging invalid file/path ([#108](https://github.com/extrawurst/gitui/issues/108))

Makefile

@@ -29,6 +29,7 @@ fmt:
 	cargo fmt -- --check
 
 clippy:
+	touch src/main.rs
 	cargo clean -p gitui -p asyncgit -p scopetime
 	cargo clippy --all-features
 

README.md

@@ -45,7 +45,7 @@ presentation slides: https://github.com/extrawurst/gitui-presentation
 
 # known limitations
 
-* no support for [bare repositories](https://git-scm.com/book/en/v2/Git-on-the-Server-Getting-Git-on-a-Server)
+* no support for [bare repositories](https://git-scm.com/book/en/v2/Git-on-the-Server-Getting-Git-on-a-Server) (see [#100](https://github.com/extrawurst/gitui/issues/100))
 * [core.hooksPath](https://git-scm.com/docs/githooks) config not supported
 * revert/reset hunk in working dir (see [#11](https://github.com/extrawurst/gitui/issues/11))
 
@@ -89,9 +89,7 @@ see [releases](https://github.com/extrawurst/gitui/releases)
 
 ### requirements
 
-install `rust`/`cargo`: https://www.rust-lang.org/tools/install
-
-min rust version: `1.42`
+install **latest** `rust`/`cargo`: https://www.rust-lang.org/tools/install
 
 ### cargo install
 

asyncgit/src/commit_files.rs

@@ -0,0 +1,101 @@
+use crate::{
+    error::Result, sync, AsyncNotification, StatusItem, CWD,
+};
+use crossbeam_channel::Sender;
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc, Mutex,
+};
+use sync::CommitId;
+
+type ResultType = Vec<StatusItem>;
+struct Request<R, A>(R, A);
+
+///
+pub struct AsyncCommitFiles {
+    current: Arc<Mutex<Option<Request<CommitId, ResultType>>>>,
+    sender: Sender<AsyncNotification>,
+    pending: Arc<AtomicUsize>,
+}
+
+impl AsyncCommitFiles {
+    ///
+    pub fn new(sender: &Sender<AsyncNotification>) -> Self {
+        Self {
+            current: Arc::new(Mutex::new(None)),
+            sender: sender.clone(),
+            pending: Arc::new(AtomicUsize::new(0)),
+        }
+    }
+
+    ///
+    pub fn current(
+        &mut self,
+    ) -> Result<Option<(CommitId, ResultType)>> {
+        let c = self.current.lock()?;
+
+        if let Some(c) = c.as_ref() {
+            Ok(Some((c.0, c.1.clone())))
+        } else {
+            Ok(None)
+        }
+    }
+
+    ///
+    pub fn is_pending(&self) -> bool {
+        self.pending.load(Ordering::Relaxed) > 0
+    }
+
+    ///
+    pub fn fetch(&mut self, id: CommitId) -> Result<()> {
+        if self.is_pending() {
+            return Ok(());
+        }
+
+        log::trace!("request: {}", id.to_string());
+
+        {
+            let current = self.current.lock()?;
+            if let Some(ref c) = *current {
+                if c.0 == id {
+                    return Ok(());
+                }
+            }
+        }
+
+        let arc_current = Arc::clone(&self.current);
+        let sender = self.sender.clone();
+        let arc_pending = Arc::clone(&self.pending);
+
+        rayon_core::spawn(move || {
+            arc_pending.fetch_add(1, Ordering::Relaxed);
+
+            Self::fetch_helper(id, arc_current)
+                .expect("failed to fetch");
+
+            arc_pending.fetch_sub(1, Ordering::Relaxed);
+
+            sender
+                .send(AsyncNotification::CommitFiles)
+                .expect("error sending");
+        });
+
+        Ok(())
+    }
+
+    fn fetch_helper(
+        id: CommitId,
+        arc_current: Arc<
+            Mutex<Option<Request<CommitId, ResultType>>>,
+        >,
+    ) -> Result<()> {
+        let res = sync::get_commit_files(CWD, id)?;
+
+        {
+            let mut last = arc_current.lock()?;
+            *last = Some(Request(id, res));
+        }
+
+        Ok(())
+    }
+}

asyncgit/src/lib.rs

@@ -6,13 +6,15 @@
 #![deny(clippy::result_unwrap_used)]
 #![deny(clippy::panic)]
 
+mod commit_files;
 mod diff;
 mod error;
 mod revlog;
 mod status;
 pub mod sync;
 
 pub use crate::{
+    commit_files::AsyncCommitFiles,
     diff::{AsyncDiff, DiffParams},
     revlog::{AsyncLog, FetchStatus},
     status::{AsyncStatus, StatusParams},
@@ -27,14 +29,16 @@ use std::{
 };
 
 /// this type is used to communicate events back through the channel
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum AsyncNotification {
     ///
     Status,
     ///
     Diff,
     ///
     Log,
+    ///
+    CommitFiles,
 }
 
 /// current working director `./`

asyncgit/src/revlog.rs

@@ -41,10 +41,10 @@ static SLEEP_BACKGROUND: Duration = Duration::from_millis(1000);
 
 impl AsyncLog {
     ///
-    pub fn new(sender: Sender<AsyncNotification>) -> Self {
+    pub fn new(sender: &Sender<AsyncNotification>) -> Self {
         Self {
             current: Arc::new(Mutex::new(Vec::new())),
-            sender,
+            sender: sender.clone(),
             pending: Arc::new(AtomicBool::new(false)),
             background: Arc::new(AtomicBool::new(false)),
         }

asyncgit/src/sync/commit_details.rs

@@ -0,0 +1,99 @@
+use super::{utils::repo, CommitId};
+use crate::error::Result;
+use git2::Signature;
+use scopetime::scope_time;
+
+///
+#[derive(Debug, PartialEq)]
+pub struct CommitSignature {
+    ///
+    pub name: String,
+    ///
+    pub email: String,
+    /// time in secs since Unix epoch
+    pub time: i64,
+}
+
+impl CommitSignature {
+    /// convert from git2-rs `Signature`
+    pub fn from(s: Signature<'_>) -> Self {
+        Self {
+            name: s.name().unwrap_or("").to_string(),
+            email: s.email().unwrap_or("").to_string(),
+
+            time: s.when().seconds(),
+        }
+    }
+}
+
+///
+pub struct CommitMessage {
+    /// first line
+    pub subject: String,
+    /// remaining lines if more than one
+    pub body: Option<String>,
+}
+
+impl CommitMessage {
+    pub fn from(s: &str) -> Self {
+        if let Some(idx) = s.find('\n') {
+            let (first, rest) = s.split_at(idx);
+            Self {
+                subject: first.to_string(),
+                body: if rest.is_empty() {
+                    None
+                } else {
+                    Some(rest.to_string())
+                },
+            }
+        } else {
+            Self {
+                subject: s.to_string(),
+                body: None,
+            }
+        }
+    }
+}
+
+///
+pub struct CommitDetails {
+    ///
+    pub author: CommitSignature,
+    /// committer when differs to `author` otherwise None
+    pub committer: Option<CommitSignature>,
+    ///
+    pub message: Option<CommitMessage>,
+    ///
+    pub hash: String,
+}
+
+///
+pub fn get_commit_details(
+    repo_path: &str,
+    id: CommitId,
+) -> Result<CommitDetails> {
+    scope_time!("get_commit_details");
+
+    let repo = repo(repo_path)?;
+
+    let commit = repo.find_commit(id.into())?;
+
+    let author = CommitSignature::from(commit.author());
+    let committer = CommitSignature::from(commit.committer());
+    let committer = if author == committer {
+        None
+    } else {
+        Some(committer)
+    };
+
+    let message = commit.message().map(|m| CommitMessage::from(m));
+
+    let details = CommitDetails {
+        author,
+        committer,
+        message,
+        hash: id.to_string(),
+    };
+
+    Ok(details)
+}