Skip to content

Commit 20f9b3f

Browse files
ByronByron
authoredSep 26, 2024··
Merge pull request #1610 from nrdxp/traverse/oldest-first
feat: add option to traverse commits from oldest to newest
·
v0.42.0gitoxide-core-v0.42.0
2 parents 7bf2f4f + 6862c27 commit 20f9b3f

File tree

10 files changed

+268
-105
lines changed

10 files changed

+268
-105
lines changed
 

‎examples/log.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ fn run(args: Args) -> anyhow::Result<()> {
7979
Sorting::BreadthFirst
8080
} else {
8181
// else if args.newest_first {
82-
Sorting::ByCommitTimeNewestFirst
82+
Sorting::ByCommitTime(Default::default())
8383
};
8484

8585
let mut min_parents = args.min_parents.unwrap_or(0);

‎gitoxide-core/src/repository/commitgraph/list.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ pub(crate) mod function {
3030
.context("Need committish as starting point")?
3131
.id()
3232
.ancestors()
33-
.sorting(Sorting::ByCommitTimeNewestFirst)
33+
.sorting(Sorting::ByCommitTime(Default::default()))
3434
.all()?;
3535
for commit in commits {
3636
let commit = commit?;

‎gitoxide-core/src/repository/revision/list.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ pub(crate) mod function {
5252
.context("Need committish as starting point")?
5353
.id()
5454
.ancestors()
55-
.sorting(Sorting::ByCommitTimeNewestFirst)
55+
.sorting(Sorting::ByCommitTime(Default::default()))
5656
.all()?;
5757

5858
let mut vg = match text {

‎gix-traverse/src/commit/simple.rs

+60-28
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,20 @@ use gix_date::SecondsSinceUnixEpoch;
22
use gix_hash::ObjectId;
33
use gix_hashtable::HashSet;
44
use smallvec::SmallVec;
5+
use std::cmp::Reverse;
56
use std::collections::VecDeque;
67

8+
#[derive(Default, Debug, Copy, Clone)]
9+
/// The order with which to prioritize the search.
10+
pub enum CommitTimeOrder {
11+
#[default]
12+
/// Sort commits by newest first.
13+
NewestFirst,
14+
/// Sort commits by oldest first.
15+
#[doc(alias = "Sort::REVERSE", alias = "git2")]
16+
OldestFirst,
17+
}
18+
719
/// Specify how to sort commits during a [simple](super::Simple) traversal.
820
///
921
/// ### Sample History
@@ -20,32 +32,35 @@ use std::collections::VecDeque;
2032
pub enum Sorting {
2133
/// Commits are sorted as they are mentioned in the commit graph.
2234
///
23-
/// In the *sample history* the order would be `8, 6, 7, 5, 4, 3, 2, 1`
35+
/// In the *sample history* the order would be `8, 6, 7, 5, 4, 3, 2, 1`.
2436
///
2537
/// ### Note
2638
///
2739
/// This is not to be confused with `git log/rev-list --topo-order`, which is notably different from
2840
/// as it avoids overlapping branches.
2941
#[default]
3042
BreadthFirst,
31-
/// Commits are sorted by their commit time in descending order, that is newest first.
43+
/// Commits are sorted by their commit time in the order specified, either newest or oldest first.
3244
///
3345
/// The sorting applies to all currently queued commit ids and thus is full.
3446
///
35-
/// In the *sample history* the order would be `8, 7, 6, 5, 4, 3, 2, 1`
47+
/// In the *sample history* the order would be `8, 7, 6, 5, 4, 3, 2, 1` for [`NewestFirst`](CommitTimeOrder::NewestFirst),
48+
/// or `1, 2, 3, 4, 5, 6, 7, 8` for [`OldestFirst`](CommitTimeOrder::OldestFirst).
3649
///
3750
/// # Performance
3851
///
3952
/// This mode benefits greatly from having an object_cache in `find()`
4053
/// to avoid having to lookup each commit twice.
41-
ByCommitTimeNewestFirst,
42-
/// This sorting is similar to `ByCommitTimeNewestFirst`, but adds a cutoff to not return commits older than
54+
ByCommitTime(CommitTimeOrder),
55+
/// This sorting is similar to [`ByCommitTime`](Sorting::ByCommitTime), but adds a cutoff to not return commits older than
4356
/// a given time, stopping the iteration once no younger commits is queued to be traversed.
4457
///
4558
/// As the query is usually repeated with different cutoff dates, this search mode benefits greatly from an object cache.
4659
///
47-
/// In the *sample history* and a cut-off date of 4, the returned list of commits would be `8, 7, 6, 4`
48-
ByCommitTimeNewestFirstCutoffOlderThan {
60+
/// In the *sample history* and a cut-off date of 4, the returned list of commits would be `8, 7, 6, 4`.
61+
ByCommitTimeCutoff {
62+
/// The order in which to prioritize lookups.
63+
order: CommitTimeOrder,
4964
/// The amount of seconds since unix epoch, the same value obtained by any `gix_date::Time` structure and the way git counts time.
5065
seconds: gix_date::SecondsSinceUnixEpoch,
5166
},
@@ -61,11 +76,14 @@ pub enum Error {
6176
ObjectDecode(#[from] gix_object::decode::Error),
6277
}
6378

79+
use Result as Either;
80+
type QueueKey<T> = Either<T, Reverse<T>>;
81+
6482
/// The state used and potentially shared by multiple graph traversals.
6583
#[derive(Clone)]
6684
pub(super) struct State {
6785
next: VecDeque<ObjectId>,
68-
queue: gix_revwalk::PriorityQueue<SecondsSinceUnixEpoch, ObjectId>,
86+
queue: gix_revwalk::PriorityQueue<QueueKey<SecondsSinceUnixEpoch>, ObjectId>,
6987
buf: Vec<u8>,
7088
seen: HashSet<ObjectId>,
7189
parents_buf: Vec<u8>,
@@ -77,10 +95,13 @@ mod init {
7795
use gix_date::SecondsSinceUnixEpoch;
7896
use gix_hash::{oid, ObjectId};
7997
use gix_object::{CommitRefIter, FindExt};
98+
use std::cmp::Reverse;
99+
use Err as Oldest;
100+
use Ok as Newest;
80101

81102
use super::{
82103
super::{simple::Sorting, Either, Info, ParentIds, Parents, Simple},
83-
collect_parents, Error, State,
104+
collect_parents, CommitTimeOrder, Error, State,
84105
};
85106

86107
impl Default for State {
@@ -105,6 +126,13 @@ mod init {
105126
}
106127
}
107128

129+
fn to_queue_key(i: i64, order: CommitTimeOrder) -> super::QueueKey<i64> {
130+
match order {
131+
CommitTimeOrder::NewestFirst => Newest(i),
132+
CommitTimeOrder::OldestFirst => Oldest(Reverse(i)),
133+
}
134+
}
135+
108136
/// Builder
109137
impl<Find, Predicate> Simple<Find, Predicate>
110138
where
@@ -117,19 +145,20 @@ mod init {
117145
Sorting::BreadthFirst => {
118146
self.queue_to_vecdeque();
119147
}
120-
Sorting::ByCommitTimeNewestFirst | Sorting::ByCommitTimeNewestFirstCutoffOlderThan { .. } => {
148+
Sorting::ByCommitTime(order) | Sorting::ByCommitTimeCutoff { order, .. } => {
121149
let cutoff_time = self.sorting.cutoff_time();
122150
let state = &mut self.state;
123151
for commit_id in state.next.drain(..) {
124152
let commit_iter = self.objects.find_commit_iter(&commit_id, &mut state.buf)?;
125153
let time = commit_iter.committer()?.time.seconds;
126-
match cutoff_time {
127-
Some(cutoff_time) if time >= cutoff_time => {
128-
state.queue.insert(time, commit_id);
154+
let key = to_queue_key(time, order);
155+
match (cutoff_time, order) {
156+
(Some(cutoff_time), _) if time >= cutoff_time => {
157+
state.queue.insert(key, commit_id);
129158
}
130-
Some(_) => {}
131-
None => {
132-
state.queue.insert(time, commit_id);
159+
(Some(_), _) => {}
160+
(None, _) => {
161+
state.queue.insert(key, commit_id);
133162
}
134163
}
135164
}
@@ -254,10 +283,8 @@ mod init {
254283
} else {
255284
match self.sorting {
256285
Sorting::BreadthFirst => self.next_by_topology(),
257-
Sorting::ByCommitTimeNewestFirst => self.next_by_commit_date(None),
258-
Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds } => {
259-
self.next_by_commit_date(seconds.into())
260-
}
286+
Sorting::ByCommitTime(order) => self.next_by_commit_date(order, None),
287+
Sorting::ByCommitTimeCutoff { seconds, order } => self.next_by_commit_date(order, seconds.into()),
261288
}
262289
}
263290
}
@@ -267,7 +294,7 @@ mod init {
267294
/// If not topo sort, provide the cutoff date if present.
268295
fn cutoff_time(&self) -> Option<SecondsSinceUnixEpoch> {
269296
match self {
270-
Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds } => Some(*seconds),
297+
Sorting::ByCommitTimeCutoff { seconds, .. } => Some(*seconds),
271298
_ => None,
272299
}
273300
}
@@ -281,18 +308,21 @@ mod init {
281308
{
282309
fn next_by_commit_date(
283310
&mut self,
284-
cutoff_older_than: Option<SecondsSinceUnixEpoch>,
311+
order: CommitTimeOrder,
312+
cutoff: Option<SecondsSinceUnixEpoch>,
285313
) -> Option<Result<Info, Error>> {
286314
let state = &mut self.state;
287315

288-
let (commit_time, oid) = state.queue.pop()?;
316+
let (commit_time, oid) = match state.queue.pop()? {
317+
(Newest(t) | Oldest(Reverse(t)), o) => (t, o),
318+
};
289319
let mut parents: ParentIds = Default::default();
290320
match super::super::find(self.cache.as_ref(), &self.objects, &oid, &mut state.buf) {
291321
Ok(Either::CachedCommit(commit)) => {
292322
if !collect_parents(&mut state.parent_ids, self.cache.as_ref(), commit.iter_parents()) {
293323
// drop corrupt caches and try again with ODB
294324
self.cache = None;
295-
return self.next_by_commit_date(cutoff_older_than);
325+
return self.next_by_commit_date(order, cutoff);
296326
}
297327
for (id, parent_commit_time) in state.parent_ids.drain(..) {
298328
parents.push(id);
@@ -301,9 +331,10 @@ mod init {
301331
continue;
302332
}
303333

304-
match cutoff_older_than {
334+
let key = to_queue_key(parent_commit_time, order);
335+
match cutoff {
305336
Some(cutoff_older_than) if parent_commit_time < cutoff_older_than => continue,
306-
Some(_) | None => state.queue.insert(parent_commit_time, id),
337+
Some(_) | None => state.queue.insert(key, id),
307338
}
308339
}
309340
}
@@ -323,9 +354,10 @@ mod init {
323354
.and_then(|parent| parent.committer().ok().map(|committer| committer.time.seconds))
324355
.unwrap_or_default();
325356

326-
match cutoff_older_than {
357+
let time = to_queue_key(parent_commit_time, order);
358+
match cutoff {
327359
Some(cutoff_older_than) if parent_commit_time < cutoff_older_than => continue,
328-
Some(_) | None => state.queue.insert(parent_commit_time, id),
360+
Some(_) | None => state.queue.insert(time, id),
329361
}
330362
}
331363
Ok(_unused_token) => break,

‎gix-traverse/tests/commit/simple.rs

+158-39
Original file line numberDiff line numberDiff line change
@@ -92,7 +92,7 @@ impl TraversalAssertion<'_> {
9292
}
9393

9494
mod different_date_intermixed {
95-
use gix_traverse::commit::simple::Sorting;
95+
use gix_traverse::commit::simple::{CommitTimeOrder, Sorting};
9696

9797
use crate::commit::simple::TraversalAssertion;
9898

@@ -114,6 +114,7 @@ mod different_date_intermixed {
114114
"65d6af66f60b8e39fd1ba6a1423178831e764ec5", /* c1 */
115115
],
116116
)
117+
.with_sorting(Sorting::BreadthFirst)
117118
.check()
118119
}
119120

@@ -134,13 +135,30 @@ mod different_date_intermixed {
134135
"65d6af66f60b8e39fd1ba6a1423178831e764ec5", /* c1 */
135136
],
136137
)
137-
.with_sorting(Sorting::ByCommitTimeNewestFirst)
138+
.with_sorting(Sorting::ByCommitTime(CommitTimeOrder::NewestFirst))
139+
.check()?;
140+
141+
TraversalAssertion::new_at(
142+
"make_repos.sh",
143+
"intermixed",
144+
&["58912d92944087dcb09dca79cdd2a937cc158bed"], /* merge */
145+
&[
146+
"a9c28710e058af4e5163699960234adb9fb2abc7", /* b2c2 */
147+
"b648f955b930ca95352fae6f22cb593ee0244b27", /* b2c1 */
148+
"ad33ff2d0c4fc77d56b5fbff6f86f332fe792d83", /* c2 */
149+
"65d6af66f60b8e39fd1ba6a1423178831e764ec5", /* c1 */
150+
"0f6632a5a7d81417488b86692b729e49c1b73056", /* b1c2 */
151+
"77fd3c6832c0cd542f7a39f3af9250c3268db979", /* b1c1 */
152+
"2dce37be587e07caef8c4a5ab60b423b13a8536a", /* c3 */
153+
],
154+
)
155+
.with_sorting(Sorting::ByCommitTime(CommitTimeOrder::OldestFirst))
138156
.check()
139157
}
140158
}
141159

142160
mod different_date {
143-
use gix_traverse::commit::simple::Sorting;
161+
use gix_traverse::commit::simple::{CommitTimeOrder, Sorting};
144162

145163
use crate::commit::simple::TraversalAssertion;
146164

@@ -186,16 +204,34 @@ mod different_date {
186204
"65d6af66f60b8e39fd1ba6a1423178831e764ec5", /* c1 */
187205
],
188206
)
189-
.with_sorting(Sorting::ByCommitTimeNewestFirst)
207+
.with_sorting(Sorting::ByCommitTime(CommitTimeOrder::NewestFirst))
208+
.check()?;
209+
TraversalAssertion::new_at(
210+
"make_repos.sh",
211+
"simple",
212+
&["f49838d84281c3988eeadd988d97dd358c9f9dc4"], /* merge */
213+
&[
214+
"48e8dac19508f4238f06c8de2b10301ce64a641c", /* b2c2 */
215+
"cb6a6befc0a852ac74d74e0354e0f004af29cb79", /* b2c1 */
216+
"8cb5f13b66ce52a49399a2c49f537ee2b812369c", /* c4 */
217+
"33aa07785dd667c0196064e3be3c51dd9b4744ef", /* c3 */
218+
"ad33ff2d0c4fc77d56b5fbff6f86f332fe792d83", /* c2 */
219+
"65d6af66f60b8e39fd1ba6a1423178831e764ec5", /* c1 */
220+
"66a309480201c4157b0eae86da69f2d606aadbe7", /* b1c2 */
221+
"80947acb398362d8236fcb8bf0f8a9dac640583f", /* b1c1 */
222+
"0edb95c0c0d9933d88f532ec08fcd405d0eee882", /* c5 */
223+
],
224+
)
225+
.with_sorting(Sorting::ByCommitTime(CommitTimeOrder::OldestFirst))
190226
.check()
191227
}
192228
}
193229

194230
/// Same dates are somewhat special as they show how sorting-details on priority queues affects ordering
195231
mod same_date {
196-
use gix_traverse::commit::{simple::Sorting, Parents};
197-
198232
use crate::{commit::simple::TraversalAssertion, hex_to_id};
233+
use gix_traverse::commit::simple::CommitTimeOrder;
234+
use gix_traverse::commit::{simple::Sorting, Parents};
199235

200236
#[test]
201237
fn c4_breadth_first() -> crate::Result {
@@ -208,6 +244,7 @@ mod same_date {
208244
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
209245
],
210246
)
247+
.with_sorting(Sorting::BreadthFirst)
211248
.check()
212249
}
213250

@@ -229,6 +266,7 @@ mod same_date {
229266
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
230267
],
231268
)
269+
.with_sorting(Sorting::BreadthFirst)
232270
.check()
233271
}
234272

@@ -247,7 +285,23 @@ mod same_date {
247285
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
248286
],
249287
)
250-
.with_sorting(Sorting::ByCommitTimeNewestFirst)
288+
.with_sorting(Sorting::ByCommitTime(CommitTimeOrder::NewestFirst))
289+
.check()?;
290+
291+
TraversalAssertion::new(
292+
"make_traversal_repo_for_commits_same_date.sh",
293+
&["01ec18a3ebf2855708ad3c9d244306bc1fae3e9b"], /* m1b1 */
294+
&[
295+
"efd9a841189668f1bab5b8ebade9cd0a1b139a37", /* c5 */
296+
"ce2e8ffaa9608a26f7b21afc1db89cadb54fd353", /* b1c2 */
297+
"9556057aee5abb06912922e9f26c46386a816822", /* c4 */
298+
"9152eeee2328073cf23dcf8e90c949170b711659", /* b1c1 */
299+
"17d78c64cef6c33a10a604573fd2c429e477fd63", /* c3 */
300+
"9902e3c3e8f0c569b4ab295ddf473e6de763e1e7", /* c2 */
301+
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
302+
],
303+
)
304+
.with_sorting(Sorting::ByCommitTime(CommitTimeOrder::OldestFirst))
251305
.check()
252306
}
253307

@@ -265,6 +319,7 @@ mod same_date {
265319
],
266320
)
267321
.with_parents(Parents::First)
322+
.with_sorting(Sorting::BreadthFirst)
268323
.check()
269324
}
270325

@@ -285,6 +340,7 @@ mod same_date {
285340
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
286341
],
287342
)
343+
.with_sorting(Sorting::BreadthFirst)
288344
.check()
289345
}
290346

@@ -306,6 +362,7 @@ mod same_date {
306362
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
307363
],
308364
)
365+
.with_sorting(Sorting::BreadthFirst)
309366
.check_with_predicate(|id| id != hex_to_id("9152eeee2328073cf23dcf8e90c949170b711659"))
310367
}
311368

@@ -323,6 +380,7 @@ mod same_date {
323380
"9152eeee2328073cf23dcf8e90c949170b711659", /* b1c1 */
324381
],
325382
)
383+
.with_sorting(Sorting::BreadthFirst)
326384
.check_with_predicate(move |id| {
327385
if id == hex_to_id("9556057aee5abb06912922e9f26c46386a816822") {
328386
assert!(!seen);
@@ -337,9 +395,9 @@ mod same_date {
337395

338396
/// Some dates adjusted to be a year apart, but still 'c1' and 'c2' with the same date.
339397
mod adjusted_dates {
340-
use gix_traverse::commit::{simple::Sorting, Parents, Simple};
341-
342398
use crate::{commit::simple::TraversalAssertion, hex_to_id};
399+
use gix_traverse::commit::simple::CommitTimeOrder;
400+
use gix_traverse::commit::{simple::Sorting, Parents, Simple};
343401

344402
#[test]
345403
fn head_breadth_first() -> crate::Result {
@@ -354,6 +412,7 @@ mod adjusted_dates {
354412
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
355413
],
356414
)
415+
.with_sorting(Sorting::BreadthFirst)
357416
.check()
358417
}
359418

@@ -368,55 +427,115 @@ mod adjusted_dates {
368427
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
369428
],
370429
)
371-
.with_sorting(Sorting::ByCommitTimeNewestFirst)
372-
.check()
373-
}
374-
375-
#[test]
376-
fn head_date_order_with_cutoff() -> crate::Result {
430+
.with_sorting(Sorting::ByCommitTime(CommitTimeOrder::NewestFirst))
431+
.check()?;
377432
TraversalAssertion::new(
378433
"make_traversal_repo_for_commits_with_dates.sh",
379434
&["288e509293165cb5630d08f4185bdf2445bf6170"], /* m1b1 */
380-
&["bcb05040a6925f2ff5e10d3ae1f9264f2e8c43ac"], /* b1c1 */
435+
&[
436+
"9902e3c3e8f0c569b4ab295ddf473e6de763e1e7", /* c2 */
437+
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
438+
"bcb05040a6925f2ff5e10d3ae1f9264f2e8c43ac", /* b1c1 */
439+
],
381440
)
382-
.with_sorting(Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
383-
seconds: 978393600, // =2001-01-02 00:00:00 +0000
384-
})
441+
.with_sorting(Sorting::ByCommitTime(CommitTimeOrder::OldestFirst))
385442
.check()
386443
}
387444

388445
#[test]
389-
fn date_order_with_cutoff_is_applied_to_starting_position() -> crate::Result {
390-
let dir =
391-
gix_testtools::scripted_fixture_read_only_standalone("make_traversal_repo_for_commits_with_dates.sh")?;
392-
let store = gix_odb::at(dir.join(".git").join("objects"))?;
393-
let iter = Simple::new(
394-
Some(hex_to_id("9902e3c3e8f0c569b4ab295ddf473e6de763e1e7" /* c2 */)),
395-
&store,
396-
)
397-
.sorting(Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
398-
seconds: 978393600, // =2001-01-02 00:00:00 +0000
399-
})?;
400-
assert_eq!(
401-
iter.count(),
402-
0,
403-
"initial tips that don't pass cutoff value are not returned either"
404-
);
446+
fn head_date_order_with_cutoff() -> crate::Result {
447+
for order in all_commit_time_orderings() {
448+
TraversalAssertion::new(
449+
"make_traversal_repo_for_commits_with_dates.sh",
450+
&["288e509293165cb5630d08f4185bdf2445bf6170"], /* m1b1 */
451+
&["bcb05040a6925f2ff5e10d3ae1f9264f2e8c43ac"], /* b1c1 */
452+
)
453+
.with_sorting(Sorting::ByCommitTimeCutoff {
454+
order,
455+
seconds: 978393600, // =2001-01-02 00:00:00 +0000
456+
})
457+
.check()?;
458+
}
405459
Ok(())
406460
}
407461

408462
#[test]
409-
fn head_date_order_first_parent_only() -> crate::Result {
463+
fn head_date_order_with_cutoff_disabled() -> crate::Result {
464+
let very_early = 878393600; // an early date before any commit
410465
TraversalAssertion::new(
411466
"make_traversal_repo_for_commits_with_dates.sh",
412467
&["288e509293165cb5630d08f4185bdf2445bf6170"], /* m1b1 */
413468
&[
469+
"bcb05040a6925f2ff5e10d3ae1f9264f2e8c43ac", /* b1c1 */
414470
"9902e3c3e8f0c569b4ab295ddf473e6de763e1e7", /* c2 */
415471
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
416472
],
417473
)
418-
.with_sorting(Sorting::ByCommitTimeNewestFirst)
419-
.with_parents(Parents::First)
420-
.check()
474+
.with_sorting(Sorting::ByCommitTimeCutoff {
475+
order: CommitTimeOrder::NewestFirst,
476+
seconds: very_early,
477+
})
478+
.check()?;
479+
480+
TraversalAssertion::new(
481+
"make_traversal_repo_for_commits_with_dates.sh",
482+
&["288e509293165cb5630d08f4185bdf2445bf6170"], /* m1b1 */
483+
&[
484+
"9902e3c3e8f0c569b4ab295ddf473e6de763e1e7", /* c2 */
485+
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
486+
"bcb05040a6925f2ff5e10d3ae1f9264f2e8c43ac", /* b1c1 */
487+
],
488+
)
489+
.with_sorting(Sorting::ByCommitTimeCutoff {
490+
order: CommitTimeOrder::OldestFirst,
491+
seconds: very_early,
492+
})
493+
.check()?;
494+
Ok(())
495+
}
496+
497+
#[test]
498+
fn date_order_with_cutoff_is_applied_to_starting_position() -> crate::Result {
499+
for order in all_commit_time_orderings() {
500+
let dir =
501+
gix_testtools::scripted_fixture_read_only_standalone("make_traversal_repo_for_commits_with_dates.sh")?;
502+
let store = gix_odb::at(dir.join(".git").join("objects"))?;
503+
let iter = Simple::new(
504+
Some(hex_to_id("9902e3c3e8f0c569b4ab295ddf473e6de763e1e7" /* c2 */)),
505+
&store,
506+
)
507+
.sorting(Sorting::ByCommitTimeCutoff {
508+
order,
509+
seconds: 978393600, // =2001-01-02 00:00:00 +0000
510+
})?;
511+
assert_eq!(
512+
iter.count(),
513+
0,
514+
"initial tips that don't pass cutoff value are not returned either"
515+
);
516+
}
517+
Ok(())
518+
}
519+
520+
#[test]
521+
fn head_date_order_first_parent_only() -> crate::Result {
522+
for order in all_commit_time_orderings() {
523+
TraversalAssertion::new(
524+
"make_traversal_repo_for_commits_with_dates.sh",
525+
&["288e509293165cb5630d08f4185bdf2445bf6170"], /* m1b1 */
526+
&[
527+
"9902e3c3e8f0c569b4ab295ddf473e6de763e1e7", /* c2 */
528+
"134385f6d781b7e97062102c6a483440bfda2a03", /* c1 */
529+
],
530+
)
531+
.with_sorting(Sorting::ByCommitTime(order))
532+
.with_parents(Parents::First)
533+
.check()?;
534+
}
535+
Ok(())
536+
}
537+
538+
fn all_commit_time_orderings() -> [CommitTimeOrder; 2] {
539+
[CommitTimeOrder::NewestFirst, CommitTimeOrder::OldestFirst]
421540
}
422541
}

‎gix/src/remote/connection/fetch/update_refs/mod.rs

+13-13
Original file line numberDiff line numberDiff line change
@@ -154,19 +154,19 @@ pub(crate) fn update(
154154
.find_object(local_id)?
155155
.try_into_commit()
156156
.map_err(|_| ())
157-
.and_then(|c| {
158-
c.committer().map(|a| a.time.seconds).map_err(|_| ())
159-
}).and_then(|local_commit_time|
160-
remote_id
161-
.to_owned()
162-
.ancestors(&repo.objects)
163-
.sorting(
164-
gix_traverse::commit::simple::Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
165-
seconds: local_commit_time
166-
},
167-
)
168-
.map_err(|_| ())
169-
);
157+
.and_then(|c| c.committer().map(|a| a.time.seconds).map_err(|_| ()))
158+
.and_then(|local_commit_time| {
159+
remote_id
160+
.to_owned()
161+
.ancestors(&repo.objects)
162+
.sorting(
163+
gix_traverse::commit::simple::Sorting::ByCommitTimeCutoff {
164+
order: Default::default(),
165+
seconds: local_commit_time,
166+
},
167+
)
168+
.map_err(|_| ())
169+
});
170170
match ancestors {
171171
Ok(mut ancestors) => {
172172
ancestors.any(|cid| cid.map_or(false, |c| c.id == local_id))

‎gix/src/revision/spec/parse/delegate/navigate.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -192,7 +192,7 @@ impl<'repo> delegate::Navigate for Delegate<'repo> {
192192
match oid
193193
.attach(repo)
194194
.ancestors()
195-
.sorting(crate::revision::walk::Sorting::ByCommitTimeNewestFirst)
195+
.sorting(crate::revision::walk::Sorting::ByCommitTime(Default::default()))
196196
.all()
197197
{
198198
Ok(iter) => {
@@ -245,7 +245,7 @@ impl<'repo> delegate::Navigate for Delegate<'repo> {
245245
.filter(|r| r.id().header().ok().map_or(false, |obj| obj.kind().is_commit()))
246246
.filter_map(|r| r.detach().peeled),
247247
)
248-
.sorting(crate::revision::walk::Sorting::ByCommitTimeNewestFirst)
248+
.sorting(crate::revision::walk::Sorting::ByCommitTime(Default::default()))
249249
.all()
250250
{
251251
Ok(iter) => {

‎gix/src/revision/walk.rs

+18-13
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
use gix_hash::ObjectId;
22
use gix_object::FindExt;
3+
use gix_traverse::commit::simple::CommitTimeOrder;
34

45
use crate::{ext::ObjectIdExt, revision, Repository};
56

@@ -39,24 +40,27 @@ pub enum Sorting {
3940
/// as it avoids overlapping branches.
4041
#[default]
4142
BreadthFirst,
42-
/// Commits are sorted by their commit time in descending order, that is newest first.
43+
/// Commits are sorted by their commit time in the order specified, either newest or oldest first.
4344
///
4445
/// The sorting applies to all currently queued commit ids and thus is full.
4546
///
46-
/// In the *sample history* the order would be `8, 7, 6, 4, 5, 2, 3, 1`
47+
/// In the *sample history* the order would be `8, 7, 6, 5, 4, 3, 2, 1` for [`NewestFirst`](CommitTimeOrder::NewestFirst),
48+
/// or `1, 2, 3, 4, 5, 6, 7, 8` for [`OldestFirst`](CommitTimeOrder::OldestFirst).
4749
///
4850
/// # Performance
4951
///
5052
/// This mode benefits greatly from having an [object cache](crate::Repository::object_cache_size) configured
5153
/// to avoid having to look up each commit twice.
52-
ByCommitTimeNewestFirst,
53-
/// This sorting is similar to `ByCommitTimeNewestFirst`, but adds a cutoff to not return commits older than
54+
ByCommitTime(CommitTimeOrder),
55+
/// This sorting is similar to [`ByCommitTime`](Sorting::ByCommitTimeCutoff), but adds a cutoff to not return commits older than
5456
/// a given time, stopping the iteration once no younger commits is queued to be traversed.
5557
///
5658
/// As the query is usually repeated with different cutoff dates, this search mode benefits greatly from an object cache.
5759
///
5860
/// In the *sample history* and a cut-off date of 4, the returned list of commits would be `8, 7, 6, 4`
59-
ByCommitTimeNewestFirstCutoffOlderThan {
61+
ByCommitTimeCutoff {
62+
/// The order in wich to prioritize lookups
63+
order: CommitTimeOrder,
6064
/// The amount of seconds since unix epoch to use as cut-off time.
6165
seconds: gix_date::SecondsSinceUnixEpoch,
6266
},
@@ -66,9 +70,9 @@ impl Sorting {
6670
fn into_simple(self) -> Option<gix_traverse::commit::simple::Sorting> {
6771
Some(match self {
6872
Sorting::BreadthFirst => gix_traverse::commit::simple::Sorting::BreadthFirst,
69-
Sorting::ByCommitTimeNewestFirst => gix_traverse::commit::simple::Sorting::ByCommitTimeNewestFirst,
70-
Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds } => {
71-
gix_traverse::commit::simple::Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds }
73+
Sorting::ByCommitTime(order) => gix_traverse::commit::simple::Sorting::ByCommitTime(order),
74+
Sorting::ByCommitTimeCutoff { seconds, order } => {
75+
gix_traverse::commit::simple::Sorting::ByCommitTimeCutoff { order, seconds }
7276
}
7377
})
7478
}
@@ -208,15 +212,16 @@ impl<'repo> Platform<'repo> {
208212
/// Prune the commit with the given `ids` such that they won't be returned, and such that none of their ancestors is returned either.
209213
///
210214
/// Note that this forces the [sorting](Self::sorting) to
211-
/// [`ByCommitTimeNewestFirstCutoffOlderThan`](Sorting::ByCommitTimeNewestFirstCutoffOlderThan) configured with
215+
/// [`ByCommitTimeCutoff`](Sorting::ByCommitTimeCutoff) configured with
212216
/// the oldest available commit time, ensuring that no commits older than the oldest of `ids` will be returned either.
213217
///
214218
/// Also note that commits that can't be accessed or are missing are simply ignored for the purpose of obtaining the cutoff date.
215219
#[doc(alias = "hide", alias = "git2")]
216220
pub fn with_pruned(mut self, ids: impl IntoIterator<Item = impl Into<ObjectId>>) -> Self {
217-
let mut cutoff = match self.sorting {
218-
Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds } => Some(seconds),
219-
Sorting::BreadthFirst | Sorting::ByCommitTimeNewestFirst => None,
221+
let (mut cutoff, order) = match self.sorting {
222+
Sorting::ByCommitTimeCutoff { seconds, order } => (Some(seconds), order),
223+
Sorting::ByCommitTime(order) => (None, order),
224+
Sorting::BreadthFirst => (None, CommitTimeOrder::default()),
220225
};
221226
for id in ids.into_iter() {
222227
let id = id.into();
@@ -231,7 +236,7 @@ impl<'repo> Platform<'repo> {
231236
}
232237

233238
if let Some(cutoff) = cutoff {
234-
self.sorting = Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds: cutoff }
239+
self.sorting = Sorting::ByCommitTimeCutoff { seconds: cutoff, order }
235240
}
236241
self
237242
}

‎gix/tests/id/mod.rs

+7-4
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,7 @@ mod ancestors {
8585
let commits_by_commit_date = head
8686
.ancestors()
8787
.use_commit_graph(!use_commit_graph)
88-
.sorting(gix::revision::walk::Sorting::ByCommitTimeNewestFirst)
88+
.sorting(gix::revision::walk::Sorting::ByCommitTime(Default::default()))
8989
.all()?
9090
.map(|c| c.map(gix::revision::walk::Info::detach))
9191
.collect::<Result<Vec<_>, _>>()?;
@@ -119,7 +119,7 @@ mod ancestors {
119119
let head = repo.head()?.into_peeled_id()?;
120120
let commits = head
121121
.ancestors()
122-
.sorting(gix::revision::walk::Sorting::ByCommitTimeNewestFirst) // assure we have time set
122+
.sorting(gix::revision::walk::Sorting::ByCommitTime(Default::default())) // assure we have time set
123123
.use_commit_graph(use_commit_graph)
124124
.all()?
125125
.collect::<Result<Vec<_>, _>>()?;
@@ -162,8 +162,11 @@ mod ancestors {
162162
for use_commit_graph in [false, true] {
163163
for sorting in [
164164
gix::revision::walk::Sorting::BreadthFirst,
165-
gix::revision::walk::Sorting::ByCommitTimeNewestFirst,
166-
gix::revision::walk::Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds: 0 },
165+
gix::revision::walk::Sorting::ByCommitTime(Default::default()),
166+
gix::revision::walk::Sorting::ByCommitTimeCutoff {
167+
order: Default::default(),
168+
seconds: 0,
169+
},
167170
] {
168171
let commits_graph_order = head
169172
.ancestors()

‎gix/tests/repository/shallow.rs

+7-3
Original file line numberDiff line numberDiff line change
@@ -44,6 +44,7 @@ fn yes() -> crate::Result {
4444
}
4545

4646
mod traverse {
47+
use gix_traverse::commit::simple::CommitTimeOrder;
4748
use serial_test::parallel;
4849

4950
use crate::util::{hex_to_id, named_subrepo_opts};
@@ -53,8 +54,11 @@ mod traverse {
5354
fn boundary_is_detected_triggering_no_error() -> crate::Result {
5455
for sorting in [
5556
gix::revision::walk::Sorting::BreadthFirst,
56-
gix::revision::walk::Sorting::ByCommitTimeNewestFirst,
57-
gix::revision::walk::Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds: 0 },
57+
gix::revision::walk::Sorting::ByCommitTime(CommitTimeOrder::NewestFirst),
58+
gix::revision::walk::Sorting::ByCommitTimeCutoff {
59+
order: CommitTimeOrder::NewestFirst,
60+
seconds: 0,
61+
},
5862
] {
5963
for toggle in [false, true] {
6064
for name in ["shallow.git", "shallow"] {
@@ -97,7 +101,7 @@ mod traverse {
97101
.head_id()?
98102
.ancestors()
99103
.use_commit_graph(toggle)
100-
.sorting(gix::revision::walk::Sorting::ByCommitTimeNewestFirst)
104+
.sorting(gix::revision::walk::Sorting::ByCommitTime(CommitTimeOrder::NewestFirst))
101105
.all()?
102106
.map(|c| c.map(|c| c.id))
103107
.collect::<Result<_, _>>()?;

0 commit comments

Comments
 (0)
Please sign in to comment.