Work in progress #270

Author: oknozor

git-object/src/commit/ref_iter.rs

@@ -65,6 +65,17 @@ impl<'a> CommitRefIter<'a> {
                 _ => None,
             })
     }
+
+    /// TODO:
+    pub fn committer(&mut self) -> Option<git_actor::SignatureRef<'_>> {
+        self.filter_map(Result::ok)
+            .find(|t| matches!(t, Token::Committer { .. }))
+            .map(|t| match t {
+                Token::Committer { signature } => Some(signature),
+                _ => None,
+            })
+            .flatten()
+    }
 }
 
 impl<'a> CommitRefIter<'a> {

git-traverse/src/commit.rs

@@ -4,9 +4,11 @@ pub struct Ancestors<Find, Predicate, StateMut> {
     predicate: Predicate,
     state: StateMut,
     mode: Parents,
+    sorting: Sorting,
 }
 
 /// Specify how to handle commit parents during traversal.
+#[derive(Copy, Clone)]
 pub enum Parents {
     /// Traverse all parents, useful for traversing the entire ancestry.
     All,
@@ -20,6 +22,22 @@ impl Default for Parents {
     }
 }
 
+/// Specify how to sort commits during traversal.
+#[derive(Copy, Clone)]
+pub enum Sorting {
+    /// TODO: The default sorting mode
+    GraphOrder,
+    /// Order commit looking up the most recent parent, since only parents are looked up
+    /// this ordering is partial
+    ByCommitterDate,
+}
+
+impl Default for Sorting {
+    fn default() -> Self {
+        Sorting::GraphOrder
+    }
+}
+
 ///
 pub mod ancestors {
     use std::{
@@ -31,7 +49,7 @@ pub mod ancestors {
     use git_object::CommitRefIter;
     use quick_error::quick_error;
 
-    use crate::commit::{Ancestors, Parents};
+    use crate::commit::{Ancestors, Parents, Sorting};
 
     quick_error! {
         /// The error is part of the item returned by the [Ancestors] iterator.
@@ -71,6 +89,12 @@ pub mod ancestors {
             self.mode = mode;
             self
         }
+
+        /// Set the sorting method, either topological or by author date
+        pub fn sorting(mut self, sorting: Sorting) -> Self {
+            self.sorting = sorting;
+            self
+        }
     }
 
     impl<Find, StateMut> Ancestors<Find, fn(&oid) -> bool, StateMut>
@@ -138,6 +162,7 @@ pub mod ancestors {
                 predicate,
                 state,
                 mode: Default::default(),
+                sorting: Default::default(),
             }
         }
     }
@@ -151,6 +176,80 @@ pub mod ancestors {
         type Item = Result<ObjectId, Error>;
 
         fn next(&mut self) -> Option<Self::Item> {
+            match self.sorting {
+                Sorting::GraphOrder => self.graph_sort_next(),
+                Sorting::ByCommitterDate => self.next_by_commit_date(),
+            }
+        }
+    }
+
+    impl<Find, Predicate, StateMut> Ancestors<Find, Predicate, StateMut>
+    where
+        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<CommitRefIter<'a>>,
+        Predicate: FnMut(&oid) -> bool,
+        StateMut: BorrowMut<State>,
+    {
+        fn next_by_commit_date(&mut self) -> Option<Result<ObjectId, Error>> {
+            let state = self.state.borrow_mut();
+            let res = state.next.pop_front();
+            let mut parents_with_date = vec![];
+
+            if let Some(oid) = res {
+                match (self.find)(&oid, &mut state.buf) {
+                    Some(mut commit_iter) => {
+                        if let Some(Err(decode_tree_err)) = commit_iter.next() {
+                            return Some(Err(decode_tree_err.into()));
+                        }
+
+                        for token in commit_iter {
+                            match token {
+                                Ok(git_object::commit::ref_iter::Token::Parent { id }) => {
+                                    let mut vec = vec![];
+                                    let parent = (self.find)(id.as_ref(), &mut vec);
+
+                                    // Get the parent committer date
+                                    let parent_committer_date = parent
+                                        .map(|parent| parent.into_iter().committer().map(|committer| committer.time))
+                                        .flatten();
+
+                                    if let Some(parent_committer_date) = parent_committer_date {
+                                        parents_with_date.push((id, parent_committer_date.time));
+                                    }
+
+                                    if matches!(self.mode, Parents::First) {
+                                        break;
+                                    }
+                                }
+                                Ok(_unused_token) => break,
+                                Err(err) => return Some(Err(err.into())),
+                            }
+                        }
+                    }
+                    None => return Some(Err(Error::NotFound { oid })),
+                }
+            }
+
+            parents_with_date.sort_by(|(_, time), (_, other_time)| other_time.cmp(&time));
+            for parent in parents_with_date {
+                let id = parent.0;
+                let was_inserted = state.seen.insert(id);
+
+                if was_inserted && (self.predicate)(&id) {
+                    state.next.push_back(id);
+                }
+            }
+
+            res.map(Ok)
+        }
+    }
+
+    impl<Find, Predicate, StateMut> Ancestors<Find, Predicate, StateMut>
+    where
+        Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<CommitRefIter<'a>>,
+        Predicate: FnMut(&oid) -> bool,
+        StateMut: BorrowMut<State>,
+    {
+        fn graph_sort_next(&mut self) -> Option<Result<ObjectId, Error>> {
             let state = self.state.borrow_mut();
             let res = state.next.pop_front();
             if let Some(oid) = res {