white-space
:
;
}
/* ---- Log ------------------------------------------------------------------ */
.
{
margin-top
:
var
(--
space-lg
);
max-width
:
420
px
;
}
.
{
margin-top
:
var
(--
space-xl
);
}
.
{
list-style
:
;
border-top
:
1
px
var
(--
border
);
}
.
{
display
:
;
align-items
:
;
justify-content
:
;
:
var
(--
space-md
);
padding
:
12
px
;
border-bottom
:
1
px
var
(--
border
);
}
.
{
min-width
:
0
;
}
.
{
color
:
var
(--
text-primary
);
overflow-wrap
:
;
}
.
{
margin-top
:
var
(--
space-2xs
);
font-family
:
var
(--
font-mono
);
font-size
:
var
(--
caption
);
color
:
var
(--
text-secondary
);
}
.
{
flex
:
;
font-size
:
var
(--
caption
);
color
:
var
(--
interactive
);
}
.
{
margin-top
:
var
(--
space-lg
);
}
.
{
display
:
;
justify-content
:
;
:
var
(--
space-md
);
margin-top
:
var
(--
space-xl
);
}
.
a
,
.
span
{
display
:
;
align-items
:
;
min-height
:
44
px
;
}
/* ---- Commit --------------------------------------------------------------- */
.
{
margin-top
:
var
(--
space-lg
);
}
.
{
font-size
:
var
(--
heading
);
font-weight
:
400
;
line-height
:
1
.
25
;
color
:
var
(--
text-display
);
overflow-wrap
:
;
}
.
{
max-width
:
72
ch
;
margin-top
:
var
(--
space-md
);
font-family
:
var
(--
font-body
);
font-size
:
var
(--
body
);
white-space
:
;
overflow-wrap
:
;
color
:
var
(--
text-secondary
);
}
.
{
display
:
;
:
var
(--
space-xl
);
margin-top
:
var
(--
space-xl
);
}
@
media
(
min-width
:
768
px
)
{
.
{
grid-template-columns
:
minmax
(
0
,
1
fr
)
;
align-items
:
;
}
}
/* The one break on the commit page: a hero diffstat. */
.
{
text-align
:
;
}
.
{
font-family
:
var
(--
font-mono
);
font-size
:
48
px
;
line-height
:
1
;
letter-spacing
:
-0
.
02
em
;
color
:
var
(--
text-display
);
white-space
:
;
}
.
.
{
margin-top
:
var
(--
space-sm
);
}
.
{
color
:
var
(--
success
);
}
.
{
color
:
var
(--
accent
);
}
.
{
display
:
;
flex-wrap
:
;
align-items
:
;
justify-content
:
;
:
var
(--
space-md
);
margin-top
:
var
(--
space-xl
);
}
.
{
display
:
;
align-items
:
;
:
var
(--
space-sm
);
}
.
a
,
.
>
span
:
,
.
>
span
:
{
display
:
;
align-items
:
;
justify-content
:
;
min-width
:
28
px
;
min-height
:
28
px
;
}
.
{
list-style
:
;
margin-top
:
var
(--
space-lg
);
border-top
:
1
px
var
(--
border
);
}
.
{
display
:
;
align-items
:
;
:
var
(--
space-md
);
min-height
:
40
px
;
padding
:
var
(--
space-xs
);
border-bottom
:
1
px
var
(--
border
);
}
.
{
flex
:
;
width
:
1
.
5
em
;
font-family
:
var
(--
font-mono
);
font-size
:
var
(--
caption
);
color
:
var
(--
text-secondary
);
}
.
{
flex
:
1
;
min-width
:
0
;
font-family
:
var
(--
font-mono
);
font-size
:
var
(--
body-sm
);
color
:
var
(--
text-primary
);
overflow-wrap
:
;
}
.
.
,
.
.
{
color
:
var
(--
text-disabled
);
}
.
{
flex
:
;
font-family
:
var
(--
font-mono
);
font-size
:
var
(--
caption
);
white-space
:
;
}
.
{
display
:
;
flex
:
;
:
2
px
;
}
.
i
{
width
:
8
px
;
height
:
8
px
;
background
:
var
(--
segment-empty
);
}
.
i
.
{
background
:
var
(--
success
);
}
.
i
.
{
background
:
var
(--
accent
);
}
.
{
margin-top
:
var
(--
space-2xl
);
}
.
{
position
:
;
top
:
0
;
z-index
:
1
;
display
:
;
align-items
:
;
:
var
(--
space-md
);
min-height
:
44
px
;
background
:
var
(--
black
);
border-bottom
:
1
px
var
(--
border-visible
);
}
.
{
flex
:
1
;
min-width
:
0
;
font-family
:
var
(--
font-mono
);
font-size
:
var
(--
body-sm
);
color
:
var
(--
text-display
);
overflow-wrap
:
;
}
.
{
flex
:
;
}
.
{
padding
:
var
(--
space-md
);
border-bottom
:
1
px
var
(--
border
);
overflow-wrap
:
;
}
.
.
{
margin-top
:
0
;
border-top
:
0
;
}
.
.
.
{
padding
:
0
var
(--
space-sm
);
color
:
var
(--
text-disabled
);
font-size
:
12
px
;
}
.
.
.
+
.
{
border-left
:
0
;
}
.
.
.
{
width
:
1
%
;
padding
:
0
var
(--
space-xs
)
0
var
(--
space-sm
);
color
:
var
(--
text-disabled
);
user-select
:
;
-webkit-user-select
:
;
}
.
.
.
{
padding-left
:
0
;
}
.
.
tr
.
.
:
{
border-left-color
:
var
(--
success
);
}
.
.
tr
.
.
{
color
:
var
(--
success
);
}
.
.
tr
.
.
:
{
border-left-color
:
var
(--
accent
);
}
.
.
tr
.
.
{
color
:
var
(--
accent
);
}
.
.
tr
.
.
{
opacity
:
0
.
55
;
}
.
.
tr
.
td
{
padding
:
var
(--
space-xs
);
color
:
var
(--
text-disabled
);
}
.
.
tr
.
.
{
font-family
:
var
(--
font-mono
);
font-size
:
12
px
;
}
.
.
tr
.
:
(:
)
td
{
border-top
:
1
px
var
(--
border
);
}
/* ---- Markdown ------------------------------------------------------------ */
.
{
code_font
=
"Space Mono"
max_blob_kb
=
1024
max_highlight_kb
=
256
log_page
=
50
# commits per log page
[
cache
]
size_mb
=
64
git_parallel
=
0
# 0 = 2 × CPUs
heavy_parallel
=
2
request_timeout_secs
=
30
log_scan
=
10000
# commits examined per page by path/grep log filters
diff_files
=
300
# larger commits show the file list only
diff_lines
=
10000
# changed lines rendered per commit
diff_file_lines
=
2000
# changed lines rendered per file
[
log
]
level
=
"info"
# RUST_LOG takes precedence when set
use
::
::
;
use
crate
::
::
;
use
crate
::
::
::{
,
};
use
crate
::
::
::
;
use
crate
::
::
::
;
use
crate
::
::{
,
};
use
crate
::
::
::{
,
as
};
#[
(
,
,
,
,
)]
pub
enum
Key
{
:
String
,
:
u64
,
},
{
:
,
:
,
},
{
:
,
:
,
},
(
),
}
#[
(
)]
(
<
Vec
<
>>),
(
u64
),
(
<
>),
(
<
>),
(
<
>),
(
<
>),
}
impl
Value
{
::
(
)
=>
.
iter
().
map
(|
|
.
.
len
()
+
64
).
sum
(),
::
(_)
=>
8
,
::
(
)
=>
.
weight
(),
::
(
)
=>
.
weight
(),
::
(
)
=>
.
weight
(),
::
(
)
=>
.
weight
(),
}
}
}
::
{
,
..
}
=>
.
len
(),
::
{
,
..
}
=>
.
len
(),
::
{
,
..
}
=>
.
len
(),
::
{
,
..
}
=>
{
.
.
len
()
+
.
.
as_ref
().
map_or
(
0
,
String
::
)
}
_
=>
0
,
};
u32
::
(
64
+
+
.
weight
()).
unwrap_or
(
u32
::
)
}
}
pub
fn
log
<
>(
&
:
:
()
Result
<
>
)
->
Result
<
<
>
>
{
match
.
get_or
(
,
||
compute
().
map
(|
|
::
(
::
(
))))?
{
::
(
)
=>
Ok
(
),
_
=>
("cache key/value kind mismatch"),
}
}
pub
fn
diff
<
>(
&
:
:
()
Result
<
>
)
->
Result
<
<
>
>
{
match
.
get_or
(
,
||
compute
().
map
(|
|
::
(
::
(
))))?
{
::
(
)
=>
Ok
(
),
_
=>
("cache key/value kind mismatch"),
}
}
pub
fn
mailmap
<
>(
&
:
:
()
Result
<
>
)
->
Result
<
<
>
>
{
match
.
get_or
(
::
(
),
||
{
compute
().
map
(|
|
::
(
::
(
)))
})?
{
::
(
)
=>
Ok
(
),
_
=>
("cache key/value kind mismatch"),
}
}
pub
fn
entry_count
(&
)
->
u64
{
.
.
run_pending_tasks
();
.
.
entry_count
()
pub
:
pub
:
u64
pub
:
u64
/// Commits per log page.
pub
:
usize
}
impl
for
UiConfig
{
:
.
into
(),
:
1024
,
:
256
,
:
50
,
}
}
}
pub
:
usize
pub
:
usize
pub
:
u64
/// Commits a filtered log (path or grep) examines per page.
pub
:
usize
/// Above these, a commit's diff is not shown in full.
pub
:
usize
pub
:
usize
pub
:
usize
}
impl
for
LimitsConfig
{
:
0
,
:
2
,
:
30
,
:
10_000
,
:
300
,
:
10_000
,
:
2_000
,
}
}
}
if
.
.
==
0
{
.
push
("limits.request_timeout_secs must be at least 1".
into
());
}
if
!(
1
..=
1000
).
contains
(&
.
.
)
{
.
push
("ui.log_page must be between 1 and 1000".
into
());
}
for
(
,
)
in
[
("log_scan",
.
.
),
("diff_files",
.
.
),
("diff_lines",
.
.
),
("diff_file_lines",
.
.
),
]
{
if
==
0
{
.
push
(
("limits.{key} must be at least 1"));
}
}
// log
if
let
Err
(
)
=
::
::
(&
.
.
)
{
//! What a commit changed: the file list (with renames) against its first
//! parent, and line diffs grouped into hunks.
use
::
::
;
use
::
;
use
::
::
;
use
::
::
::{
,
,
};
use
::
::
::
::
;
use
super
::
;
use
super
::
::
;
#[
(
,
,
,
,
)]
pub
enum
Status
{
,
,
,
,
,
}
/// One side of a change.
#[
(
,
,
,
)]
pub
struct
Side
{
pub
:
pub
:
pub
:
}
#[
(
,
,
,
)]
pub
struct
FileChange
{
pub
:
pub
:
Option
<
>
pub
:
Option
<
>
/// Rename/copy similarity in percent.
pub
:
Option
<
u8
>
}
impl
FileChange
{
/// The path after the change (before it, for deletions).
pub
fn
path
(&
)
->
&
{
match
(&
.
,
&
.
)
{
(
Some
(
),
_)
|
(
None
,
Some
(
))
=>
&
.
,
(
None
,
None
)
=>
("a change has at least one side"),
}
}
}
#[
(
,
)]
pub
struct
Changes
{
/// The first parent; `None` for a root commit (compared to nothing).
pub
:
Option
<
>
pub
:
Vec
<
>
}
/// Files changed by `commit` relative to its first parent, renames
/// detected like `git diff -M` (50% similarity), sorted by path.
pub
fn
changes
(
:
&
::
:
)
->
::
Result
<
>
{
let
=
.
find_commit
(
).
context
("commit not found")?;
let
=
.
tree
().
context
("commit has no tree")?;
let
=
.
parent_ids
().
next
().
map
(|
|
.
detach
());
let
=
match
{
Some
(
)
=>
Some
(
.
find_commit
(
)
.
context
("parent commit not found")?
.
tree
()
.
context
("parent has no tree")?,
),
None
=>
None
,
};
let
=
::
::
::
().
with_rewrites
(
Some
(
Default
::
()));
let
=
.
diff_tree_to_tree
(
.
as_ref
(),
Some
(&
),
)
.
context
("cannot diff trees")?;
let
side
=
|
:
&
,
:
::
::
::
,
:
|
{
(!
.
is_tree
()).
then
(||
{
:
.
clone
(),
,
:
::
(
.
kind
()),
})
};
let
mut
=
Vec
::
();
for
in
{
let
=
match
{
::
{
,
,
,
..
}
=>
{
:
::
,
:
None
,
:
side
(&
,
,
),
:
None
,
},
::
{
,
,
,
..
}
=>
{
:
::
,
:
side
(&
,
,
),
:
None
,
:
None
,
},
::
{
,
,
,
,
,
}
=>
{
// A tree replaced by a file (or the reverse) is just an
// addition (deletion) of the file. A file that changed type
// (regular, symlink, submodule) is both, as git shows it.
let
=
side
(&
,
,
);
let
=
side
(&
,
,
);
match
(
,
)
{
(
Some
(
),
Some
(
))
if
!
.
.
same_type
(
.
)
=>
{
.
push
(
{
:
::
,
:
Some
(
),
:
None
,
:
None
,
});
{
:
::
,
:
None
,
:
Some
(
),
:
None
,
}
}
(
,
)
=>
{
:
match
(&
,
&
)
{
(
None
,
_)
=>
::
,
(_,
None
)
=>
::
,
_
=>
::
,
},
,
,
:
None
,
},
}
}
::
{
,
,
,
,
,
,
,
,
..
}
=>
{
:
if
{
::
}
else
{
::
},
:
side
(&
,
,
),
:
side
(&
,
,
),
// Truncated like git's percentage.
:
Some
(
.
map_or
(
100.0
,
|
|
.
*
100.0
)
.
floor
()
.
clamp
(
0.0
,
100.0
)
as
u8
,
),
},
};
if
.
.
is_some
()
||
.
.
is_some
()
{
.
push
(
);
}
}
.
sort_by
(|
,
|
.
path
().
cmp
(
.
path
()));
Ok
(
{
,
})
}
#[
(
,
,
,
,
)]
pub
enum
LineKind
{
,
,
,
}
/// A line in a hunk; `old`/`new` are 0-based line indexes into each side.
#[
(
,
,
,
,
)]
pub
struct
Line
{
pub
:
pub
:
Option
<
u32
>
pub
:
Option
<
u32
>
}
#[
(
,
,
,
)]
pub
struct
Hunk
{
/// 0-based first line and length on each side.
pub
:
u32
pub
:
u32
pub
:
u32
pub
:
u32
pub
:
Vec
<
>
/// The enclosing "function" line git shows after the ranges.
pub
:
Option
<
String
>
}
impl
Hunk
{
/// `@@ -1,5 +1,8 @@ fn main() {`
pub
fn
header
(&
)
->
{
fn
range
(
:
u32
:
u32
)
->
{
match
{
0
=>
("{start},0"),
1
=>
("{}",
+
1
),
_
=>
("{},{len}",
+
1
),
}
}
let
mut
=
(
"@@ -{} +{} @@",
range
(
.
,
.
),
range
(
.
,
.
)
);
if
let
Some
(
)
=
&
.
{
.
push
(' ');
.
push_str
(
);
}
}
}
#[
(
,
,
,
,
)]
pub
struct
LineDiff
{
pub
:
Vec
<
>
pub
:
u32
pub
:
u32
}
/// Line diff of two texts split into lines (each with its `\n`, so a
/// missing final newline counts as a change), with `context` unchanged
/// lines around each change. `ignore_ws` compares lines with all
/// whitespace removed, like `git diff -w`.
pub
fn
lines
(
:
&
&
str
:
&
&
str
:
u32
:
bool
)
->
{
let
=
if
{
let
=
|
:
&&
str
|
->
Vec
<
u8
>
{
.
bytes
().
filter
(|
|
!
.
is_ascii_whitespace
()).
collect
()
};
compute
(
.
iter
().
map
(
),
.
iter
().
map
(
))
}
else
{
compute
(
.
iter
().
map
(|
|
.
as_bytes
()),
.
iter
().
map
(|
|
.
as_bytes
()),
)
};
let
:
Vec
<_>
=
.
hunks
().
collect
();
let
(
,
)
=
(
.
len
()
as
u32
,
.
len
()
as
u32
);
let
mut
=
{
:
Vec
::
(),
:
.
count_additions
(),
:
.
count_removals
(),
};
let
mut
=
0
;
while
<
.
len
()
{
// Merge changes whose context would overlap or touch.
let
mut
=
;
while
+
1
<
.
len
()
&&
[
+
1
].
.
-
[
].
.
<=
2
*
{
+=
1
;
}
let
=
[
].
.
.
min
(
);
let
(
,
)
=
(
[
].
.
-
,
[
].
.
-
);
let
=
.
min
(
-
[
].
.
);
let
(
,
)
=
(
[
].
.
+
,
[
].
.
+
);
(
<=
);
let
mut
=
Vec
::
();
let
(
mut
,
mut
)
=
(
,
);
for
in
&
[
..=
]
{
while
<
.
.
{
.
push
(
{
:
::
,
:
Some
(
),
:
Some
(
),
});
+=
1
;
+=
1
;
}
for
in
.
.
clone
()
{
.
push
(
{
:
::
,
:
Some
(
),
:
None
,
});
}
for
in
.
.
clone
()
{
.
push
(
{
:
::
,
:
None
,
:
Some
(
),
});
}
=
.
.
;
=
.
.
;
}
while
<
{
.
push
(
{
:
::
,
:
Some
(
),
:
Some
(
),
});
+=
1
;
+=
1
;
}
.
.
push
(
{
,
:
-
,
,
:
-
,
,
:
func_line
(&
[..
as
usize
]),
});
=
+
1
;
}
}
/// git's default hunk-header context: the closest line above the hunk
/// that starts like an identifier, trailing whitespace trimmed, at most
/// 80 bytes.
fn
func_line
(
:
&
&
str
)
->
Option
<
String
>
{
let
=
.
iter
().
rev
().
find
(|
|
{
.
bytes
()
.
next
()
.
is_some_and
(|
|
.
is_ascii_alphabetic
()
||
==
b
'_'
||
==
b
'$')
})?;
let
=
&
.
as_bytes
()[..
.
len
().
min
(
80
)];
let
=
.
iter
()
.
rposition
(|
|
!
.
is_ascii_whitespace
())
.
map_or
(
0
,
|
|
+
1
);
Some
(
String
::
(&
[..
]).
into_owned
())
}
fn
compute
<
:
AsRef
<[
u8
]>
+
+
Eq
+
Default
>(
:
Iterator
<
>
:
Iterator
<
>
)
->
{
let
mut
=
::
();
.
update_before
(
);
.
update_after
(
);
::
::
::
(
::
,
&
)
}
/// Git's mode for an entry kind (`100644`, …).
pub
fn
mode
(
:
)
->
&
'static
str
{
match
{
::
=>
"100644",
::
=>
"100755",
::
=>
"120000",
::
=>
"160000",
::
=>
"040000",
}
}
#[
(
)]
mod
tests
{
use
super
::*;
fn
split
(
:
&
str
)
->
Vec
<&
str
>
{
.
split_inclusive
('\n').
collect
()
}
#[
]
fn
hunks_with_context_and_merging
()
{
let
=
"a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n";
let
=
"a\nB\nc\nd\ne\nf\ng\nh\ni\nJ\n";
let
=
lines
(&
split
(
),
&
split
(
),
3
,
false
);
((
.
,
.
),
(
2
,
2
));
// Changes at lines 2 and 10 are 7 apart: with 3 lines of context
// they stay separate hunks.
(
.
.
len
(),
2
);
(
.
[
0
].
header
(),
"@@ -1,5 +1,5 @@");
(
.
[
1
].
header
(),
"@@ -7,4 +7,4 @@ f");
// With more context they merge.
let
=
lines
(&
split
(
),
&
split
(
),
4
,
false
);
(
.
.
len
(),
1
);
(
.
[
0
].
header
(),
"@@ -1,10 +1,10 @@");
}
#[
]
fn
additions_to_empty_and_whitespace
()
{
let
=
lines
(&[],
&
split
("x\ny\n"),
3
,
false
);
(
.
[
0
].
header
(),
"@@ -0,0 +1,2 @@");
(
.
[
0
].
.
len
(),
2
);
let
=
split
("fn x() {\n    a;\n}\n");
let
=
split
("fn x() {\n\ta;\n}\n");
(
lines
(&
,
&
,
3
,
false
).
,
1
);
let
=
lines
(&
,
&
,
3
,
true
);
(
.
.
is_empty
());
((
.
,
.
),
(
0
,
0
));
}
#[
]
fn
missing_final_newline_is_a_change
()
{
let
=
lines
(&
split
("a\nb\n"),
&
split
("a\nb"),
0
,
false
);
((
.
,
.
),
(
1
,
1
));
(
.
[
0
].
header
(),
"@@ -2 +2 @@ a");
}
}
//! Commit history: newest-first walks, paged with a cursor, optionally
//! filtered by path and message.
//!
//! Path filters follow git's default history simplification: at a merge
//! that kept one parent's version of the path, only that parent is
//! followed, so side branches whose changes didn't survive are left out
//! (`git log -- path`, not `--full-history`).
use
::
::{
,
,
,
};
use
::
;
use
::
::
;
use
::
::
::
;
use
::
::
::
::
;
use
super
::
::{
,
};
use
super
::{
,
,
};
#[
(
,
,
,
,
,
)]
pub
struct
LogQuery
{
/// Only commits that change this path (empty: all commits).
pub
:
Vec
<
u8
>
/// Case-insensitive match on the message, author name and email.
pub
:
Option
<
String
>
/// Start after this commit (the last one on the previous page).
pub
:
Option
<
>
pub
:
usize
/// Commits a filtered walk may examine before giving up on this page.
pub
:
usize
}
impl
LogQuery
{
fn
filtered
(&
)
->
bool
{
!
.
.
is_empty
()
||
.
.
is_some
()
}
}
/// Where the "newer" link of a page goes.
#[
(
,
,
,
,
)]
pub
enum
Newer
{
/// This is the first page.
None
,
/// Back to the first page (filtered logs can't step back exactly).
,
(
),
}
#[
(
,
)]
pub
struct
LogPage
{
pub
:
Vec
<
>
/// Cursor for the next (older) page.
pub
:
Option
<
>
pub
:
/// The filter gave up after `scan_limit` commits; `older` continues.
pub
:
bool
}
impl
LogPage
{
pub
fn
weight
(&
)
->
usize
{
64
+
.
.
iter
().
map
(
::
).
::<
usize
>()
}
}
#[
(
,
)]
pub
enum
LogError
{
#[
("the cursor commit is not in this history")]
,
#[
(
)]
(#[
]
::
),
}
/// One page of the history of `tip`, newest commit first.
pub
fn
page
(
:
&
::
:
:
&
)
->
Result
<
>
{
let
=
.
filtered
();
let
=
.
.
as_ref
().
map
(|
|
.
to_lowercase
());
let
mut
=
if
.
.
is_empty
()
{
::
(
.
rev_walk
([
])
.
sorting
(
::
(
::
))
.
all
()
.
context
("cannot walk history")?,
)
}
else
{
::
(
::
(
,
,
&
.
)?)
};
// Unfiltered: the commits up to and including the cursor, enough to
// find where the previous page started.
let
mut
:
<
>
=
::
();
let
mut
=
.
;
let
mut
=
{
:
Vec
::
(),
:
None
,
:
::
,
:
false
,
};
let
mut
=
0
;
let
mut
=
None
;
while
let
Some
(
)
=
.
next
()
{
let
(
,
)
=
?;
if
let
Some
(
)
=
{
if
!
{
.
push_back
(
);
if
.
len
()
>
.
+
1
{
.
pop_front
();
}
}
if
==
{
=
None
;
}
continue
;
}
if
{
if
==
.
{
.
=
true
;
.
=
;
break
;
}
+=
1
;
=
Some
(
);
}
if
!
{
continue
;
}
let
=
commit_info
(
,
)?;
if
let
Some
(
)
=
&
&&
!
message_matches
(
,
&
,
)?
{
continue
;
}
if
.
.
len
()
==
.
{
.
=
.
.
last
().
map
(|
|
.
);
break
;
}
.
.
push
(
);
}
if
.
is_some
()
{
return
Err
(
::
);
}
if
.
.
is_some
()
{
.
=
if
||
.
len
()
<=
.
{
::
}
else
{
::
(
[
0
])
};
}
Ok
(
)
}
fn
message_matches
(
:
&
::
:
&
:
&
str
)
->
::
Result
<
bool
>
{
if
.
.
to_lowercase
().
contains
(
)
||
.
.
to_lowercase
().
contains
(
)
{
return
Ok
(
true
);
}
let
=
.
find_commit
(
.
).
context
("commit not found")?;
let
=
.
message_raw_sloppy
().
to_str_lossy
().
to_lowercase
();
Ok
(
.
contains
(
))
}
enum
Walk
{
(
::
::
<
'repo
>),
(
<
'repo
>),
}
impl
Walk
<
_>
{
/// The next commit, and whether it passes the path filter.
fn
next
(&
mut
)
->
Option
<
::
Result
<(
bool
)>>
{
match
{
::
(
)
=>
Some
(
.
next
()?
.
map
(|
|
(
.
,
true
))
.
context
("cannot walk history"),
),
::
(
)
=>
.
next
().
transpose
(),
}
}
}
/// Newest-first walk that simplifies history for `path`.
struct
PathWalk
<
'repo
>
{
:
&
'repo
::
:
Vec
<
u8
>
:
<(
i64
)>
:
<
>
:
}
impl
<
'repo
>
PathWalk
<
'repo
>
{
fn
new
(
:
&
'repo
::
:
:
&
u8
)
->
::
Result
<
Self
>
{
let
mut
=
{
,
:
.
to_vec
(),
:
::
(),
:
::
(),
:
::
(),
};
.
push
(
)?;
Ok
(
)
}
fn
push
(&
mut
:
)
->
::
Result
<()>
{
if
!
.
.
insert
(
)
{
return
Ok
(());
}
// Missing parents (shallow clones) end the walk there.
let
Ok
(
)
=
.
.
find_commit
(
)
else
{
return
Ok
(());
};
let
=
.
time
().
context
("malformed commit")?.
;
.
.
push
((
,
));
Ok
(())
}
fn
next
(&
mut
)
->
::
Result
<
Option
<(
bool
)>>
{
let
Some
((_,
))
=
.
.
pop
()
else
{
return
Ok
(
None
);
};
let
=
.
.
find_commit
(
).
context
("commit not found")?;
let
:
Vec
<
>
=
.
parent_ids
().
map
(|
|
.
detach
()).
collect
();
let
=
.
.
get
(
.
,
,
&
.
)?;
let
mut
=
None
;
for
in
&
{
if
.
.
get
(
.
,
*
,
&
.
)?
==
{
=
Some
(*
);
break
;
}
}
let
(
,
)
=
match
{
// Identical to a parent: not interesting, and only that
// parent's history explains the path's state.
Some
(
)
=>
(
false
,
[
]),
None
if
.
is_empty
()
=>
(
.
is_some
(),
Vec
::
()),
None
=>
(
true
,
),
};
for
in
{
.
push
(
)?;
}
Ok
(
Some
((
,
)))
}
}
/// What one path holds (id and mode), memoized per commit: each commit is
/// usually asked about again as the parent of the next one.
#[
(
)]
struct
PathOids
{
:
<
Option
<(
)>>
}
impl
PathOids
{
fn
get
(
&
mut
:
&
::
:
:
&
u8
)
->
::
Result
<
Option
<(
)>>
{
if
let
Some
(
)
=
.
.
get
(&
)
{
return
Ok
(*
);
}
let
=
::
(
,
,
)?;
if
.
.
len
()
>
4096
{
.
.
clear
();
}
.
.
insert
(
,
);
Ok
(
)
}
}
//! All repository access goes through this module; nothing else touches gix.
pub
mod
diff
;
pub
mod
log
;
pub
mod
refs
;
pub
mod
tree
;
}
Ok
(
)
}
/// Everything the commit page shows about a commit.
#[
(
,
)]
pub
struct
CommitDetail
{
pub
:
/// The message after the subject line, trimmed.
pub
:
/// The full message as stored, for patches.
pub
:
pub
:
pub
:
pub
:
Vec
<
>
pub
:
}
#[
(
,
,
,
)]
pub
struct
Person
{
pub
:
pub
:
/// Unix seconds and the UTC offset in seconds, as recorded.
pub
:
i64
pub
:
i32
}
pub
fn
commit_detail
(
:
&
::
:
)
->
::
Result
<
>
{
let
=
.
find_commit
(
).
context
("commit not found")?;
let
=
.
decode
().
context
("malformed commit")?;
let
person
=
|
:
::
::
<
_>|
{
let
=
.
time
().
unwrap_or_default
();
{
:
.
.
to_str_lossy
().
trim
().
to_string
(),
:
.
.
to_str_lossy
().
trim
().
to_string
(),
:
.
,
:
.
,
}
};
let
=
.
message
();
Ok
(
{
:
commit_info
(
,
)?,
:
.
body
()
.
map
(|
|
.
to_str_lossy
().
trim
().
to_string
())
.
unwrap_or_default
(),
:
.
.
to_str_lossy
().
into_owned
(),
:
person
(
.
author
().
context
("malformed author")?),
:
person
(
.
committer
().
context
("malformed committer")?),
:
.
parents
().
collect
(),
:
.
tree
(),
})
}
/// A `.mailmap`: canonical names and emails for authors.
#[
(
)]
pub
struct
Mailmap
(
::
::
);
impl
Mailmap
{
pub
fn
parse
(
:
&
u8
)
->
Self
{
(
::
::
::
(
))
}
/// Canonical `(name, email)` for an identity.
pub
fn
resolve
(&
:
&
str
:
&
str
)
->
(
)
{
let
=
::
::
{
:
.
as_bytes
().
as_bstr
(),
:
.
as_bytes
().
as_bstr
(),
:
"",
};
match
.
0.try_resolve_ref
(
)
{
Some
(
)
=>
(
.
.
map_or_else
(||
.
to_string
(),
|
|
.
to_str_lossy
().
into_owned
()),
.
.
map_or_else
(||
.
to_string
(),
|
|
.
to_str_lossy
().
into_owned
()),
),
None
=>
(
.
to_string
(),
.
to_string
()),
}
}
pub
fn
weight
(&
)
->
usize
{
.
0
.
iter
()
.
map
(|
|
{
64
+
.
old_email
().
len
()
+
.
old_name
().
map_or
(
0
,
|
|
.
len
())
+
.
new_email
().
map_or
(
0
,
|
|
.
len
())
+
.
new_name
().
map_or
(
0
,
|
|
.
len
())
})
.
sum
()
}
}
/// The `.mailmap` blob at the root of `commit`, if there is one.
pub
fn
mailmap_blob
(
:
&
::
:
)
->
Option
<
>
{
let
=
.
find_commit
(
).
ok
()?.
tree
().
ok
()?;
let
=
.
find_entry
(".mailmap")?;
.
mode
().
is_blob
().
then
(||
.
object_id
())
}
}
impl
EntryKind
{
fn
from_gix
(
:
)
->
Self
{
pub
(
super
)
fn
from_gix
(
:
)
->
Self
{
match
{
::
=>
::
,
::
=>
::
,
}
}
/// Same kind of object, ignoring the executable bit.
pub
fn
same_type
(
:
)
->
bool
{
let
regular
=
|
|
(
,
::
|
::
);
==
||
(
regular
(
)
&&
regular
(
))
}
pub
fn
is_blob
(
)
->
bool
{
(
,
}))
}
/// Id and kind of whatever `path` names in `commit`'s tree. `None` when
/// the path doesn't exist, or the commit itself is missing (shallow clones).
pub
fn
entry_at
(
:
&
::
:
:
&
u8
)
->
::
Result
<
Option
<(
)>>
{
let
Ok
(
)
=
.
find_commit
(
)
else
{
return
Ok
(
None
);
};
let
=
.
tree
().
context
("commit has no tree")?;
Ok
(
.
lookup_entry_by_path
(
as_path
(
))?
.
map
(|
|
(
.
object_id
(),
::
(
.
mode
().
kind
()))))
}
/// Entries of a tree: directories first, then files, each by name.
pub
fn
list
(
:
&
::
:
)
->
::
Result
<
Vec
<
>>
{
let
=
.
find_tree
(
).
context
("tree not found")?;
/// `412 lines`, `12.4 KB`, `Rust`.
pub
:
Vec
<
String
>
pub
:
pub
:
pub
:
pub
:
Option
<
>
pub
:
:
.
unwrap_or_else
(|
|
match
{}),
}
}
else
{
let
=
.
lines
().
next
().
unwrap_or_default
();
let
=
::
(&
,
);
=
.
map
(|
|
.
.
clone
());
let
=
match
{
Some
(
)
if
<=
.
.
.
*
1024
=>
{
let
=
::
{
:
,
:
.
.
clone
(),
};
.
.
.
lines
(
,
||
{
Ok
::<_
::
::
>(
::
(&
,
))
})
.
unwrap_or_else
(|
|
match
{})
}
_
=>
::
(
::
(&
)),
};
let
(
,
)
=
::
(
&
.
.
,
,
&
,
&
,
.
.
.
*
1024
,
);
=
.
map
(
str
::
);
::
{
}
}
}
:
Some
(
),
,
:
("{raw_url}?download"),
:
.
url
("log",
&
.
,
&
),
,
,
,
//! `/{repo}/commit/{rev}` — message, metadata, diffstat and the unified
//! diff against the first parent (`?context=N`, `?ws=ignore`).
//! `/{repo}/commit/{rev}.patch` — the same as a plain-text patch.
use
::
;
use
::
::{
,
,
};
use
::
::{
,
};
use
::
::
;
use
super
::
::
;
use
super
::
::{
,
,
,
,
,
};
use
super
::{
,
};
use
crate
::
::
;
use
crate
::
::
::
;
use
crate
::
::
::{
,
};
use
crate
::
::{
,
};
use
crate
::
::
::{
,
,
,
};
use
crate
::
::
;
const
:
u32
=
3
;
const
:
u32
=
50
;
pub
struct
Meta
{
pub
:
&
'static
str
pub
:
pub
:
Option
<
String
>
pub
:
Vec
<(
)>
}
pub
struct
FileRow
<
'a
>
{
pub
:
&
'a
pub
:
pub
:
/// Source path of a rename or copy.
pub
:
Option
<
String
>
pub
:
&
'static
str
/// Single-letter status (`A`, `M`, `D`, `R`, `C`).
pub
:
&
'static
str
/// Five blocks: `add`, `del` or `none`.
pub
:
&
'static
str
/// The file at this commit (or its parent, for deletions).
pub
:
Option
<
String
>
}
pub
struct
Toggle
{
pub
:
&
'static
str
pub
:
pub
:
bool
}
#[
(
)]
#[
(
=
"commit.html")]
pub
struct
CommitPage
<
'a
>
{
pub
:
pub
:
pub
:
Vec
<
>
pub
:
Option
<
String
>
pub
:
pub
:
pub
:
Vec
<
>
pub
:
u64
pub
:
u64
pub
:
Vec
<
<
'a
>>
pub
:
&
'a
pub
:
pub
:
pub
:
Vec
<
>
pub
:
Option
<
String
>
pub
:
Option
<
String
>
pub
:
u32
}
pub
fn
page
(
:
&
:
&
Vec
<
u8
>
)
->
{
let
Some
((
,
))
=
resolve
(
,
)
else
{
return
.
not_found
("UNKNOWN REVISION");
};
let
=
.
.
.
as_deref
()
.
and_then
(|
|
.
::<
u32
>().
ok
())
.
map_or
(
,
|
|
.
min
(
));
let
=
.
.
.
as_deref
()
==
Some
("ignore");
let
=
if
{
.
etag
(("patch",
.
))
}
else
{
.
etag
(("commit",
.
,
,
))
};
let
=
.
is_immutable
();
if
let
Some
(
)
=
.
not_modified
(&
,
)
{
return
;
}
let
=
match
::
(&
.
,
.
)
{
Ok
(
)
=>
,
Err
(
)
=>
return
.
internal_error
(
),
};
let
=
match
::
::
(&
.
,
.
)
{
Ok
(
)
=>
,
Err
(
)
=>
return
.
internal_error
(
),
};
if
{
return
match
::
(&
.
,
&
,
&
)
{
Ok
(
)
=>
{
let
mut
=
.
into_response
();
let
=
.
headers_mut
();
.
insert
(
::
,
::
("text/plain; charset=utf-8"),
);
.
insert
(
::
,
::
(
),
);
.
insert
(
::
,
::
("nosniff"),
);
set_cache_headers
(&
mut
,
&
,
);
}
Err
(
)
=>
.
internal_error
(
),
};
}
let
=
::
{
,
,
:
.
.
.
,
:
.
.
.
,
:
.
.
.
,
:
.
.
.
*
1024
,
:
.
.
.
*
1024
,
};
let
=
::
{
:
.
,
,
};
let
=
.
.
.
diff
(
,
||
{
::
(&
.
,
&
.
.
,
&
,
&
)
});
let
=
match
{
Ok
(
)
=>
,
Err
(
)
=>
return
.
internal_error
(
),
};
let
mut
=
commit_page
(
,
&
,
&
,
&
,
.
);
.
=
;
let
=
.
commit_url
(&
.
);
let
url
=
|
:
u32
,
:
bool
|
{
let
mut
=
Vec
::
();
if
!=
{
.
push
(
("context={context}"));
}
if
{
.
push
("ws=ignore".
to_string
());
}
if
.
is_empty
()
{
.
clone
()
}
else
{
("{base}?{}",
.
join
("&"))
}
};
.
=
[
{
:
"Whitespace",
:
url
(
,
false
),
:
!
,
},
{
:
"Ignore",
:
url
(
,
true
),
:
,
},
];
.
=
(
>
0
).
then
(||
url
(
.
saturating_sub
(
3
),
));
.
=
(
<
).
then
(||
url
((
+
3
).
min
(
),
));
let
mut
=
render
(
::
,
&
);
set_cache_headers
(&
mut
,
&
,
);
}
/// The revision and whether a patch was asked for. `{rev}.patch` is a
/// patch unless a ref with that literal name exists.
fn
resolve
(
:
&
:
&
Vec
<
u8
>
)
->
Option
<(
bool
)>
{
let
=
::
::
(&
.
join
(&
b
'/')).
ok
()?.
to_string
();
if
.
is_empty
()
{
return
None
;
}
if
let
Some
(
)
=
.
strip_suffix
(".patch")
&&
let
Some
(
)
=
::
(&
.
,
)
&&
::
(&
.
,
&
).
is_none
()
{
return
Some
((
,
true
));
}
::
(&
.
,
&
).
map
(|
|
(
,
false
))
}
fn
commit_page
<
'a
>(
:
&
:
&
:
&
:
&
'a
:
Option
<
::
>
)
->
<
'a
>
{
let
=
.
mailmap
();
let
=
.
.
.
to_string
();
let
(
,
)
=
.
resolve
(&
.
.
,
&
.
.
);
let
(
,
)
=
.
resolve
(&
.
.
,
&
.
.
);
let
mut
=
[
{
:
"Author",
:
.
clone
(),
:
Some
(
.
clone
()),
:
Vec
::
(),
}];
.
push
(
{
:
"Date",
:
::
(
.
.
,
.
.
),
:
Some
(
::
(
.
.
)),
:
Vec
::
(),
});
if
(&
,
&
)
!=
(&
,
&
)
||
.
.
!=
.
.
{
.
push
(
{
:
"Committer",
:
(
"{committer} · {}",
::
(
.
.
,
.
.
)
),
:
Some
(
),
:
Vec
::
(),
});
}
.
push
(
{
:
if
.
.
len
()
==
1
{
"Parent"
}
else
{
"Parents"
},
:
if
.
.
is_empty
()
{
"None".
into
()
}
else
{
String
::
()
},
:
None
,
:
.
.
iter
()
.
map
(|
|
(
short
(&
.
to_string
()),
.
commit_url
(
)))
.
collect
(),
});
.
push
(
{
:
"Commit",
:
.
clone
(),
:
None
,
:
Vec
::
(),
});
let
=
.
url
("tree",
&
,
b
"");
let
=
.
map
(|
|
.
to_string
());
let
=
.
.
iter
()
.
enumerate
()
.
map
(|(
,
)|
{
let
=
&
.
;
let
=
.
path
().
to_str_lossy
().
into_owned
();
let
=
match
.
{
::
=>
.
as_ref
()
.
map
(|
|
.
url
("blob",
,
.
path
())),
_
=>
Some
(
.
url
("blob",
&
,
.
path
())),
};
let
=
match
.
{
::
|
::
=>
.
.
as_ref
()
.
map
(|
|
.
.
to_str_lossy
().
into_owned
()),
_
=>
None
,
};
let
(
,
)
=
match
.
{
::
=>
("Added",
"A"),
::
=>
("Deleted",
"D"),
::
=>
("Modified",
"M"),
::
=>
("Renamed",
"R"),
::
=>
("Copied",
"C"),
};
// Submodules and binaries have no line counts but still have
// a URL; only blobs get one.
let
=
.
filter
(|
|
!
(
.
,
::
{
..
}));
{
,
:
("f{}",
+
1
),
,
,
,
,
:
bar
(
.
),
,
}
})
.
collect
();
{
:
::
(
.
,
.
,
Some
(&
("{} · {}",
.
.
,
.
.
)),
),
:
.
nav
(
::
,
Some
(
),
|
|
.
url
("log",
,
b
"")),
:
[
{
:
.
.
.
clone
(),
:
.
repo_url
(),
}],
:
Some
(
short
(&
)),
:
.
.
.
clone
(),
:
.
.
clone
(),
,
:
.
,
:
.
,
,
:
,
:
("{}.patch",
.
commit_url
(&
.
.
)),
,
:
Vec
::
(),
:
None
,
:
None
,
:
,
}
}
/// Five blocks split between additions and removals; fewer than five
/// changed lines leave the rest empty.
fn
bar
(
:
Option
<(
u32
u32
)>)
->
[&
'static
str
;
5
]
{
let
mut
=
["none";
5
];
let
Some
((
,
))
=
else
{
return
;
};
let
=
+
;
if
==
0
{
return
;
}
let
=
.
min
(
5
);
let
mut
=
((
*
)
as
f64
/
as
f64
).
round
()
as
u32
;
// Keep at least one block for each side that changed.
if
>
0
&&
==
0
{
=
1
;
}
if
>
0
&&
==
{
=
-
1
;
}
for
(
,
)
in
.
iter_mut
().
enumerate
().
take
(
as
usize
)
{
*
=
if
(
as
u32
)
<
{
"add"
}
else
{
"del"
};
}
}
#[
(
)]
mod
tests
{
use
super
::
;
#[
]
fn
diffstat_bars
()
{
(
bar
(
None
),
["none";
5
]);
(
bar
(
Some
((
0
,
0
))),
["none";
5
]);
(
bar
(
Some
((
2
,
0
))),
["add",
"add",
"none",
"none",
"none"]);
(
bar
(
Some
((
100
,
1
))),
["add",
"add",
"add",
"add",
"del"]);
(
bar
(
Some
((
1
,
100
))),
["add",
"del",
"del",
"del",
"del"]);
(
bar
(
Some
((
30
,
20
))),
["add",
"add",
"add",
"del",
"del"]);
}
}
//! `/{repo}/log/{rev}[/{path…}]` — history, newest first, grouped by day.
//! `?after=<oid>` pages, `?q=` filters by message and author.
use
::
;
use
::
::
;
use
::
::
;
use
::
::
;
use
super
::
::{
,
,
,
,
,
,
};
use
super
::{
,
};
use
crate
::
::
;
use
crate
::
::
;
use
crate
::
::
::{
,
,
,
};
use
crate
::
::{
,
};
pub
struct
LogRow
{
pub
:
pub
:
pub
:
pub
:
pub
:
pub
:
}
pub
struct
Day
{
pub
:
pub
:
Vec
<
>
}
#[
(
)]
#[
(
=
"log.html")]
pub
struct
LogPage
{
pub
:
pub
:
pub
:
Vec
<
>
pub
:
Option
<
String
>
pub
:
Vec
<
>
/// The form posts here (the log URL without query).
pub
:
pub
:
pub
:
Option
<
String
>
/// `Newer`, or `Newest` when the link jumps back to the first page.
pub
:
&
'static
str
pub
:
Option
<
String
>
pub
:
bool
pub
:
usize
}
pub
fn
page
(
:
&
:
&
Vec
<
u8
>
)
->
{
let
(
,
)
=
match
.
resolve
(
)
{
Ok
(
)
=>
,
Err
(
)
=>
return
*
,
};
let
=
match
.
.
.
as_deref
().
filter
(|
|
!
.
is_empty
())
{
None
=>
None
,
Some
(
)
=>
match
::
(
.
as_bytes
())
{
Ok
(
)
=>
Some
(
),
Err
(_)
=>
return
.
not_found
("INVALID CURSOR"),
},
};
let
=
.
.
.
as_deref
()
.
map
(
str
::
)
.
filter
(|
|
!
.
is_empty
())
.
map
(
str
::
);
let
=
{
:
.
clone
(),
,
,
:
.
.
.
,
:
.
.
.
,
};
let
=
.
etag
(("log",
.
,
&
));
let
=
.
is_immutable
();
if
let
Some
(
)
=
.
not_modified
(&
,
)
{
return
;
}
let
=
::
{
:
.
,
:
.
clone
(),
};
let
=
.
.
.
log
(
,
||
::
(&
.
,
.
,
&
));
let
=
match
{
Ok
(
)
=>
,
Err
(
::
)
=>
return
.
not_found
("COMMIT NOT IN THIS HISTORY"),
Err
(
::
(
))
=>
return
.
internal_error
(
),
};
let
=
.
url
("log",
&
.
,
&
);
let
link
=
|
:
Option
<
>|
{
let
mut
=
Vec
::
();
if
let
Some
(
)
=
&
.
{
.
push
(
("q={}",
encode_path
(
)));
}
if
let
Some
(
)
=
{
.
push
(
("after={id}"));
}
if
.
is_empty
()
{
.
clone
()
}
else
{
("{action}?{}",
.
join
("&"))
}
};
let
(
,
)
=
match
.
{
::
=>
(
None
,
"Newer"),
::
=>
(
Some
(
link
(
None
)),
"Newest"),
::
(
)
=>
(
Some
(
link
(
Some
(
))),
"Newer"),
};
let
=
.
mailmap
();
let
=
::
();
let
mut
:
Vec
<
>
=
Vec
::
();
for
in
&
.
{
let
=
::
(
.
);
let
=
.
.
to_string
();
let
=
{
:
if
.
.
is_empty
()
{
"(no message)".
into
()
}
else
{
.
.
clone
()
},
:
.
commit_url
(&
.
),
:
.
resolve
(&
.
,
&
.
).
0
,
:
::
(
.
,
),
:
::
(
.
),
:
short
(&
),
};
match
.
last_mut
()
{
Some
(
)
if
.
==
=>
.
.
push
(
),
_
=>
.
push
(
{
,
:
[
],
}),
}
}
let
(
,
)
=
crumbs
(
,
&
.
,
&
);
let
=
if
.
is_empty
()
{
("Log · {}",
.
.
)
}
else
{
("History of {} · {}",
.
to_str_lossy
(),
.
.
)
};
let
=
.
.
map
(|
|
link
(
Some
(
)));
let
=
{
:
::
(
.
,
.
,
Some
(&
)),
:
.
nav
(
::
,
Some
(&
),
|
|
.
url
("log",
,
&
)),
,
:
,
,
,
:
.
.
clone
().
unwrap_or_default
(),
,
,
,
:
.
,
:
.
,
};
let
mut
=
render
(
::
,
&
);
set_cache_headers
(&
mut
,
&
,
);
}
//! Request handlers. Each page is an askama template that embeds a [`Layout`].
pub
mod
blob
;
pub
mod
commit
;
pub
mod
error
;
pub
mod
index
;
pub
mod
log
;
pub
mod
raw
;
pub
mod
refs
;
pub
mod
repo
;
use
::
::{
,
,
};
use
::
;
use
super
::{
,
,
,
,
,
};
use
super
::{
,
,
,
,
,
,
,
};
use
crate
::
::
;
use
crate
::
::
;
use
crate
::
::
::{
,
,
};
use
crate
::
::{
,
};
use
crate
::
::{
,
,
,
};
use
crate
::
::
;
use
crate
::
::{
,
};
use
crate
::
::
;
pub
:
Option
<
String
>
/// Raw: serve as an attachment.
pub
:
Option
<
String
>
/// Log: cursor (the last commit of the previous page).
pub
:
Option
<
String
>
/// Log: message/author filter.
pub
:
Option
<
String
>
/// Commit: lines of context.
pub
:
Option
<
String
>
/// Commit: `ignore` compares lines ignoring whitespace.
pub
:
Option
<
String
>
}
pub
struct
RepoRequest
{
b
"tree"
=>
::
(&
,
),
b
"blob"
=>
::
(&
,
),
b
"raw"
=>
::
(&
,
),
b
"log"
=>
::
(&
,
),
b
"commit"
=>
::
(&
,
),
b
"refs"
if
.
is_empty
()
=>
::
(&
),
_
=>
.
not_found
("PAGE NOT FOUND"),
}
}
pub
fn
commit_url
(&
:
&
)
->
{
("{}/commit/{id}",
.
repo_url
())
}
/// The `.mailmap` on the default branch (empty when there is none).
pub
fn
mailmap
(&
)
->
<
>
{
let
=
.
.
.
.
and_then
(|
|
::
(&
.
,
));
let
Some
(
)
=
else
{
return
::
();
};
.
.
.
mailmap
(
,
||
{
::
::
(&
.
,
).
map
(|
|
::
(&
))
})
.
unwrap_or_default
()
}
pub
fn
not_found
(&
:
&
str
)
->
{
::
(
.
,
::
,
)
}
:
Option
<&
>
:
(
)
)
->
{
let
=
match
{
Some
(
)
=>
.
url
("tree",
&
.
,
b
""),
None
=>
("{}/tree",
.
repo_url
()),
let
(
,
)
=
match
{
Some
(
)
=>
(
.
url
("tree",
&
.
,
b
""),
.
url
("log",
&
.
,
b
""),
),
None
=>
(
("{}/tree",
.
repo_url
()),
("{}/log",
.
repo_url
()),
),
};
let
=
.
and_then
(|
|
{
let
=
.
refs
().
ok
()?;
:
.
.
.
clone
(),
:
.
repo_url
(),
,
,
:
("{}/refs",
.
repo_url
()),
:
.
as_str
(),
,
pub
enum
Active
{
,
,
,
,
}
match
{
::
=>
"summary",
::
=>
"tree",
::
=>
"log",
::
=>
"refs",
}
}
pub
:
pub
:
pub
:
pub
:
pub
:
/// `summary`, `tree` or `refs`.
/// `summary`, `tree`, `log` or `refs`.
pub
:
&
'static
str
pub
:
Option
<
>
}
pub
:
&
'static
str
pub
:
pub
:
Option
<
String
>
pub
:
Option
<
String
>
}
pub
struct
CloneUrl
{
:
"Commits",
:
.
unwrap_or
(
0
).
to_string
(),
:
None
,
:
.
map
(|
|
("{}/log",
.
repo_url
())),
},
{
:
"Branches",
:
.
.
to_string
(),
:
None
,
:
None
,
},
{
:
"Tags",
:
.
.
to_string
(),
:
None
,
:
None
,
},
];
if
let
Some
(
)
=
.
{
:
"Updated",
:
::
(
,
::
()),
:
Some
(
::
(
)),
:
None
,
});
}
if
let
Some
(
)
=
&
.
{
:
"Owner",
:
.
clone
(),
:
None
,
:
None
,
});
}
let
=
.
.
to_string
();
{
:
.
.
clone
(),
:
.
.
clone
(),
:
.
mailmap
()
.
resolve
(&
.
,
&
.
)
.
0
,
:
::
(
.
,
::
()),
:
::
(
.
),
:
.
url
("tree",
&
,
b
""),
:
.
commit_url
(&
.
),
:
short
(&
),
}
}
pub
:
Vec
<
>
pub
:
usize
pub
:
pub
:
pub
:
Option
<
>
}
,
:
.
len
(),
:
short
(&
.
to_string
()),
:
.
url
("log",
&
.
,
&
),
:
dir_readme
(
,
&
,
&
,
&
),
};
let
mut
=
render
(
::
,
&
);
//! Commit diffs: the cached, render-ready model behind the commit page,
//! and plain-text patches.
use
::
::
;
use
::
::
;
use
crate
::
::
;
use
crate
::
::
::{
,
,
,
,
,
};
use
crate
::
::
::{
,
};
use
crate
::
::{
,
,
};
use
crate
::
::
;
/// Knobs for [`build`]; everything that changes the output is part of the
/// cache key.
#[
(
,
,
,
,
,
)]
pub
struct
Options
{
pub
:
u32
pub
:
bool
/// Above this many files only the file list is shown.
pub
:
usize
/// Changed lines rendered for the whole commit, and per file.
pub
:
usize
pub
:
usize
/// Blobs larger than this are not diffed.
pub
:
u64
pub
:
u64
}
pub
struct
CommitDiff
{
pub
:
Vec
<
>
/// Totals over the files that were diffed.
pub
:
u64
pub
:
u64
/// More than `max_files` files: no per-file diffs at all.
pub
:
bool
}
impl
CommitDiff
{
pub
fn
weight
(&
)
->
usize
{
64
+
.
.
iter
().
map
(
::
).
::<
usize
>()
}
}
pub
struct
FileDiff
{
pub
:
/// Lines added and removed; `None` when the file wasn't diffed.
pub
:
Option
<(
u32
u32
)>
/// `(old, new)` modes when only the mode or type changed alongside.
pub
:
Option
<(&
'static
str
&
'static
str
)>
pub
:
}
impl
FileDiff
{
fn
weight
(&
)
->
usize
{
let
=
match
&
.
{
::
(
)
=>
.
iter
()
.
map
(|
|
.
.
len
()
+
.
.
iter
().
map
(|
|
.
.
len
()
+
32
).
::<
usize
>())
.
sum
(),
_
=>
0
,
};
128
+
.
.
path
().
len
()
*
2
+
}
}
pub
enum
Body
{
(
Vec
<
>),
/// Content unchanged (pure rename, mode change, whitespace-only with
/// `ignore_ws`).
,
,
{
:
Option
<
>,
:
Option
<
>,
},
/// Over a size limit: the blob, the per-file or the per-commit lines.
,
/// Not diffed because the commit has too many files.
,
}
pub
struct
Hunk
{
pub
:
pub
:
Vec
<
>
}
pub
struct
Line
{
pub
:
/// 1-based line numbers.
pub
:
Option
<
u32
>
pub
:
Option
<
u32
>
pub
:
}
impl
Line
{
pub
fn
sign
(&
)
->
&
'static
str
{
match
.
{
::
=>
" ",
::
=>
"+",
::
=>
"\u{2212}",
}
}
pub
fn
class
(&
)
->
&
'static
str
{
match
.
{
::
=>
"ctx",
::
=>
"add",
::
=>
"del",
}
}
}
enum
Content
{
(
String
),
,
,
,
}
impl
Content
{
fn
text
(&
)
->
&
str
{
match
{
::
(
)
=>
,
_
=>
"",
}
}
}
fn
load
(
:
&
:
Option
<&
>
:
Option
<
u64
>)
->
::
Result
<
>
{
let
Some
(
)
=
else
{
return
Ok
(
::
);
};
if
let
Some
(
)
=
&&
::
(
,
.
)?
>
{
return
Ok
(
::
);
}
let
=
::
(
,
.
)?;
if
[..
.
len
().
min
(
8000
)].
contains
(&
0
)
{
return
Ok
(
::
);
}
Ok
(
::
(
String
::
(&
).
into_owned
()))
}
fn
split
(
:
&
str
)
->
Vec
<&
str
>
{
.
split_inclusive
('\n').
collect
()
}
fn
mode_change
(
:
&
)
->
Option
<(&
'static
str
&
'static
str
)>
{
let
(
,
)
=
(
.
.
as_ref
()?,
.
.
as_ref
()?);
(
.
!=
.
).
then
(||
(
::
(
.
),
::
(
.
)))
}
fn
is_submodule
(
:
Option
<&
>)
->
bool
{
submodule
(
).
is_some
()
}
fn
submodule
(
:
Option
<&
>)
->
Option
<&
>
{
.
filter
(|
|
.
==
::
)
}
/// Diff every changed file, highlighting both sides as whole files.
pub
fn
build
(
:
&
:
&
:
&
:
&
)
->
::
Result
<
>
{
let
=
.
.
len
()
>
.
;
let
mut
=
{
:
Vec
::
(
.
.
len
()),
:
0
,
:
0
,
,
};
let
mut
=
.
;
for
in
&
.
{
let
mut
=
{
:
.
clone
(),
:
None
,
:
mode_change
(
),
:
::
,
};
if
{
.
.
push
(
);
continue
;
}
let
(
,
)
=
(
.
.
as_ref
(),
.
.
as_ref
());
if
is_submodule
(
)
||
is_submodule
(
)
{
.
=
::
{
:
submodule
(
).
map
(|
|
.
),
:
submodule
(
).
map
(|
|
.
),
};
.
.
push
(
);
continue
;
}
if
.
map
(|
|
.
)
==
.
map
(|
|
.
)
{
.
=
Some
((
0
,
0
));
.
=
::
;
.
.
push
(
);
continue
;
}
let
=
Some
(
.
);
let
(
,
)
=
(
load
(
,
,
)?,
load
(
,
,
)?);
.
=
match
(&
,
&
)
{
(
::
,
_)
|
(_,
::
)
=>
::
,
(
::
,
_)
|
(_,
::
)
=>
::
,
_
=>
{
let
(
,
)
=
(
.
text
(),
.
text
());
let
(
,
)
=
(
split
(
),
split
(
));
let
=
::
(&
,
&
,
.
,
.
);
.
=
Some
((
.
,
.
));
.
+=
u64
::
(
.
);
.
+=
u64
::
(
.
);
let
=
(
.
+
.
)
as
usize
;
if
.
.
is_empty
()
{
::
}
else
if
>
.
||
>
{
::
}
else
{
-=
;
let
html
=
|
:
Option
<&
>,
:
&
str
|
match
{
Some
(
)
=>
{
::
(
,
.
,
&
String
::
(&
.
),
,
.
,
)
.
0
}
None
=>
::
(
Vec
::
()),
};
let
=
html
(
,
);
let
=
html
(
,
);
let
get
=
|
:
&
,
:
Option
<
u32
>|
{
.
and_then
(|
|
.
get
(
as
usize
))
.
cloned
()
.
unwrap_or_default
()
};
::
(
.
.
iter
()
.
map
(|
|
{
:
.
header
(),
:
.
.
iter
()
.
map
(|
|
{
:
.
,
:
.
.
map
(|
|
+
1
),
:
.
.
map
(|
|
+
1
),
:
match
.
{
::
=>
get
(&
,
.
),
_
=>
get
(&
,
.
),
},
})
.
collect
(),
})
.
collect
(),
)
}
}
};
.
.
push
(
);
}
Ok
(
)
}
/// A `git format-patch`-style patch of `commit` against its first parent.
pub
fn
patch
(
:
&
:
&
:
&
)
->
::
Result
<
String
>
{
let
mut
=
String
::
();
let
mut
=
String
::
();
let
(
mut
,
mut
,
mut
)
=
(
0
,
0
,
0
);
let
=
.
.
iter
()
.
map
(|
|
display_path
(
).
chars
().
count
())
.
max
()
.
unwrap_or
(
0
);
let
mut
=
Vec
::
();
for
in
&
.
{
+=
1
;
let
(
,
,
)
=
file_patch
(
,
,
&
mut
)?;
+=
;
+=
;
.
push
((
display_path
(
),
,
,
));
}
let
=
.
iter
()
.
map
(|(
,
,
,
)|
+
)
.
max
()
.
unwrap_or
(
0
)
.
max
(
1
);
for
(
,
,
,
)
in
&
{
let
_
=
(
" {path:<width$} | ");
match
{
Some
(
)
=>
{
let
_
=
(
"{sizes}");
}
None
=>
{
// Scale the bar like git (to at most 50 columns).
let
scale
=
|
:
u32
|
->
usize
{
if
<=
50
{
as
usize
}
else
{
((
as
u64
*
50
).
div_ceil
(
as
u64
))
as
usize
}
};
let
_
=
(
"{} {}{}",
+
,
"+".
repeat
(
scale
(*
)),
"-".
repeat
(
scale
(*
))
);
}
}
}
let
plural
=
|
:
u32
,
:
&
str
,
:
&
str
|
("{n} {}",
if
==
1
{
}
else
{
});
let
mut
=
(" {} changed",
plural
(
,
"file",
"files"));
if
>
0
||
==
0
{
let
_
=
(
", {}(+)",
plural
(
,
"insertion",
"insertions"));
}
if
>
0
{
let
_
=
(
", {}(-)",
plural
(
,
"deletion",
"deletions"));
}
let
(
,
)
=
.
.
split_once
('\n')
.
unwrap_or
((
.
.
as_str
(),
""));
let
mut
=
String
::
();
let
_
=
(
"From {} Mon Sep 17 00:00:00 2001",
.
.
);
let
_
=
(
"From: {} <{}>",
.
.
,
.
.
);
let
_
=
(
"Date: {}",
crate
::
::
::
(
.
.
,
.
.
)
);
let
_
=
(
"Subject: [PATCH] {}",
.
trim
());
.
push
('\n');
let
=
.
trim
();
if
!
.
is_empty
()
{
.
push_str
(
);
.
push
('\n');
}
.
push_str
("---\n");
.
push_str
(&
);
.
push_str
(&
);
.
push_str
("\n\n");
.
push_str
(&
);
let
_
=
(
"-- \nferrenium {}\n\n",
("CARGO_PKG_VERSION"));
Ok
(
)
}
fn
display_path
(
:
&
)
->
{
let
=
String
::
(
.
path
()).
into_owned
();
match
(&
.
,
&
.
)
{
(
::
|
::
,
Some
(
))
=>
{
("{} => {new}",
String
::
(&
.
))
}
_
=>
,
}
}
fn
short
(
:
&
)
->
{
.
to_hex_with_len
(
7
).
to_string
()
}
/// Append one file's `diff --git` section; returns lines added, removed,
/// and the stat text for binary files.
fn
file_patch
(
:
&
:
&
:
&
mut
)
->
::
Result
<(
u32
u32
Option
<
String
>)>
{
let
path
=
|
:
Option
<&
>|
.
map
(|
|
String
::
(&
.
).
into_owned
());
let
(
,
)
=
(
.
.
as_ref
(),
.
.
as_ref
());
let
=
path
(
).
unwrap_or_else
(||
path
(
).
unwrap_or_default
());
let
=
path
(
).
unwrap_or_else
(||
.
clone
());
let
_
=
(
"diff --git a/{a} b/{b}");
match
(
,
)
{
(
None
,
Some
(
))
=>
{
let
_
=
(
"new file mode {}",
::
(
.
));
}
(
Some
(
),
None
)
=>
{
let
_
=
(
"deleted file mode {}",
::
(
.
));
}
(
Some
(
),
Some
(
))
=>
{
if
.
!=
.
{
let
_
=
(
"old mode {}",
::
(
.
));
let
_
=
(
"new mode {}",
::
(
.
));
}
if
let
(
Some
(
),
true
)
=
(
.
,
(
.
,
::
|
::
),
)
{
let
=
if
.
==
::
{
"copy"
}
else
{
"rename"
};
let
_
=
(
"similarity index {similarity}%");
let
_
=
(
"{verb} from {a}");
let
_
=
(
"{verb} to {b}");
}
}
(
None
,
None
)
=>
{}
}
let
=
.
map_or_else
(||
"0000000".
to_string
(),
|
|
short
(&
.
));
let
=
.
map_or_else
(||
"0000000".
to_string
(),
|
|
short
(&
.
));
if
.
map
(|
|
.
)
==
.
map
(|
|
.
)
{
return
Ok
((
0
,
0
,
None
));
}
match
(
,
)
{
(
Some
(
),
Some
(
))
if
.
==
.
=>
{
let
_
=
(
"index {old_id}..{new_id} {}",
::
(
.
));
}
_
=>
{
let
_
=
(
"index {old_id}..{new_id}");
}
}
let
=
.
map_or_else
(||
"/dev/null".
to_string
(),
|
|
("a/{a}"));
let
=
.
map_or_else
(||
"/dev/null".
to_string
(),
|
|
("b/{b}"));
if
is_submodule
(
)
||
is_submodule
(
)
{
let
_
=
(
"--- {minus}\n+++ {plus}");
let
(
,
)
=
(
submodule
(
),
submodule
(
));
let
_
=
(
"@@ -{} +{} @@",
if
.
is_some
()
{
"1"
}
else
{
"0,0"
},
if
.
is_some
()
{
"1"
}
else
{
"0,0"
}
);
if
let
Some
(
)
=
{
let
_
=
(
"-Subproject commit {}",
.
);
}
if
let
Some
(
)
=
{
let
_
=
(
"+Subproject commit {}",
.
);
}
return
Ok
((
u32
::
(
.
is_some
()),
u32
::
(
.
is_some
()),
None
));
}
let
(
,
)
=
(
load
(
,
,
None
)?,
load
(
,
,
None
)?);
if
(
,
::
)
||
(
,
::
)
{
let
_
=
(
"Binary files {minus} and {plus} differ");
let
size
=
|
:
Option
<&
>|
->
::
Result
<
u64
>
{
.
map_or
(
Ok
(
0
),
|
|
::
(
,
.
))
};
let
=
("Bin {} -> {} bytes",
size
(
)?,
size
(
)?);
return
Ok
((
0
,
0
,
Some
(
)));
}
let
(
,
)
=
(
split
(
.
text
()),
split
(
.
text
()));
let
=
::
(&
,
&
,
3
,
false
);
// Like git, an empty file added or removed has no `---`/`+++` lines.
if
.
.
is_empty
()
{
return
Ok
((
0
,
0
,
None
));
}
let
_
=
(
"--- {minus}\n+++ {plus}");
for
in
&
.
{
.
push_str
(&
.
header
());
.
push
('\n');
for
in
&
.
{
let
(
,
)
=
match
.
{
::
=>
(' ',
[
.
.
unwrap_or
(
0
)
as
usize
]),
::
=>
('-',
[
.
.
unwrap_or
(
0
)
as
usize
]),
::
=>
('+',
[
.
.
unwrap_or
(
0
)
as
usize
]),
};
.
push
(
);
.
push_str
(
);
if
!
.
ends_with
('\n')
{
.
push_str
("\n\\ No newline at end of file\n");
}
}
}
Ok
((
.
,
.
,
None
))
}
//! `hl-k` keywords/storage, `hl-d` names/numbers/constants, `hl-s`
//! strings/punctuation/operators, `hl-c` comments, `hl-x` invalid.
use
::
::
;
use
::
::{
,
};
use
::
::{
,
,
,
,
};
use
::
::
;
use
super
::
;
use
crate
::
::{
,
};
use
crate
::
::
;
static
:
<
>
=
::
();
}
/// Lines longer than this (minified code) make syntect crawl; such files
/// are shown plain.
const
:
usize
=
5000
;
/// HTML lines of blob `oid` (the file at `path`, contents `text`),
/// highlighted when a syntax is detected, the blob is at most `max_bytes`
/// and no line is minified-long, plain otherwise. Highlighted lines are cached by blob and
/// shared by every view of it. Also returns the detected language.
pub
fn
cached_lines
(
:
&
:
:
&
str
:
&
str
:
u64
)
->
(
<
Vec
<
String
>>
Option
<&
'static
str
>)
{
let
=
.
lines
().
next
().
unwrap_or_default
();
let
=
detect
(
,
);
let
=
.
map
(|
|
.
.
as_str
());
let
=
match
{
Some
(
)
if
.
len
()
as
u64
<=
&&
!
.
lines
().
any
(|
|
.
len
()
>
)
=>
{
let
=
::
{
:
,
:
.
.
clone
(),
};
.
lines
(
,
||
{
Ok
::<_
::
::
>(
lines
(
,
))
})
.
unwrap_or_else
(|
|
match
{})
}
_
=>
::
(
plain_lines
(
)),
};
(
,
)
}
/// Escaped lines without highlighting.
pub
fn
plain_lines
(
:
&
str
)
->
Vec
<
String
>
{
::
(
).
map
(
).
collect
()
//! Presentation helpers shared by handlers and templates.
pub
mod
diff
;
pub
mod
highlight
;
pub
mod
markdown
;
pub
mod
time
;
.
unwrap_or_default
()
}
fn
zoned
(
:
i64
:
i32
)
->
Option
<
::
>
{
let
=
::
::
::
(
).
unwrap_or
(
::
::
::
);
let
=
::
::
(
).
ok
()?;
Some
(
.
to_zoned
(
::
::
::
(
)))
}
/// `Thu, 5 Nov 2026 14:03:00 +0100` in the recorded offset (patch headers).
pub
fn
rfc2822
(
:
i64
:
i32
)
->
{
zoned
(
,
)
.
map
(|
|
.
strftime
("%a, %-d %b %Y %H:%M:%S %z").
to_string
())
.
unwrap_or_default
()
}
/// `2026-11-05 14:03 +0100` in the recorded offset.
pub
fn
local
(
:
i64
:
i32
)
->
{
zoned
(
,
)
.
map
(|
|
.
strftime
("%Y-%m-%d %H:%M %z").
to_string
())
.
unwrap_or_default
()
}
/// `Nov 5, 2026` (UTC), for grouping commits by day.
pub
fn
day
(
:
i64
)
->
{
::
::
(
)
.
map
(|
|
.
strftime
("%b %-d, %Y").
to_string
())
.
unwrap_or_default
()
}
#[
(
)]
mod
tests
{
use
super
::*;
#[
]
fn
iso_format
()
{
(
iso
(
0
),
"1970-01-01T00:00:00Z");
(
rfc2822
(
0
,
3600
),
"Thu, 1 Jan 1970 01:00:00 +0100");
(
local
(
0
,
-
7200
),
"1969-12-31 22:00 -0200");
(
day
(
86400
*
5
),
"Jan 6, 1970");
}
}
</
nav
>
<
a
="btn-ghost"
="{{ raw_url }}">
</
a
>
<
a
="btn-ghost"
="{{ log_url }}">
</
a
>
<
a
="btn-ghost"
="{{ download_url }}">
</
a
>
</
div
>
</
div
>
<
section
="commit-head">
<
h2
="commit-subject">
</
h2
>
<
pre
="commit-body">
</
pre
>
</
section
>
<
div
="commit-grid">
<
dl
="stats commit-meta">
<
div
="stat">
<
dt
="label">
</
dt
>
<
dd
>
<
span
="{{ title }}">
</
span
>
<
a
="sha"
="{{ url }}">
</
a
>
</
dd
>
</
div
>
</
dl
>
<
div
="diffstat-hero">
<
p
="diffstat-num">
</
p
>
<
p
="label dim">
</
p
>
<
p
="diffstat-num"><
span
="add">
</
span
>
<
span
="del">&
;
</
span
></
p
>
<
p
="label dim">
</
p
>
</
div
>
</
div
>
<
div
="commit-actions">
<
div
="blob-actions">
<
a
="btn-ghost"
="{{ tree_url }}">
</
a
>
<
a
="btn-ghost"
="{{ patch_url }}">
</
a
>
</
div
>
<
div
="blob-actions">
<
nav
="segmented segmented-sm"
="Whitespace">
<
a
="{{ t.url }}"
="true"
>
</
a
>
</
nav
>
<
span
="label dim context-ctl">
<
a
="{{ url }}"
="Less context">&
;</
a
>
<
span
>&
;</
span
>
<
span
>
</
span
>
<
a
="{{ url }}"
="More context">
</
a
>
<
span
>
</
span
>
</
span
>
</
div
>
</
div
>
<
p
="status blob-note">
</
p
>
<
ol
="file-list">
<
li
="file-row">
<
span
="file-status"
="{{ row.status }}">
</
span
>
<
a
="file-path"
="#{{ row.anchor }}">
<
span
="dim">
&
;
</
span
>
</
a
>
<
span
="file-counts"><
span
="add">
</
span
>
<
span
="del">&
;
</
span
></
span
>
<
span
="file-counts"></
span
>
<
span
="blocks"
="true">
<
i
="{{ b }}"></
i
>
</
span
>
</
li
>
</
ol
>
<
p
="status blob-note">
<
a
="{{ patch_url }}">
</
a
></
p
>
<
section
="diff-file"
="{{ row.anchor }}">
<
header
="diff-head">
<
span
="file-status"
="{{ row.status }}">
</
span
>
<
span
="diff-path">
<
span
="dim">
&
;
</
span
>
</
span
>
<
a
="label diff-view"
="{{ url }}">
</
a
>
</
header
>
<
p
="label dim diff-note">
&
;
</
p
>
<
div
="code-wrap">
<
table
="code diff">
<
tbody
>
<
tr
="hunk"><
td
="ln"
="2"></
td
><
td
="lc"
="2">
</
td
></
tr
>
<
tr
="{{ line.class() }}"><
td
="ln">
</
td
><
td
="ln">
</
td
><
td
="sign">
</
td
><
td
="lc">
</
td
></
tr
>
</
tbody
>
</
table
>
</
div
>
<
p
="status diff-note">
</
p
>
<
p
="status diff-note">
</
p
>
<
p
="diff-note"><
span
="label">
</
span
>
<
span
="mono">
&
;
&
;
&
;
</
span
></
p
>
<
p
="status diff-note">
<
a
="{{ url }}">
</
a
>
</
p
>
</
section
>
<
form
="log-tools"
="get"
="{{ action }}"
="search">
<
label
="field">
<
span
="label">
</
span
>
<
input
="search"
="q"
="{{ q }}"
="off"
="false"
="Message, author or email">
</
label
>
</
form
>
<
p
="status log-note">
</
p
>
<
section
="log-day">
<
h2
="label section-label">
</
h2
>
<
ol
="log">
<
li
="log-row">
<
div
="log-main">
<
a
="log-subject"
="{{ row.url }}">
</
a
>
<
p
="log-meta">
<
time
="{{ row.iso }}"
="{{ row.iso }}">
</
time
></
p
>
</
div
>
<
a
="sha log-sha"
="{{ row.url }}">
</
a
>
</
li
>
</
ol
>
</
section
>
<
p
="status log-note">
</
p
>
<
nav
="pager"
="Pages">
<
a
="label"
="{{ url }}"
="prev">&
;
</
a
>
<
span
="label dim">&
;
</
span
>
<
a
="label"
="{{ url }}"
="next">
&
;</
a
>
<
span
="label dim">
&
;</
span
>
</
nav
>
<
nav
="bracket-nav"
="Repository">
<
a
="label{% if nav.active == "
"
"
="{{ nav.url }}"
=
"
"
="page"
>
</
a
>
<
a
="label{% if nav.active == "
"
"
="{{ nav.tree_url }}"
=
"
"
="page"
>
</
a
>
<
a
="label{% if nav.active == "
"
"
="{{ nav.log_url }}"
=
"
"
="page"
>
</
a
>
<
a
="label{% if nav.active == "
"
"
="{{ nav.refs_url }}"
=
"
"
="page"
>
</
a
>
</
nav
>
<
div
="stat">
<
dt
="label">
</
dt
>
<
dd
>
<
time
="{{ title }}"
="{{ title }}">
</
time
>
</
dd
>
<
dd
>
<
a
="{{ url }}">
</
a
>
<
time
="{{ title }}"
="{{ title }}">
</
time
>
</
dd
>
</
div
>
</
dl
>
<
p
="label dim tree-foot">
</
p
>
<
p
="label dim tree-foot">
<
a
="{{ log_url }}">
</
a
></
p
>
(
.
contains
(
r
#"src="/rich/raw/main/img/logo.png""#));
(!
.
contains
("alert(1)"));
// Rail.
(
.
contains
("<dd>2</dd>"),
"commit count: {html}");
(
.
contains
(
r
#"<dd><a href="/rich/log">2</a></dd>"#),
"commit count: {html}"
);
(
.
contains
("https://git.example.com/rich"));
(
.
contains
("git@example.com:rich"));
(
.
contains
(">HTTPS<")
&&
.
contains
(">SSH<"));
(
.
contains
("add everything"));
(
.
contains
(&
(
r
#"href="/rich/tree/{}""#,
.
.
)));
(
.
contains
(&
(
r
#"href="/rich/commit/{}""#,
.
.
)));
// Nav + picker.
(
.
contains
(
r
#"class="label active" href="/rich" aria-current="page">Summary"#));
(
.
contains
(
r
#"href="/rich/tree/feature/x""#));
("/rich/tree/nope",
"UNKNOWN REVISION"),
("/rich/tree/main/nope",
"PATH NOT FOUND IN main"),
("/rich/blob/main/vendor/lib",
"PATH IS A SUBMODULE"),
("/rich/log",
"PAGE NOT FOUND"),
("/rich/blame-nope",
"PAGE NOT FOUND"),
("/rich/tree/main/../x",
"PAGE NOT FOUND"),
("/-/nope",
"PAGE NOT FOUND"),
]
{
//! History pages (log, commit, patch) checked against the git CLI.
mod
common
;
use
::
::{
,
};
use
::
::{
,
};
use
::
::{
,
,
,
};
use
::{
,
,
};
use
::
::
;
use
::
;
use
::
::{
,
};
use
::
;
/// Commit ids in [`history_repo`], oldest first.
struct
History
{
:
:
:
:
:
:
:
:
}
fn
lines
(
:
usize
)
->
{
(
1
..=
).
map
(|
|
("line {i}\n")).
collect
()
}
/// Root commit; a tweak; a rename with an edit; binary + mode change +
/// deletion; a merge of a side branch; a whitespace-only change; a
/// `.mailmap`. Authors vary so mailmap and grep have something to do.
fn
history_repo
(
:
&
)
->
{
let
=
bare
(
,
"hist.git",
&[]);
let
=
::
(&
);
let
=
.
path
();
let
write
=
|
:
&
str
,
:
&
u8
|
{
let
=
.
join
(
);
::
::
(
.
parent
().
unwrap
()).
unwrap
();
::
::
(
,
).
unwrap
();
};
let
commit
=
|
:
&
&
str
|
{
git
(
,
&["add",
"-A"]);
let
mut
=
["commit",
"-q"];
.
extend_from_slice
(
);
git
(
,
&
);
git
(
,
&["rev-parse",
"HEAD"])
};
write
("a.txt",
lines
(
20
).
as_bytes
());
write
("src/lib.rs",
b
"pub fn one() -> u32 {\n    1\n}\n");
write
("gone.txt",
b
"bye\n");
write
("run.sh",
b
"#!/bin/sh\necho hi\n");
let
=
commit
(&["-m",
"Initial import"]);
write
(
"a.txt",
lines
(
20
).
replace
("line 5\n",
"line five\n").
as_bytes
(),
);
let
=
commit
(&[
"-m",
"Tweak a.txt\n\nThe body mentions a Needle.",
"--author",
"Bob <bob@old.example>",
]);
git
(
,
&["mv",
"a.txt",
"b.txt"]);
write
(
"b.txt",
lines
(
20
)
.
replace
("line 5\n",
"line five\n")
.
replace
("line 20\n",
"line twenty\n")
.
as_bytes
(),
);
let
=
commit
(&["-m",
"Rename a to b"]);
write
("blob.bin",
b
"\0\x01\x02\x03binary");
::
::
(
.
join
("gone.txt")).
unwrap
();
use
::
::
::
::
;
::
::
(
.
join
("run.sh"),
::
::
::
(
0o755
)).
unwrap
();
let
=
commit
(&["-m",
"Binary, mode and deletion"]);
git
(
,
&["checkout",
"-q",
"-b",
"side"]);
write
("side.txt",
b
"from the side\n");
commit
(&["-m",
"Side work"]);
git
(
,
&["checkout",
"-q",
"main"]);
write
(
"src/lib.rs",
b
"pub fn one() -> u32 {\n    1\n}\n\npub fn two() -> u32 {\n    2\n}\n",
);
commit
(&["-m",
"Add two"]);
git
(
,
&["merge",
"-q",
"--no-ff",
"-m",
"Merge side",
"side"]);
let
=
git
(
,
&["rev-parse",
"HEAD"]);
write
(
"src/lib.rs",
b
"pub fn one() -> u32 {\n\t1\n}\n\npub fn two() -> u32 {\n    2\n}\n",
);
let
=
commit
(&["-m",
"Tabs"]);
write
(
".mailmap",
b
"Ada Lovelace <ada@example.com>\nRobert <bob@new.example> <bob@old.example>\n",
);
let
=
commit
(&["-m",
"Add mailmap"]);
git
(
,
&["push",
"-q",
"origin",
"main",
"side"]);
{
,
:
,
,
,
,
,
,
,
}
}
struct
Site
{
:
::
:
::
:
}
fn
site
(
:
&
str
)
->
{
let
=
::
().
unwrap
();
let
=
history_repo
(
.
path
());
let
=
(
"[repos]\nscan_path = {:?}\n[watch]\nenabled = false\n{extra}",
.
path
().
to_str
().
unwrap
()
);
let
mut
=
::
(&
).
expect
("parse");
.
finish
().
expect
("valid");
let
=
::
(
,
::
());
let
=
.
.
load_full
();
.
.
full_scan
(&
);
{
:
::
(
),
,
:
,
}
}
struct
Res
{
:
:
:
}
fn
fetch
(
:
&
::
:
&
str
:
Option
<&
str
>)
->
{
let
mut
=
::
(
);
if
let
Some
(
)
=
{
=
.
header
(
::
,
);
}
let
=
.
clone
()
.
oneshot
(
.
body
(
::
()).
unwrap
())
.
.
unwrap
();
let
=
.
status
();
let
=
.
headers
().
clone
();
let
=
to_bytes
(
.
into_body
(),
usize
::
).
.
unwrap
();
{
,
,
:
String
::
(&
).
into_owned
(),
}
}
fn
ok
(
:
&
::
:
&
str
)
->
{
let
=
fetch
(
,
,
None
).
;
(
.
,
::
,
"{uri}: {}",
.
);
(!
.
.
contains
("style=\""),
"style attribute in {uri}");
.
}
/// Commit ids linked from log rows, in page order.
fn
log_ids
(
:
&
str
)
->
Vec
<
String
>
{
.
split
(
r
#"class="sha log-sha" href="/hist/commit/"#)
.
skip
(
1
)
.
map
(|
|
[..
40
].
to_string
())
.
collect
()
}
fn
next_link
(
:
&
str
:
&
str
)
->
Option
<
String
>
{
let
=
.
find
(&
(
r
#"" rel="{rel}""#))?;
let
=
[..
].
rfind
("href=\"")?
+
6
;
Some
(
[
..
].
replace
("&#38;",
"&").
replace
("&amp;",
"&"))
}
/// Follow `Older` links from `uri` and collect every commit id.
fn
all_pages
(
:
&
::
:
&
str
)
->
(
Vec
<
String
>
usize
)
{
let
(
mut
,
mut
,
mut
)
=
(
Vec
::
(),
0
,
.
to_string
());
loop
{
let
=
ok
(
,
&
).
;
+=
1
;
.
extend
(
log_ids
(&
));
match
next_link
(&
,
"next")
{
Some
(
)
=>
=
,
None
=>
return
(
,
),
}
}
}
fn
git_log
(
:
&
:
&
&
str
)
->
Vec
<
String
>
{
let
mut
=
["log",
"--format=%H"];
.
extend_from_slice
(
);
git
(
,
&
).
lines
().
map
(
str
::
).
collect
()
}
#[
]
fn
log_pages_match_git
()
{
let
=
site
("[ui]\nlog_page = 3\n");
let
(
,
)
=
all_pages
(&
.
,
"/hist/log").
;
(
,
git_log
(&
.
.
,
&["main"]));
(
,
.
len
().
div_ceil
(
3
));
// Second page: "newer" goes back to the first.
let
=
ok
(&
.
,
"/hist/log/main").
;
let
=
next_link
(&
,
"next").
unwrap
();
let
=
ok
(&
.
,
&
).
;
(
next_link
(&
,
"prev").
unwrap
(),
"/hist/log/main");
let
=
ok
(&
.
,
&
next_link
(&
,
"next").
unwrap
()).
;
(
next_link
(&
,
"prev").
unwrap
(),
);
// Day groups and nav.
(
.
contains
(
r
#"class="label section-label""#));
(
.
contains
(
r
#"class="label active" href="/hist/log/main" aria-current="page">Log<"#),
"{first}"
);
// Mailmap applies to authors.
(
.
contains
("Ada Lovelace"),
"{first}");
(!
.
contains
(">Ada ·"));
}
#[
]
fn
path_filtered_log_matches_git
()
{
let
=
site
("[ui]\nlog_page = 2\n");
for
in
[
"src/lib.rs",
"src",
"b.txt",
"a.txt",
"gone.txt",
"side.txt",
"run.sh",
]
{
let
(
,
_)
=
all_pages
(&
.
,
&
("/hist/log/main/{path}")).
;
(
,
git_log
(&
.
.
,
&["main",
"--",
]),
"{path}");
}
let
=
ok
(&
.
,
"/hist/log/main/src/lib.rs").
;
(
.
contains
(
r
#"<span class="crumb-here">lib.rs</span>"#),
"{html}"
);
let
=
ok
(&
.
,
"/hist/log/main/nope").
;
(
.
contains
("[No commits]"));
}
#[
]
fn
grep_filters_message_and_author
()
{
let
=
site
("");
let
=
ok
(&
.
,
"/hist/log?q=needle").
;
(
log_ids
(&
),
[
.
.
.
clone
()]);
(
.
contains
(
r
#"value="needle""#));
let
=
ok
(&
.
,
"/hist/log/main?q=BOB%40OLD").
;
(
log_ids
(&
),
[
.
.
.
clone
()]);
let
=
ok
(&
.
,
"/hist/log?q=zzz-nothing").
;
(
.
contains
("[No commits]"));
// The scan limit stops a search and offers to continue.
let
=
site
("[limits]\nlog_scan = 2\n");
let
=
ok
(&
.
,
"/hist/log?q=initial").
;
(
log_ids
(&
).
is_empty
());
(
.
contains
("[No matches in 2 commits]"),
"{html}");
let
(
,
_)
=
all_pages
(&
.
,
"/hist/log?q=initial").
;
(
,
[
.
.
.
clone
()]);
}
#[
]
fn
bad_cursors_are_not_found
()
{
let
=
site
("");
let
=
fetch
(&
.
,
"/hist/log?after=xyz",
None
).
;
(
.
,
::
);
let
=
fetch
(&
.
,
&
("/hist/log?after={}",
"0".
repeat
(
40
)),
None
).
;
(
.
,
::
);
(
.
.
contains
("COMMIT NOT IN THIS HISTORY"));
}
/// `+added −removed` per file from `git diff --numstat`, as the commit page
/// shows them.
fn
numstat
(
:
&
:
&
str
)
->
Vec
<(
)>
{
let
=
git
(
,
&["diff",
"--numstat",
"-M",
&
("{commit}^"),
],
);
.
lines
()
.
map
(|
|
{
let
mut
=
.
split
('\t');
let
(
,
)
=
(
.
next
().
unwrap
(),
.
next
().
unwrap
());
(
.
to_string
(),
.
to_string
())
})
.
collect
()
}
#[
]
fn
commit_page_shows_metadata_and_diffstat
()
{
let
=
site
("");
let
=
ok
(&
.
,
&
("/hist/commit/{}",
.
.
)).
;
(
.
contains
(
r
#"<h2 class="commit-subject">Tweak a.txt</h2>"#),
"{html}"
);
(
.
contains
("The body mentions a Needle."));
// Mailmap: Bob's old address maps to Robert.
(
.
contains
(
r
#"title="bob@new.example">Robert<"#),
"{html}"
);
(
.
contains
(&
(
r
#"href="/hist/commit/{}""#,
.
.
)));
(
.
contains
(
r
#"<span class="add">+1</span> <span class="del">&minus;1</span>"#));
(
.
contains
(
r
#"<tr class="del"><td class="ln">5</td><td class="ln"></td><td class="sign">"#
)
);
(
.
contains
(
r
#"<tr class="add"><td class="ln"></td><td class="ln">5</td><td class="sign">+</td><td class="lc">line five</td>"#),
"{html}");
(
.
contains
("@@ -2,7 +2,7 @@ line 1"));
// Rename with an edit: stats match git, the old name is shown.
let
=
ok
(&
.
,
&
("/hist/commit/{}",
.
.
)).
;
let
=
numstat
(&
.
.
,
&
.
.
);
(
,
[("1".
into
(),
"1".
into
())]);
(
.
contains
(
r
#"title="Renamed">R<"#));
(
.
contains
("a.txt &rarr; </span>b.txt"),
"{html}");
// Binary, mode change and deletion.
let
=
ok
(&
.
,
&
("/hist/commit/{}",
.
.
)).
;
(
.
contains
("[Binary file]"));
(
.
contains
("Mode 100644 &rarr; 100755"),
"{html}");
(
.
contains
(
r
#"title="Deleted">D<"#));
// A deleted file links to its last version.
let
=
git
(&
.
.
,
&["rev-parse",
&
("{}^",
.
.
)]);
(
.
contains
(&
(
r
#"href="/hist/blob/{parent}/gone.txt""#)));
// Root commit: everything added.
let
=
ok
(&
.
,
&
("/hist/commit/{}",
.
.
)).
;
(
.
contains
("<dd>None</dd>"),
"{html}");
(
.
contains
("4 files changed"));
// Merge: diffed against the first parent, both parents listed.
let
=
ok
(&
.
,
&
("/hist/commit/{}",
.
.
)).
;
(
.
contains
(">Parents<"));
(
.
contains
("side.txt"));
(!
.
contains
("pub fn two"),
"first-parent diff: {html}");
}
#[
]
fn
whitespace_and_context_options
()
{
let
=
site
("");
let
=
("/hist/commit/{}",
.
.
);
let
=
ok
(&
.
,
&
).
;
(
.
contains
(
r
#"<span class="add">+1</span> <span class="del">&minus;1</span>"#));
let
=
ok
(&
.
,
&
("{url}?ws=ignore")).
;
(
.
contains
("[No content changes]"),
"{html}");
(
.
contains
(&
(
r
#"href="{url}?ws=ignore" aria-current="true">Ignore<"#
)));
let
=
ok
(&
.
,
&
("{url}?context=0")).
;
(
.
contains
("@@ -2 +2 @@ pub fn one"),
"{html}");
(
.
contains
("Context 0"));
let
=
ok
(&
.
,
&
("{url}?context=999")).
;
(
.
contains
("Context 50"));
}
#[
]
fn
patch_matches_git
()
{
let
=
site
("");
for
in
[
&
.
.
,
&
.
.
,
&
.
.
,
&
.
.
,
&
.
.
,
&
.
.
,
]
{
let
=
fetch
(&
.
,
&
("/hist/commit/{commit}.patch"),
None
).
;
(
.
,
::
);
(
.
[
::
],
"text/plain; charset=utf-8"
);
(
.
[
::
]
.
to_str
()
.
unwrap
()
.
contains
("sandbox")
);
(
.
.
starts_with
(&
("From {commit} Mon Sep 17 00:00:00 2001\n"))
);
let
:
String
=
.
.
split_inclusive
('\n')
.
skip_while
(|
|
!
.
starts_with
("diff --git"))
.
take_while
(|
|
*
!=
"-- \n")
.
collect
();
let
=
if
==
&
.
.
{
"4b825dc642cb6eb9a060e54bf8d69288fbee4904".
to_string
()
}
else
{
("{commit}^")
};
let
=
::
::
::
("git")
.
args
([
"-c",
"core.abbrev=7",
"diff",
"--no-color",
"-M",
"--abbrev=7",
&
,
,
])
.
current_dir
(&
.
.
)
.
env
("GIT_CONFIG_NOSYSTEM",
"1")
.
env
("GIT_CONFIG_GLOBAL",
"/dev/null")
.
output
()
.
unwrap
()
.
;
(
,
String
::
(
).
unwrap
(),
"{commit}");
}
let
=
fetch
(&
.
,
&
("/hist/commit/{}.patch",
.
.
),
None
).
;
(
.
.
contains
("From: Bob <bob@old.example>\n"),
"patches keep the recorded author"
);
(
.
.
contains
("Subject: [PATCH] Tweak a.txt\n\nThe body mentions a Needle.\n---\n")
);
(
.
.
contains
(" 1 file changed, 1 insertion(+), 1 deletion(-)\n")
);
}
#[
]
fn
diff_limits
()
{
let
=
site
("[limits]\ndiff_file_lines = 1\n");
let
=
ok
(&
.
,
&
("/hist/commit/{}",
.
.
)).
;
(
.
contains
("[Diff too large]"),
"{html}");
(
.
contains
(
r
#"<span class="add">+1</span>"#),
"stats still shown"
);
let
=
site
("[limits]\ndiff_files = 2\n");
let
=
ok
(&
.
,
&
("/hist/commit/{}",
.
.
)).
;
(
.
contains
("[Diff too large: 4 files]"),
"{html}");
(
.
contains
("src/lib.rs"));
// The per-commit line budget.
let
=
site
("[limits]\ndiff_lines = 1\n");
let
=
ok
(&
.
,
&
("/hist/commit/{}",
.
.
)).
;
(
.
contains
("[Diff too large]"),
"{html}");
}
#[
]
fn
caching_and_resolution
()
{
let
=
site
("");
// Full ids are immutable; refs revalidate.
let
=
fetch
(&
.
,
&
("/hist/commit/{}",
.
.
),
None
).
;
(
.
[
::
],
"public, max-age=86400");
let
=
.
[
::
].
to_str
().
unwrap
().
to_string
();
let
=
fetch
(&
.
,
&
("/hist/commit/{}",
.
.
),
Some
(&
)).
;
(
.
,
::
);
let
=
fetch
(&
.
,
"/hist/log/main",
None
).
;
(
.
[
::
],
"no-cache");
let
=
.
[
::
].
to_str
().
unwrap
().
to_string
();
let
=
fetch
(&
.
,
"/hist/log/main",
Some
(&
)).
;
(
.
,
::
);
// A different query is a different page.
let
=
fetch
(&
.
,
"/hist/log/main?q=x",
Some
(&
)).
;
(
.
,
::
);
// Commits by branch name and short id.
let
=
ok
(&
.
,
"/hist/commit/main").
;
(
.
contains
("Add mailmap"));
let
=
ok
(&
.
,
&
("/hist/commit/{}",
&
.
.
[..
8
])).
;
(
.
contains
("Tweak a.txt"));
let
=
fetch
(&
.
,
"/hist/commit/nope",
None
).
;
(
.
,
::
);
let
=
fetch
(&
.
,
"/hist/commit",
None
).
;
(
.
,
::
);
// Links into history from other pages.
let
=
ok
(&
.
,
"/hist").
;
(
.
contains
(
r
#"<a href="/hist/log">"#),
"{html}");
(
.
contains
(&
(
r
#"href="/hist/commit/{}""#,
.
.
)));
let
=
ok
(&
.
,
"/hist/blob/main/src/lib.rs").
;
(
.
contains
(
r
#"href="/hist/log/main/src/lib.rs">History<"#));
let
=
ok
(&
.
,
"/hist/tree/main/src").
;
(
.
contains
(
r
#"href="/hist/log/main/src">History<"#));
}
		@@ -554,6 +554,319 @@ html:not(.js) .copy-status {
554	554		white-space: nowrap;
555	555		}
556	556
	557	+	/* ---- Log ------------------------------------------------------------------ */
	558	+
	559	+	.log-tools {
	560	+	margin-top: var(--space-lg);
	561	+	max-width: 420px;
	562	+	}
	563	+
	564	+	.log-day {
	565	+	margin-top: var(--space-xl);
	566	+	}
	567	+
	568	+	.log {
	569	+	list-style: none;
	570	+	border-top: 1px solid var(--border);
	571	+	}
	572	+
	573	+	.log-row {
	574	+	display: flex;
	575	+	align-items: baseline;
	576	+	justify-content: space-between;
	577	+	gap: var(--space-md);
	578	+	padding-block: 12px;
	579	+	border-bottom: 1px solid var(--border);
	580	+	}
	581	+
	582	+	.log-main {
	583	+	min-width: 0;
	584	+	}
	585	+
	586	+	.log-subject {
	587	+	color: var(--text-primary);
	588	+	overflow-wrap: anywhere;
	589	+	}
	590	+
	591	+	.log-meta {
	592	+	margin-top: var(--space-2xs);
	593	+	font-family: var(--font-mono);
	594	+	font-size: var(--caption);
	595	+	color: var(--text-secondary);
	596	+	}
	597	+
	598	+	.log-sha {
	599	+	flex: none;
	600	+	font-size: var(--caption);
	601	+	color: var(--interactive);
	602	+	}
	603	+
	604	+	.log-note {
	605	+	margin-top: var(--space-lg);
	606	+	}
	607	+
	608	+	.pager {
	609	+	display: flex;
	610	+	justify-content: space-between;
	611	+	gap: var(--space-md);
	612	+	margin-top: var(--space-xl);
	613	+	}
	614	+
	615	+	.pager a,
	616	+	.pager span {
	617	+	display: inline-flex;
	618	+	align-items: center;
	619	+	min-height: 44px;
	620	+	}
	621	+
	622	+	/* ---- Commit --------------------------------------------------------------- */
	623	+
	624	+	.commit-head {
	625	+	margin-top: var(--space-lg);
	626	+	}
	627	+
	628	+	.commit-subject {
	629	+	font-size: var(--heading);
	630	+	font-weight: 400;
	631	+	line-height: 1.25;
	632	+	color: var(--text-display);
	633	+	overflow-wrap: anywhere;
	634	+	}
	635	+
	636	+	.commit-body {
	637	+	max-width: 72ch;
	638	+	margin-top: var(--space-md);
	639	+	font-family: var(--font-body);
	640	+	font-size: var(--body);
	641	+	white-space: pre-wrap;
	642	+	overflow-wrap: anywhere;
	643	+	color: var(--text-secondary);
	644	+	}
	645	+
	646	+	.commit-grid {
	647	+	display: grid;
	648	+	gap: var(--space-xl);
	649	+	margin-top: var(--space-xl);
	650	+	}
	651	+
	652	+	@media (min-width: 768px) {
	653	+	.commit-grid {
	654	+	grid-template-columns: minmax(0, 1fr) auto;
	655	+	align-items: end;
	656	+	}
	657	+	}
	658	+
	659	+	/* The one break on the commit page: a hero diffstat. */
	660	+	.diffstat-hero {
	661	+	text-align: right;
	662	+	}
	663	+
	664	+	.diffstat-num {
	665	+	font-family: var(--font-mono);
	666	+	font-size: 48px;
	667	+	line-height: 1;
	668	+	letter-spacing: -0.02em;
	669	+	color: var(--text-display);
	670	+	white-space: nowrap;
	671	+	}
	672	+
	673	+	.diffstat-hero .label {
	674	+	margin-top: var(--space-sm);
	675	+	}
	676	+
	677	+	.add {
	678	+	color: var(--success);
	679	+	}
	680	+
	681	+	.del {
	682	+	color: var(--accent);
	683	+	}
	684	+
	685	+	.commit-actions {
	686	+	display: flex;
	687	+	flex-wrap: wrap;
	688	+	align-items: center;
	689	+	justify-content: space-between;
	690	+	gap: var(--space-md);
	691	+	margin-top: var(--space-xl);
	692	+	}
	693	+
	694	+	.context-ctl {
	695	+	display: inline-flex;
	696	+	align-items: center;
	697	+	gap: var(--space-sm);
	698	+	}
	699	+
	700	+	.context-ctl a,
	701	+	.context-ctl > span:first-child,
	702	+	.context-ctl > span:last-child {
	703	+	display: inline-flex;
	704	+	align-items: center;
	705	+	justify-content: center;
	706	+	min-width: 28px;
	707	+	min-height: 28px;
	708	+	}
	709	+
	710	+	.file-list {
	711	+	list-style: none;
	712	+	margin-top: var(--space-lg);
	713	+	border-top: 1px solid var(--border);
	714	+	}
	715	+
	716	+	.file-row {
	717	+	display: flex;
	718	+	align-items: center;
	719	+	gap: var(--space-md);
	720	+	min-height: 40px;
	721	+	padding-block: var(--space-xs);
	722	+	border-bottom: 1px solid var(--border);
	723	+	}
	724	+
	725	+	.file-status {
	726	+	flex: none;
	727	+	width: 1.5em;
	728	+	font-family: var(--font-mono);
	729	+	font-size: var(--caption);
	730	+	color: var(--text-secondary);
	731	+	}
	732	+
	733	+	.file-path {
	734	+	flex: 1;
	735	+	min-width: 0;
	736	+	font-family: var(--font-mono);
	737	+	font-size: var(--body-sm);
	738	+	color: var(--text-primary);
	739	+	overflow-wrap: anywhere;
	740	+	}
	741	+
	742	+	.file-path .dim,
	743	+	.diff-path .dim {
	744	+	color: var(--text-disabled);
	745	+	}
	746	+
	747	+	.file-counts {
	748	+	flex: none;
	749	+	font-family: var(--font-mono);
	750	+	font-size: var(--caption);
	751	+	white-space: nowrap;
	752	+	}
	753	+
	754	+	.blocks {
	755	+	display: inline-flex;
	756	+	flex: none;
	757	+	gap: 2px;
	758	+	}
	759	+
	760	+	.blocks i {
	761	+	width: 8px;
	762	+	height: 8px;
	763	+	background: var(--segment-empty);
	764	+	}
	765	+
	766	+	.blocks i.add {
	767	+	background: var(--success);
	768	+	}
	769	+
	770	+	.blocks i.del {
	771	+	background: var(--accent);
	772	+	}
	773	+
	774	+	.diff-file {
	775	+	margin-top: var(--space-2xl);
	776	+	}
	777	+
	778	+	.diff-head {
	779	+	position: sticky;
	780	+	top: 0;
	781	+	z-index: 1;
	782	+	display: flex;
	783	+	align-items: center;
	784	+	gap: var(--space-md);
	785	+	min-height: 44px;
	786	+	background: var(--black);
	787	+	border-bottom: 1px solid var(--border-visible);
	788	+	}
	789	+
	790	+	.diff-path {
	791	+	flex: 1;
	792	+	min-width: 0;
	793	+	font-family: var(--font-mono);
	794	+	font-size: var(--body-sm);
	795	+	color: var(--text-display);
	796	+	overflow-wrap: anywhere;
	797	+	}
	798	+
	799	+	.diff-view {
	800	+	flex: none;
	801	+	}
	802	+
	803	+	.diff-note {
	804	+	padding-block: var(--space-md);
	805	+	border-bottom: 1px solid var(--border);
	806	+	overflow-wrap: anywhere;
	807	+	}
	808	+
	809	+	.diff-file .code-wrap {
	810	+	margin-top: 0;
	811	+	border-top: 0;
	812	+	}
	813	+
	814	+	.code.diff .ln {
	815	+	padding: 0 var(--space-sm);
	816	+	color: var(--text-disabled);
	817	+	font-size: 12px;
	818	+	}
	819	+
	820	+	.code.diff .ln + .ln {
	821	+	border-left: 0;
	822	+	}
	823	+
	824	+	.code.diff .sign {
	825	+	width: 1%;
	826	+	padding: 0 var(--space-xs) 0 var(--space-sm);
	827	+	color: var(--text-disabled);
	828	+	user-select: none;
	829	+	-webkit-user-select: none;
	830	+	}
	831	+
	832	+	.code.diff .lc {
	833	+	padding-left: 0;
	834	+	}
	835	+
	836	+	.code.diff tr.add .ln:first-child {
	837	+	border-left-color: var(--success);
	838	+	}
	839	+
	840	+	.code.diff tr.add .sign {
	841	+	color: var(--success);
	842	+	}
	843	+
	844	+	.code.diff tr.del .ln:first-child {
	845	+	border-left-color: var(--accent);
	846	+	}
	847	+
	848	+	.code.diff tr.del .sign {
	849	+	color: var(--accent);
	850	+	}
	851	+
	852	+	.code.diff tr.del .lc {
	853	+	opacity: 0.55;
	854	+	}
	855	+
	856	+	.code.diff tr.hunk td {
	857	+	padding-block: var(--space-xs);
	858	+	color: var(--text-disabled);
	859	+	}
	860	+
	861	+	.code.diff tr.hunk .lc {
	862	+	font-family: var(--font-mono);
	863	+	font-size: 12px;
	864	+	}
	865	+
	866	+	.code.diff tr.hunk:not(:first-child) td {
	867	+	border-top: 1px solid var(--border);
	868	+	}
	869	+
557	870		/* ---- Markdown ------------------------------------------------------------ */
558	871
559	872		.markdown {
		@@ -42,6 +42,7 @@ theme = "auto" # auto \| dark \| light
42	42		code_font = "Space Mono"
43	43		max_blob_kb = 1024
44	44		max_highlight_kb = 256
	45	+	log_page = 50 # commits per log page
45	46
46	47		[cache]
47	48		size_mb = 64
		@@ -55,6 +56,10 @@ poll_interval_secs = 300 # 0 disables the periodic full rescan
55	56		git_parallel = 0 # 0 = 2 × CPUs
56	57		heavy_parallel = 2
57	58		request_timeout_secs = 30
	59	+	log_scan = 10000 # commits examined per page by path/grep log filters
	60	+	diff_files = 300 # larger commits show the file list only
	61	+	diff_lines = 10000 # changed lines rendered per commit
	62	+	diff_file_lines = 2000 # changed lines rendered per file
58	63
59	64		[log]
60	65		level = "info" # RUST_LOG takes precedence when set
		@@ -6,9 +6,11 @@
6	6
7	7		use std::sync::Arc;
8	8
9		−	use crate::git::ObjectId;
	9	+	use crate::git::log::{LogPage, LogQuery};
10	10		use crate::git::refs::RefList;
11	11		use crate::git::tree::TreeEntry;
	12	+	use crate::git::{Mailmap, ObjectId};
	13	+	use crate::render::diff::{CommitDiff, Options as DiffOptions};
12	14
13	15		#[derive(Debug, Clone, PartialEq, Eq, Hash)]
14	16		pub enum Key {
		@@ -28,6 +30,15 @@ pub enum Key {
28	30		repo: String,
29	31		generation: u64,
30	32		},
	33	+	Log {
	34	+	tip: ObjectId,
	35	+	query: LogQuery,
	36	+	},
	37	+	Diff {
	38	+	commit: ObjectId,
	39	+	options: DiffOptions,
	40	+	},
	41	+	Mailmap(ObjectId),
31	42		}
32	43
33	44		#[derive(Clone)]
		@@ -37,6 +48,9 @@ pub enum Value {
37	48		Tree(Arc<Vec<TreeEntry>>),
38	49		Count(u64),
39	50		Refs(Arc<RefList>),
	51	+	Log(Arc<LogPage>),
	52	+	Diff(Arc<CommitDiff>),
	53	+	Mailmap(Arc<Mailmap>),
40	54		}
41	55
42	56		impl Value {
		@@ -47,6 +61,9 @@ impl Value {
47	61		Value::Tree(entries) => entries.iter().map(\|e\| e.name.len() + 64).sum(),
48	62		Value::Count(_) => 8,
49	63		Value::Refs(refs) => refs.weight(),
	64	+	Value::Log(page) => page.weight(),
	65	+	Value::Diff(diff) => diff.weight(),
	66	+	Value::Mailmap(map) => map.weight(),
50	67		}
51	68		}
52	69		}
		@@ -64,6 +81,9 @@ impl Cache {
64	81		Key::Highlight { syntax, .. } => syntax.len(),
65	82		Key::Markdown { context, .. } => context.len(),
66	83		Key::Refs { repo, .. } => repo.len(),
	84	+	Key::Log { query, .. } => {
	85	+	query.path.len() + query.grep.as_ref().map_or(0, String::len)
	86	+	}
67	87		_ => 0,
68	88		};
69	89		u32::try_from(64 + key + value.weight()).unwrap_or(u32::MAX)
		@@ -136,6 +156,41 @@ impl Cache {
136	156		}
137	157		}
138	158
	159	+	pub fn log<E>(
	160	+	&self,
	161	+	key: Key,
	162	+	compute: impl FnOnce() -> Result<LogPage, E>,
	163	+	) -> Result<Arc<LogPage>, E> {
	164	+	match self.get_or(key, \|\| compute().map(\|v\| Value::Log(Arc::new(v))))? {
	165	+	Value::Log(v) => Ok(v),
	166	+	_ => unreachable!("cache key/value kind mismatch"),
	167	+	}
	168	+	}
	169	+
	170	+	pub fn diff<E>(
	171	+	&self,
	172	+	key: Key,
	173	+	compute: impl FnOnce() -> Result<CommitDiff, E>,
	174	+	) -> Result<Arc<CommitDiff>, E> {
	175	+	match self.get_or(key, \|\| compute().map(\|v\| Value::Diff(Arc::new(v))))? {
	176	+	Value::Diff(v) => Ok(v),
	177	+	_ => unreachable!("cache key/value kind mismatch"),
	178	+	}
	179	+	}
	180	+
	181	+	pub fn mailmap<E>(
	182	+	&self,
	183	+	blob: ObjectId,
	184	+	compute: impl FnOnce() -> Result<Mailmap, E>,
	185	+	) -> Result<Arc<Mailmap>, E> {
	186	+	match self.get_or(Key::Mailmap(blob), \|\| {
	187	+	compute().map(\|v\| Value::Mailmap(Arc::new(v)))
	188	+	})? {
	189	+	Value::Mailmap(v) => Ok(v),
	190	+	_ => unreachable!("cache key/value kind mismatch"),
	191	+	}
	192	+	}
	193	+
139	194		pub fn entry_count(&self) -> u64 {
140	195		self.inner.run_pending_tasks();
141	196		self.inner.entry_count()
		@@ -157,6 +157,8 @@ pub struct UiConfig {
157	157		pub code_font: String,
158	158		pub max_blob_kb: u64,
159	159		pub max_highlight_kb: u64,
	160	+	/// Commits per log page.
	161	+	pub log_page: usize,
160	162		}
161	163
162	164		impl Default for UiConfig {
		@@ -166,6 +168,7 @@ impl Default for UiConfig {
166	168		code_font: DEFAULT_CODE_FONT.into(),
167	169		max_blob_kb: 1024,
168	170		max_highlight_kb: 256,
	171	+	log_page: 50,
169	172		}
170	173		}
171	174		}
		@@ -229,6 +232,12 @@ pub struct LimitsConfig {
229	232		pub git_parallel: usize,
230	233		pub heavy_parallel: usize,
231	234		pub request_timeout_secs: u64,
	235	+	/// Commits a filtered log (path or grep) examines per page.
	236	+	pub log_scan: usize,
	237	+	/// Above these, a commit's diff is not shown in full.
	238	+	pub diff_files: usize,
	239	+	pub diff_lines: usize,
	240	+	pub diff_file_lines: usize,
232	241		}
233	242
234	243		impl Default for LimitsConfig {
		@@ -237,6 +246,10 @@ impl Default for LimitsConfig {
237	246		git_parallel: 0,
238	247		heavy_parallel: 2,
239	248		request_timeout_secs: 30,
	249	+	log_scan: 10_000,
	250	+	diff_files: 300,
	251	+	diff_lines: 10_000,
	252	+	diff_file_lines: 2_000,
240	253		}
241	254		}
242	255		}
		@@ -459,6 +472,19 @@ impl Config {
459	472		if self.limits.request_timeout_secs == 0 {
460	473		errors.push("limits.request_timeout_secs must be at least 1".into());
461	474		}
	475	+	if !(1..=1000).contains(&self.ui.log_page) {
	476	+	errors.push("ui.log_page must be between 1 and 1000".into());
	477	+	}
	478	+	for (key, value) in [
	479	+	("log_scan", self.limits.log_scan),
	480	+	("diff_files", self.limits.diff_files),
	481	+	("diff_lines", self.limits.diff_lines),
	482	+	("diff_file_lines", self.limits.diff_file_lines),
	483	+	] {
	484	+	if value == 0 {
	485	+	errors.push(format!("limits.{key} must be at least 1"));
	486	+	}
	487	+	}
462	488
463	489		// log
464	490		if let Err(e) = tracing_subscriber::EnvFilter::try_new(&self.log.level) {
	@@ -0,0 +1,408 @@
1	+	//! What a commit changed: the file list (with renames) against its first
2	+	//! parent, and line diffs grouped into hunks.
3	+
4	+	use std::hash::Hash;
5	+
6	+	use anyhow::Context;
7	+	use gix::bstr::BString;
8	+	use gix::diff::blob::{Algorithm, Diff, InternedInput};
9	+	use gix::object::tree::diff::ChangeDetached;
10	+
11	+	use super::ObjectId;
12	+	use super::tree::EntryKind;
13	+
14	+	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15	+	pub enum Status {
16	+	Added,
17	+	Deleted,
18	+	Modified,
19	+	Renamed,
20	+	Copied,
21	+	}
22	+
23	+	/// One side of a change.
24	+	#[derive(Debug, Clone, PartialEq, Eq)]
25	+	pub struct Side {
26	+	pub path: BString,
27	+	pub oid: ObjectId,
28	+	pub kind: EntryKind,
29	+	}
30	+
31	+	#[derive(Debug, Clone, PartialEq, Eq)]
32	+	pub struct FileChange {
33	+	pub status: Status,
34	+	pub old: Option<Side>,
35	+	pub new: Option<Side>,
36	+	/// Rename/copy similarity in percent.
37	+	pub similarity: Option<u8>,
38	+	}
39	+
40	+	impl FileChange {
41	+	/// The path after the change (before it, for deletions).
42	+	pub fn path(&self) -> &BString {
43	+	match (&self.new, &self.old) {
44	+	(Some(side), _) \| (None, Some(side)) => &side.path,
45	+	(None, None) => unreachable!("a change has at least one side"),
46	+	}
47	+	}
48	+	}
49	+
50	+	#[derive(Debug, Clone)]
51	+	pub struct Changes {
52	+	/// The first parent; `None` for a root commit (compared to nothing).
53	+	pub parent: Option<ObjectId>,
54	+	pub files: Vec<FileChange>,
55	+	}
56	+
57	+	/// Files changed by `commit` relative to its first parent, renames
58	+	/// detected like `git diff -M` (50% similarity), sorted by path.
59	+	pub fn changes(repo: &gix::Repository, commit: ObjectId) -> anyhow::Result<Changes> {
60	+	let commit = repo.find_commit(commit).context("commit not found")?;
61	+	let new_tree = commit.tree().context("commit has no tree")?;
62	+	let parent = commit.parent_ids().next().map(\|id\| id.detach());
63	+	let old_tree = match parent {
64	+	Some(id) => Some(
65	+	repo.find_commit(id)
66	+	.context("parent commit not found")?
67	+	.tree()
68	+	.context("parent has no tree")?,
69	+	),
70	+	None => None,
71	+	};
72	+	let options = gix::diff::Options::default().with_rewrites(Some(Default::default()));
73	+	let changes = repo
74	+	.diff_tree_to_tree(old_tree.as_ref(), Some(&new_tree), options)
75	+	.context("cannot diff trees")?;
76	+
77	+	let side = \|path: &BString, mode: gix::object::tree::EntryMode, oid: ObjectId\| {
78	+	(!mode.is_tree()).then(\|\| Side {
79	+	path: path.clone(),
80	+	oid,
81	+	kind: EntryKind::from_gix(mode.kind()),
82	+	})
83	+	};
84	+	let mut files = Vec::new();
85	+	for change in changes {
86	+	let file = match change {
87	+	ChangeDetached::Addition {
88	+	location,
89	+	entry_mode,
90	+	id,
91	+	..
92	+	} => FileChange {
93	+	status: Status::Added,
94	+	old: None,
95	+	new: side(&location, entry_mode, id),
96	+	similarity: None,
97	+	},
98	+	ChangeDetached::Deletion {
99	+	location,
100	+	entry_mode,
101	+	id,
102	+	..
103	+	} => FileChange {
104	+	status: Status::Deleted,
105	+	old: side(&location, entry_mode, id),
106	+	new: None,
107	+	similarity: None,
108	+	},
109	+	ChangeDetached::Modification {
110	+	location,
111	+	previous_entry_mode,
112	+	previous_id,
113	+	entry_mode,
114	+	id,
115	+	} => {
116	+	// A tree replaced by a file (or the reverse) is just an
117	+	// addition (deletion) of the file. A file that changed type
118	+	// (regular, symlink, submodule) is both, as git shows it.
119	+	let old = side(&location, previous_entry_mode, previous_id);
120	+	let new = side(&location, entry_mode, id);
121	+	match (old, new) {
122	+	(Some(old), Some(new)) if !old.kind.same_type(new.kind) => {
123	+	files.push(FileChange {
124	+	status: Status::Deleted,
125	+	old: Some(old),
126	+	new: None,
127	+	similarity: None,
128	+	});
129	+	FileChange {
130	+	status: Status::Added,
131	+	old: None,
132	+	new: Some(new),
133	+	similarity: None,
134	+	}
135	+	}
136	+	(old, new) => FileChange {
137	+	status: match (&old, &new) {
138	+	(None, _) => Status::Added,
139	+	(_, None) => Status::Deleted,
140	+	_ => Status::Modified,
141	+	},
142	+	old,
143	+	new,
144	+	similarity: None,
145	+	},
146	+	}
147	+	}
148	+	ChangeDetached::Rewrite {
149	+	source_location,
150	+	source_entry_mode,
151	+	source_id,
152	+	diff,
153	+	entry_mode,
154	+	id,
155	+	location,
156	+	copy,
157	+	..
158	+	} => FileChange {
159	+	status: if copy {
160	+	Status::Copied
161	+	} else {
162	+	Status::Renamed
163	+	},
164	+	old: side(&source_location, source_entry_mode, source_id),
165	+	new: side(&location, entry_mode, id),
166	+	// Truncated like git's percentage.
167	+	similarity: Some(
168	+	diff.map_or(100.0, \|d\| d.similarity * 100.0)
169	+	.floor()
170	+	.clamp(0.0, 100.0) as u8,
171	+	),
172	+	},
173	+	};
174	+	if file.old.is_some() \|\| file.new.is_some() {
175	+	files.push(file);
176	+	}
177	+	}
178	+	files.sort_by(\|a, b\| a.path().cmp(b.path()));
179	+	Ok(Changes { parent, files })
180	+	}
181	+
182	+	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
183	+	pub enum LineKind {
184	+	Context,
185	+	Added,
186	+	Removed,
187	+	}
188	+
189	+	/// A line in a hunk; `old`/`new` are 0-based line indexes into each side.
190	+	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
191	+	pub struct Line {
192	+	pub kind: LineKind,
193	+	pub old: Option<u32>,
194	+	pub new: Option<u32>,
195	+	}
196	+
197	+	#[derive(Debug, Clone, PartialEq, Eq)]
198	+	pub struct Hunk {
199	+	/// 0-based first line and length on each side.
200	+	pub old_start: u32,
201	+	pub old_len: u32,
202	+	pub new_start: u32,
203	+	pub new_len: u32,
204	+	pub lines: Vec<Line>,
205	+	/// The enclosing "function" line git shows after the ranges.
206	+	pub func: Option<String>,
207	+	}
208	+
209	+	impl Hunk {
210	+	/// `@@ -1,5 +1,8 @@ fn main() {`
211	+	pub fn header(&self) -> String {
212	+	fn range(start: u32, len: u32) -> String {
213	+	match len {
214	+	0 => format!("{start},0"),
215	+	1 => format!("{}", start + 1),
216	+	_ => format!("{},{len}", start + 1),
217	+	}
218	+	}
219	+	let mut header = format!(
220	+	"@@ -{} +{} @@",
221	+	range(self.old_start, self.old_len),
222	+	range(self.new_start, self.new_len)
223	+	);
224	+	if let Some(func) = &self.func {
225	+	header.push(' ');
226	+	header.push_str(func);
227	+	}
228	+	header
229	+	}
230	+	}
231	+
232	+	#[derive(Debug, Clone, Default, PartialEq, Eq)]
233	+	pub struct LineDiff {
234	+	pub hunks: Vec<Hunk>,
235	+	pub added: u32,
236	+	pub removed: u32,
237	+	}
238	+
239	+	/// Line diff of two texts split into lines (each with its `\n`, so a
240	+	/// missing final newline counts as a change), with `context` unchanged
241	+	/// lines around each change. `ignore_ws` compares lines with all
242	+	/// whitespace removed, like `git diff -w`.
243	+	pub fn lines(old: &[&str], new: &[&str], context: u32, ignore_ws: bool) -> LineDiff {
244	+	let diff = if ignore_ws {
245	+	let strip =
246	+	\|l: &&str\| -> Vec<u8> { l.bytes().filter(\|b\| !b.is_ascii_whitespace()).collect() };
247	+	compute(old.iter().map(strip), new.iter().map(strip))
248	+	} else {
249	+	compute(
250	+	old.iter().map(\|l\| l.as_bytes()),
251	+	new.iter().map(\|l\| l.as_bytes()),
252	+	)
253	+	};
254	+	let raw: Vec<_> = diff.hunks().collect();
255	+	let (old_len, new_len) = (old.len() as u32, new.len() as u32);
256	+	let mut out = LineDiff {
257	+	hunks: Vec::new(),
258	+	added: diff.count_additions(),
259	+	removed: diff.count_removals(),
260	+	};
261	+	let mut i = 0;
262	+	while i < raw.len() {
263	+	// Merge changes whose context would overlap or touch.
264	+	let mut j = i;
265	+	while j + 1 < raw.len() && raw[j + 1].before.start - raw[j].before.end <= 2 * context {
266	+	j += 1;
267	+	}
268	+	let lead = raw[i].before.start.min(context);
269	+	let (old_start, new_start) = (raw[i].before.start - lead, raw[i].after.start - lead);
270	+	let trail = context.min(old_len - raw[j].before.end);
271	+	let (old_end, new_end) = (raw[j].before.end + trail, raw[j].after.end + trail);
272	+	debug_assert!(new_end <= new_len);
273	+
274	+	let mut lines = Vec::new();
275	+	let (mut o, mut n) = (old_start, new_start);
276	+	for h in &raw[i..=j] {
277	+	while o < h.before.start {
278	+	lines.push(Line {
279	+	kind: LineKind::Context,
280	+	old: Some(o),
281	+	new: Some(n),
282	+	});
283	+	o += 1;
284	+	n += 1;
285	+	}
286	+	for r in h.before.clone() {
287	+	lines.push(Line {
288	+	kind: LineKind::Removed,
289	+	old: Some(r),
290	+	new: None,
291	+	});
292	+	}
293	+	for a in h.after.clone() {
294	+	lines.push(Line {
295	+	kind: LineKind::Added,
296	+	old: None,
297	+	new: Some(a),
298	+	});
299	+	}
300	+	o = h.before.end;
301	+	n = h.after.end;
302	+	}
303	+	while o < old_end {
304	+	lines.push(Line {
305	+	kind: LineKind::Context,
306	+	old: Some(o),
307	+	new: Some(n),
308	+	});
309	+	o += 1;
310	+	n += 1;
311	+	}
312	+	out.hunks.push(Hunk {
313	+	old_start,
314	+	old_len: old_end - old_start,
315	+	new_start,
316	+	new_len: new_end - new_start,
317	+	lines,
318	+	func: func_line(&old[..old_start as usize]),
319	+	});
320	+	i = j + 1;
321	+	}
322	+	out
323	+	}
324	+
325	+	/// git's default hunk-header context: the closest line above the hunk
326	+	/// that starts like an identifier, trailing whitespace trimmed, at most
327	+	/// 80 bytes.
328	+	fn func_line(before: &[&str]) -> Option<String> {
329	+	let line = before.iter().rev().find(\|l\| {
330	+	l.bytes()
331	+	.next()
332	+	.is_some_and(\|b\| b.is_ascii_alphabetic() \|\| b == b'_' \|\| b == b'$')
333	+	})?;
334	+	let bytes = &line.as_bytes()[..line.len().min(80)];
335	+	let end = bytes
336	+	.iter()
337	+	.rposition(\|b\| !b.is_ascii_whitespace())
338	+	.map_or(0, \|i\| i + 1);
339	+	Some(String::from_utf8_lossy(&bytes[..end]).into_owned())
340	+	}
341	+
342	+	fn compute<T: AsRef<[u8]> + Hash + Eq + Default>(
343	+	old: impl Iterator<Item = T>,
344	+	new: impl Iterator<Item = T>,
345	+	) -> Diff {
346	+	let mut input = InternedInput::default();
347	+	input.update_before(old);
348	+	input.update_after(new);
349	+	gix::diff::blob::diff_with_slider_heuristics(Algorithm::Myers, &input)
350	+	}
351	+
352	+	/// Git's mode for an entry kind (`100644`, …).
353	+	pub fn mode(kind: EntryKind) -> &'static str {
354	+	match kind {
355	+	EntryKind::Blob => "100644",
356	+	EntryKind::Executable => "100755",
357	+	EntryKind::Symlink => "120000",
358	+	EntryKind::Submodule => "160000",
359	+	EntryKind::Tree => "040000",
360	+	}
361	+	}
362	+
363	+	#[cfg(test)]
364	+	mod tests {
365	+	use super::*;
366	+
367	+	fn split(text: &str) -> Vec<&str> {
368	+	text.split_inclusive('\n').collect()
369	+	}
370	+
371	+	#[test]
372	+	fn hunks_with_context_and_merging() {
373	+	let old = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n";
374	+	let new = "a\nB\nc\nd\ne\nf\ng\nh\ni\nJ\n";
375	+	let diff = lines(&split(old), &split(new), 3, false);
376	+	assert_eq!((diff.added, diff.removed), (2, 2));
377	+	// Changes at lines 2 and 10 are 7 apart: with 3 lines of context
378	+	// they stay separate hunks.
379	+	assert_eq!(diff.hunks.len(), 2);
380	+	assert_eq!(diff.hunks[0].header(), "@@ -1,5 +1,5 @@");
381	+	assert_eq!(diff.hunks[1].header(), "@@ -7,4 +7,4 @@ f");
382	+	// With more context they merge.
383	+	let diff = lines(&split(old), &split(new), 4, false);
384	+	assert_eq!(diff.hunks.len(), 1);
385	+	assert_eq!(diff.hunks[0].header(), "@@ -1,10 +1,10 @@");
386	+	}
387	+
388	+	#[test]
389	+	fn additions_to_empty_and_whitespace() {
390	+	let diff = lines(&[], &split("x\ny\n"), 3, false);
391	+	assert_eq!(diff.hunks[0].header(), "@@ -0,0 +1,2 @@");
392	+	assert_eq!(diff.hunks[0].lines.len(), 2);
393	+
394	+	let old = split("fn x() {\n a;\n}\n");
395	+	let new = split("fn x() {\n\ta;\n}\n");
396	+	assert_eq!(lines(&old, &new, 3, false).added, 1);
397	+	let ws = lines(&old, &new, 3, true);
398	+	assert!(ws.hunks.is_empty());
399	+	assert_eq!((ws.added, ws.removed), (0, 0));
400	+	}
401	+
402	+	#[test]
403	+	fn missing_final_newline_is_a_change() {
404	+	let diff = lines(&split("a\nb\n"), &split("a\nb"), 0, false);
405	+	assert_eq!((diff.added, diff.removed), (1, 1));
406	+	assert_eq!(diff.hunks[0].header(), "@@ -2 +2 @@ a");
407	+	}
408	+	}
	@@ -0,0 +1,267 @@
1	+	//! Commit history: newest-first walks, paged with a cursor, optionally
2	+	//! filtered by path and message.
3	+	//!
4	+	//! Path filters follow git's default history simplification: at a merge
5	+	//! that kept one parent's version of the path, only that parent is
6	+	//! followed, so side branches whose changes didn't survive are left out
7	+	//! (`git log -- path`, not `--full-history`).
8	+
9	+	use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
10	+
11	+	use anyhow::Context;
12	+	use gix::bstr::ByteSlice;
13	+	use gix::revision::walk::Sorting;
14	+	use gix::traverse::commit::simple::CommitTimeOrder;
15	+
16	+	use super::tree::{self, EntryKind};
17	+	use super::{CommitInfo, ObjectId, commit_info};
18	+
19	+	#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
20	+	pub struct LogQuery {
21	+	/// Only commits that change this path (empty: all commits).
22	+	pub path: Vec<u8>,
23	+	/// Case-insensitive match on the message, author name and email.
24	+	pub grep: Option<String>,
25	+	/// Start after this commit (the last one on the previous page).
26	+	pub after: Option<ObjectId>,
27	+	pub page: usize,
28	+	/// Commits a filtered walk may examine before giving up on this page.
29	+	pub scan_limit: usize,
30	+	}
31	+
32	+	impl LogQuery {
33	+	fn filtered(&self) -> bool {
34	+	!self.path.is_empty() \|\| self.grep.is_some()
35	+	}
36	+	}
37	+
38	+	/// Where the "newer" link of a page goes.
39	+	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
40	+	pub enum Newer {
41	+	/// This is the first page.
42	+	None,
43	+	/// Back to the first page (filtered logs can't step back exactly).
44	+	First,
45	+	After(ObjectId),
46	+	}
47	+
48	+	#[derive(Debug, Clone)]
49	+	pub struct LogPage {
50	+	pub commits: Vec<CommitInfo>,
51	+	/// Cursor for the next (older) page.
52	+	pub older: Option<ObjectId>,
53	+	pub newer: Newer,
54	+	/// The filter gave up after `scan_limit` commits; `older` continues.
55	+	pub limit_reached: bool,
56	+	}
57	+
58	+	impl LogPage {
59	+	pub fn weight(&self) -> usize {
60	+	64 + self.commits.iter().map(CommitInfo::weight).sum::<usize>()
61	+	}
62	+	}
63	+
64	+	#[derive(Debug, thiserror::Error)]
65	+	pub enum LogError {
66	+	#[error("the cursor commit is not in this history")]
67	+	UnknownCursor,
68	+	#[error(transparent)]
69	+	Git(#[from] anyhow::Error),
70	+	}
71	+
72	+	/// One page of the history of `tip`, newest commit first.
73	+	pub fn page(repo: &gix::Repository, tip: ObjectId, query: &LogQuery) -> Result<LogPage, LogError> {
74	+	let filtered = query.filtered();
75	+	let grep = query.grep.as_ref().map(\|q\| q.to_lowercase());
76	+	let mut walk = if query.path.is_empty() {
77	+	Walk::All(
78	+	repo.rev_walk([tip])
79	+	.sorting(Sorting::ByCommitTime(CommitTimeOrder::NewestFirst))
80	+	.all()
81	+	.context("cannot walk history")?,
82	+	)
83	+	} else {
84	+	Walk::Path(PathWalk::new(repo, tip, &query.path)?)
85	+	};
86	+
87	+	// Unfiltered: the commits up to and including the cursor, enough to
88	+	// find where the previous page started.
89	+	let mut recent: VecDeque<ObjectId> = VecDeque::new();
90	+	let mut seeking = query.after;
91	+	let mut out = LogPage {
92	+	commits: Vec::new(),
93	+	older: None,
94	+	newer: Newer::None,
95	+	limit_reached: false,
96	+	};
97	+	let mut scanned = 0;
98	+	let mut last_examined = None;
99	+	while let Some(step) = walk.next() {
100	+	let (id, touches) = step?;
101	+	if let Some(cursor) = seeking {
102	+	if !filtered {
103	+	recent.push_back(id);
104	+	if recent.len() > query.page + 1 {
105	+	recent.pop_front();
106	+	}
107	+	}
108	+	if id == cursor {
109	+	seeking = None;
110	+	}
111	+	continue;
112	+	}
113	+	if filtered {
114	+	if scanned == query.scan_limit {
115	+	out.limit_reached = true;
116	+	out.older = last_examined;
117	+	break;
118	+	}
119	+	scanned += 1;
120	+	last_examined = Some(id);
121	+	}
122	+	if !touches {
123	+	continue;
124	+	}
125	+	let commit = commit_info(repo, id)?;
126	+	if let Some(grep) = &grep
127	+	&& !message_matches(repo, &commit, grep)?
128	+	{
129	+	continue;
130	+	}
131	+	if out.commits.len() == query.page {
132	+	out.older = out.commits.last().map(\|c\| c.id);
133	+	break;
134	+	}
135	+	out.commits.push(commit);
136	+	}
137	+	if seeking.is_some() {
138	+	return Err(LogError::UnknownCursor);
139	+	}
140	+	if query.after.is_some() {
141	+	out.newer = if filtered \|\| recent.len() <= query.page {
142	+	Newer::First
143	+	} else {
144	+	Newer::After(recent[0])
145	+	};
146	+	}
147	+	Ok(out)
148	+	}
149	+
150	+	fn message_matches(repo: &gix::Repository, info: &CommitInfo, grep: &str) -> anyhow::Result<bool> {
151	+	if info.author_name.to_lowercase().contains(grep)
152	+	\|\| info.author_email.to_lowercase().contains(grep)
153	+	{
154	+	return Ok(true);
155	+	}
156	+	let commit = repo.find_commit(info.id).context("commit not found")?;
157	+	let message = commit.message_raw_sloppy().to_str_lossy().to_lowercase();
158	+	Ok(message.contains(grep))
159	+	}
160	+
161	+	enum Walk<'repo> {
162	+	All(gix::revision::Walk<'repo>),
163	+	Path(PathWalk<'repo>),
164	+	}
165	+
166	+	impl Walk<'_> {
167	+	/// The next commit, and whether it passes the path filter.
168	+	fn next(&mut self) -> Option<anyhow::Result<(ObjectId, bool)>> {
169	+	match self {
170	+	Walk::All(walk) => Some(
171	+	walk.next()?
172	+	.map(\|info\| (info.id, true))
173	+	.context("cannot walk history"),
174	+	),
175	+	Walk::Path(walk) => walk.next().transpose(),
176	+	}
177	+	}
178	+	}
179	+
180	+	/// Newest-first walk that simplifies history for `path`.
181	+	struct PathWalk<'repo> {
182	+	repo: &'repo gix::Repository,
183	+	path: Vec<u8>,
184	+	queue: BinaryHeap<(i64, ObjectId)>,
185	+	seen: HashSet<ObjectId>,
186	+	oids: PathOids,
187	+	}
188	+
189	+	impl<'repo> PathWalk<'repo> {
190	+	fn new(repo: &'repo gix::Repository, tip: ObjectId, path: &[u8]) -> anyhow::Result<Self> {
191	+	let mut walk = PathWalk {
192	+	repo,
193	+	path: path.to_vec(),
194	+	queue: BinaryHeap::new(),
195	+	seen: HashSet::new(),
196	+	oids: PathOids::default(),
197	+	};
198	+	walk.push(tip)?;
199	+	Ok(walk)
200	+	}
201	+
202	+	fn push(&mut self, id: ObjectId) -> anyhow::Result<()> {
203	+	if !self.seen.insert(id) {
204	+	return Ok(());
205	+	}
206	+	// Missing parents (shallow clones) end the walk there.
207	+	let Ok(commit) = self.repo.find_commit(id) else {
208	+	return Ok(());
209	+	};
210	+	let time = commit.time().context("malformed commit")?.seconds;
211	+	self.queue.push((time, id));
212	+	Ok(())
213	+	}
214	+
215	+	fn next(&mut self) -> anyhow::Result<Option<(ObjectId, bool)>> {
216	+	let Some((_, id)) = self.queue.pop() else {
217	+	return Ok(None);
218	+	};
219	+	let commit = self.repo.find_commit(id).context("commit not found")?;
220	+	let parents: Vec<ObjectId> = commit.parent_ids().map(\|p\| p.detach()).collect();
221	+	let here = self.oids.get(self.repo, id, &self.path)?;
222	+	let mut same = None;
223	+	for parent in &parents {
224	+	if self.oids.get(self.repo, *parent, &self.path)? == here {
225	+	same = Some(*parent);
226	+	break;
227	+	}
228	+	}
229	+	let (touches, follow) = match same {
230	+	// Identical to a parent: not interesting, and only that
231	+	// parent's history explains the path's state.
232	+	Some(parent) => (false, vec![parent]),
233	+	None if parents.is_empty() => (here.is_some(), Vec::new()),
234	+	None => (true, parents),
235	+	};
236	+	for parent in follow {
237	+	self.push(parent)?;
238	+	}
239	+	Ok(Some((id, touches)))
240	+	}
241	+	}
242	+
243	+	/// What one path holds (id and mode), memoized per commit: each commit is
244	+	/// usually asked about again as the parent of the next one.
245	+	#[derive(Default)]
246	+	struct PathOids {
247	+	by_commit: HashMap<ObjectId, Option<(ObjectId, EntryKind)>>,
248	+	}
249	+
250	+	impl PathOids {
251	+	fn get(
252	+	&mut self,
253	+	repo: &gix::Repository,
254	+	commit: ObjectId,
255	+	path: &[u8],
256	+	) -> anyhow::Result<Option<(ObjectId, EntryKind)>> {
257	+	if let Some(found) = self.by_commit.get(&commit) {
258	+	return Ok(*found);
259	+	}
260	+	let found = tree::entry_at(repo, commit, path)?;
261	+	if self.by_commit.len() > 4096 {
262	+	self.by_commit.clear();
263	+	}
264	+	self.by_commit.insert(commit, found);
265	+	Ok(found)
266	+	}
267	+	}
		@@ -1,5 +1,7 @@
1	1		//! All repository access goes through this module; nothing else touches gix.
2	2
	3	+	pub mod diff;
	4	+	pub mod log;
3	5		pub mod refs;
4	6		pub mod tree;
5	7
		@@ -224,3 +226,102 @@ pub fn commit_count(repo: &gix::Repository, tip: ObjectId) -> anyhow::Result<u64
224	226		}
225	227		Ok(count)
226	228		}
	229	+
	230	+	/// Everything the commit page shows about a commit.
	231	+	#[derive(Debug, Clone)]
	232	+	pub struct CommitDetail {
	233	+	pub info: CommitInfo,
	234	+	/// The message after the subject line, trimmed.
	235	+	pub body: String,
	236	+	/// The full message as stored, for patches.
	237	+	pub message: String,
	238	+	pub author: Person,
	239	+	pub committer: Person,
	240	+	pub parents: Vec<ObjectId>,
	241	+	pub tree: ObjectId,
	242	+	}
	243	+
	244	+	#[derive(Debug, Clone, PartialEq, Eq)]
	245	+	pub struct Person {
	246	+	pub name: String,
	247	+	pub email: String,
	248	+	/// Unix seconds and the UTC offset in seconds, as recorded.
	249	+	pub time: i64,
	250	+	pub offset: i32,
	251	+	}
	252	+
	253	+	pub fn commit_detail(repo: &gix::Repository, id: ObjectId) -> anyhow::Result<CommitDetail> {
	254	+	let commit = repo.find_commit(id).context("commit not found")?;
	255	+	let decoded = commit.decode().context("malformed commit")?;
	256	+	let person = \|sig: gix::actor::SignatureRef<'_>\| {
	257	+	let time = sig.time().unwrap_or_default();
	258	+	Person {
	259	+	name: sig.name.to_str_lossy().trim().to_string(),
	260	+	email: sig.email.to_str_lossy().trim().to_string(),
	261	+	time: time.seconds,
	262	+	offset: time.offset,
	263	+	}
	264	+	};
	265	+	let message = decoded.message();
	266	+	Ok(CommitDetail {
	267	+	info: commit_info(repo, id)?,
	268	+	body: message
	269	+	.body()
	270	+	.map(\|b\| b.to_str_lossy().trim().to_string())
	271	+	.unwrap_or_default(),
	272	+	message: decoded.message.to_str_lossy().into_owned(),
	273	+	author: person(decoded.author().context("malformed author")?),
	274	+	committer: person(decoded.committer().context("malformed committer")?),
	275	+	parents: decoded.parents().collect(),
	276	+	tree: decoded.tree(),
	277	+	})
	278	+	}
	279	+
	280	+	/// A `.mailmap`: canonical names and emails for authors.
	281	+	#[derive(Default)]
	282	+	pub struct Mailmap(gix::mailmap::Snapshot);
	283	+
	284	+	impl Mailmap {
	285	+	pub fn parse(data: &[u8]) -> Self {
	286	+	Mailmap(gix::mailmap::Snapshot::from_bytes(data))
	287	+	}
	288	+
	289	+	/// Canonical `(name, email)` for an identity.
	290	+	pub fn resolve(&self, name: &str, email: &str) -> (String, String) {
	291	+	let signature = gix::actor::SignatureRef {
	292	+	name: name.as_bytes().as_bstr(),
	293	+	email: email.as_bytes().as_bstr(),
	294	+	time: "",
	295	+	};
	296	+	match self.0.try_resolve_ref(signature) {
	297	+	Some(found) => (
	298	+	found
	299	+	.name
	300	+	.map_or_else(\|\| name.to_string(), \|n\| n.to_str_lossy().into_owned()),
	301	+	found
	302	+	.email
	303	+	.map_or_else(\|\| email.to_string(), \|e\| e.to_str_lossy().into_owned()),
	304	+	),
	305	+	None => (name.to_string(), email.to_string()),
	306	+	}
	307	+	}
	308	+
	309	+	pub fn weight(&self) -> usize {
	310	+	self.0
	311	+	.iter()
	312	+	.map(\|e\| {
	313	+	64 + e.old_email().len()
	314	+	+ e.old_name().map_or(0, \|n\| n.len())
	315	+	+ e.new_email().map_or(0, \|n\| n.len())
	316	+	+ e.new_name().map_or(0, \|n\| n.len())
	317	+	})
	318	+	.sum()
	319	+	}
	320	+	}
	321	+
	322	+	/// The `.mailmap` blob at the root of `commit`, if there is one.
	323	+	pub fn mailmap_blob(repo: &gix::Repository, commit: ObjectId) -> Option<ObjectId> {
	324	+	let tree = repo.find_commit(commit).ok()?.tree().ok()?;
	325	+	let entry = tree.find_entry(".mailmap")?;
	326	+	entry.mode().is_blob().then(\|\| entry.object_id())
	327	+	}
		@@ -20,7 +20,7 @@ pub enum EntryKind {
20	20		}
21	21
22	22		impl EntryKind {
23		−	fn from_gix(kind: GixKind) -> Self {
	23	+	pub(super) fn from_gix(kind: GixKind) -> Self {
24	24		match kind {
25	25		GixKind::Tree => EntryKind::Tree,
26	26		GixKind::Blob => EntryKind::Blob,
		@@ -30,6 +30,12 @@ impl EntryKind {
30	30		}
31	31		}
32	32
	33	+	/// Same kind of object, ignoring the executable bit.
	34	+	pub fn same_type(self, other: EntryKind) -> bool {
	35	+	let regular = \|k\| matches!(k, EntryKind::Blob \| EntryKind::Executable);
	36	+	self == other \|\| (regular(self) && regular(other))
	37	+	}
	38	+
33	39		pub fn is_blob(self) -> bool {
34	40		matches!(
35	41		self,
		@@ -84,6 +90,22 @@ pub fn lookup(
84	90		}))
85	91		}
86	92
	93	+	/// Id and kind of whatever `path` names in `commit`'s tree. `None` when
	94	+	/// the path doesn't exist, or the commit itself is missing (shallow clones).
	95	+	pub fn entry_at(
	96	+	repo: &gix::Repository,
	97	+	commit: ObjectId,
	98	+	path: &[u8],
	99	+	) -> anyhow::Result<Option<(ObjectId, EntryKind)>> {
	100	+	let Ok(commit) = repo.find_commit(commit) else {
	101	+	return Ok(None);
	102	+	};
	103	+	let tree = commit.tree().context("commit has no tree")?;
	104	+	Ok(tree
	105	+	.lookup_entry_by_path(as_path(path))?
	106	+	.map(\|entry\| (entry.object_id(), EntryKind::from_gix(entry.mode().kind()))))
	107	+	}
	108	+
87	109		/// Entries of a tree: directories first, then files, each by name.
88	110		pub fn list(repo: &gix::Repository, tree: ObjectId) -> anyhow::Result<Vec<TreeEntry>> {
89	111		let tree = repo.find_tree(tree).context("tree not found")?;
		@@ -44,6 +44,7 @@ pub struct BlobPage {
44	44		/// `412 lines`, `12.4 KB`, `Rust`.
45	45		pub facts: Vec<String>,
46	46		pub raw_url: String,
	47	+	pub log_url: String,
47	48		pub download_url: String,
48	49		pub toggle: Option<ViewToggle>,
49	50		pub body: Body,
		@@ -132,24 +133,14 @@ pub fn page(ctx: &Ctx, segments: &[Vec<u8>]) -> Response {
132	133		html: html.unwrap_or_else(\|never\| match never {}),
133	134		}
134	135		} else {
135		−	let first_line = text.lines().next().unwrap_or_default();
136		−	let syntax = highlight::detect(&path_str, first_line);
137		−	language = syntax.map(\|s\| s.name.clone());
138		−	let lines = match syntax {
139		−	Some(syntax) if size <= ctx.config.ui.max_highlight_kb * 1024 => {
140		−	let key = Key::Highlight {
141		−	blob: oid,
142		−	syntax: syntax.name.clone(),
143		−	};
144		−	ctx.state
145		−	.cache
146		−	.lines(key, \|\| {
147		−	Ok::<_, std::convert::Infallible>(highlight::lines(&text, syntax))
148		−	})
149		−	.unwrap_or_else(\|never\| match never {})
150		−	}
151		−	_ => Arc::new(highlight::plain_lines(&text)),
152		−	};
	136	+	let (lines, lang) = highlight::cached_lines(
	137	+	&ctx.state.cache,
	138	+	oid,
	139	+	&path_str,
	140	+	&text,
	141	+	ctx.config.ui.max_highlight_kb * 1024,
	142	+	);
	143	+	language = lang.map(str::to_string);
153	144		Body::Code { lines }
154	145		}
155	146		}
		@@ -173,6 +164,7 @@ pub fn page(ctx: &Ctx, segments: &[Vec<u8>]) -> Response {
173	164		here: Some(name),
174	165		facts,
175	166		download_url: format!("{raw_url}?download"),
	167	+	log_url: ctx.url("log", &rev.name, &path),
176	168		raw_url,
177	169		toggle,
178	170		body,
	@@ -0,0 +1,375 @@
1	+	//! `/{repo}/commit/{rev}` — message, metadata, diffstat and the unified
2	+	//! diff against the first parent (`?context=N`, `?ws=ignore`).
3	+	//! `/{repo}/commit/{rev}.patch` — the same as a plain-text patch.
4	+
5	+	use askama::Template;
6	+	use axum::http::{HeaderValue, StatusCode, header};
7	+	use axum::response::{IntoResponse, Response};
8	+	use gix::bstr::ByteSlice;
9	+
10	+	use super::raw::RAW_CSP;
11	+	use super::repo::{Active, Crumb, Ctx, RepoNav, set_cache_headers, short};
12	+	use super::{Layout, render};
13	+	use crate::cache::Key;
14	+	use crate::git::diff::Status;
15	+	use crate::git::refs::{self, Rev};
16	+	use crate::git::{self, CommitDetail};
17	+	use crate::render::diff::{self, Body, CommitDiff, FileDiff};
18	+	use crate::render::time;
19	+
20	+	const DEFAULT_CONTEXT: u32 = 3;
21	+	const MAX_CONTEXT: u32 = 50;
22	+
23	+	pub struct Meta {
24	+	pub label: &'static str,
25	+	pub value: String,
26	+	pub title: Option<String>,
27	+	pub links: Vec<(String, String)>,
28	+	}
29	+
30	+	pub struct FileRow<'a> {
31	+	pub file: &'a FileDiff,
32	+	pub anchor: String,
33	+	pub path: String,
34	+	/// Source path of a rename or copy.
35	+	pub from: Option<String>,
36	+	pub status: &'static str,
37	+	/// Single-letter status (`A`, `M`, `D`, `R`, `C`).
38	+	pub letter: &'static str,
39	+	/// Five blocks: `add`, `del` or `none`.
40	+	pub bar: [&'static str; 5],
41	+	/// The file at this commit (or its parent, for deletions).
42	+	pub url: Option<String>,
43	+	}
44	+
45	+	pub struct Toggle {
46	+	pub label: &'static str,
47	+	pub url: String,
48	+	pub active: bool,
49	+	}
50	+
51	+	#[derive(Template)]
52	+	#[template(path = "commit.html")]
53	+	pub struct CommitPage<'a> {
54	+	pub layout: Layout,
55	+	pub nav: RepoNav,
56	+	pub crumbs: Vec<Crumb>,
57	+	pub here: Option<String>,
58	+	pub subject: String,
59	+	pub body: String,
60	+	pub meta: Vec<Meta>,
61	+	pub added: u64,
62	+	pub removed: u64,
63	+	pub files: Vec<FileRow<'a>>,
64	+	pub diff: &'a CommitDiff,
65	+	pub patch_url: String,
66	+	pub tree_url: String,
67	+	pub ws_toggle: Vec<Toggle>,
68	+	pub context_less: Option<String>,
69	+	pub context_more: Option<String>,
70	+	pub context: u32,
71	+	}
72	+
73	+	pub fn page(ctx: &Ctx, segments: &[Vec<u8>]) -> Response {
74	+	let Some((rev, patch)) = resolve(ctx, segments) else {
75	+	return ctx.not_found("UNKNOWN REVISION");
76	+	};
77	+	let context = ctx
78	+	.query
79	+	.context
80	+	.as_deref()
81	+	.and_then(\|c\| c.parse::<u32>().ok())
82	+	.map_or(DEFAULT_CONTEXT, \|c\| c.min(MAX_CONTEXT));
83	+	let ignore_ws = ctx.query.ws.as_deref() == Some("ignore");
84	+	let etag = if patch {
85	+	ctx.etag(("patch", rev.commit))
86	+	} else {
87	+	ctx.etag(("commit", rev.commit, context, ignore_ws))
88	+	};
89	+	let immutable = rev.is_immutable();
90	+	if let Some(res) = ctx.not_modified(&etag, immutable) {
91	+	return res;
92	+	}
93	+	let detail = match git::commit_detail(&ctx.git, rev.commit) {
94	+	Ok(detail) => detail,
95	+	Err(e) => return ctx.internal_error(e),
96	+	};
97	+	let changes = match git::diff::changes(&ctx.git, rev.commit) {
98	+	Ok(changes) => changes,
99	+	Err(e) => return ctx.internal_error(e),
100	+	};
101	+	if patch {
102	+	return match diff::patch(&ctx.git, &detail, &changes) {
103	+	Ok(text) => {
104	+	let mut res = text.into_response();
105	+	let headers = res.headers_mut();
106	+	headers.insert(
107	+	header::CONTENT_TYPE,
108	+	HeaderValue::from_static("text/plain; charset=utf-8"),
109	+	);
110	+	headers.insert(
111	+	header::CONTENT_SECURITY_POLICY,
112	+	HeaderValue::from_static(RAW_CSP),
113	+	);
114	+	headers.insert(
115	+	header::X_CONTENT_TYPE_OPTIONS,
116	+	HeaderValue::from_static("nosniff"),
117	+	);
118	+	set_cache_headers(&mut res, &etag, immutable);
119	+	res
120	+	}
121	+	Err(e) => ctx.internal_error(e),
122	+	};
123	+	}
124	+
125	+	let options = diff::Options {
126	+	context,
127	+	ignore_ws,
128	+	max_files: ctx.config.limits.diff_files,
129	+	max_lines: ctx.config.limits.diff_lines,
130	+	max_file_lines: ctx.config.limits.diff_file_lines,
131	+	max_blob_bytes: ctx.config.ui.max_blob_kb * 1024,
132	+	max_highlight_bytes: ctx.config.ui.max_highlight_kb * 1024,
133	+	};
134	+	let key = Key::Diff {
135	+	commit: rev.commit,
136	+	options,
137	+	};
138	+	let built = ctx.state.cache.diff(key, \|\| {
139	+	diff::build(&ctx.git, &ctx.state.cache, &changes, &options)
140	+	});
141	+	let built = match built {
142	+	Ok(built) => built,
143	+	Err(e) => return ctx.internal_error(e),
144	+	};
145	+
146	+	let mut page = commit_page(ctx, &rev, &detail, &built, changes.parent);
147	+	page.context = context;
148	+	let base = ctx.commit_url(&rev.commit);
149	+	let url = \|context: u32, ignore_ws: bool\| {
150	+	let mut params = Vec::new();
151	+	if context != DEFAULT_CONTEXT {
152	+	params.push(format!("context={context}"));
153	+	}
154	+	if ignore_ws {
155	+	params.push("ws=ignore".to_string());
156	+	}
157	+	if params.is_empty() {
158	+	base.clone()
159	+	} else {
160	+	format!("{base}?{}", params.join("&"))
161	+	}
162	+	};
163	+	page.ws_toggle = vec![
164	+	Toggle {
165	+	label: "Whitespace",
166	+	url: url(context, false),
167	+	active: !ignore_ws,
168	+	},
169	+	Toggle {
170	+	label: "Ignore",
171	+	url: url(context, true),
172	+	active: ignore_ws,
173	+	},
174	+	];
175	+	page.context_less = (context > 0).then(\|\| url(context.saturating_sub(3), ignore_ws));
176	+	page.context_more =
177	+	(context < MAX_CONTEXT).then(\|\| url((context + 3).min(MAX_CONTEXT), ignore_ws));
178	+
179	+	let mut res = render(StatusCode::OK, &page);
180	+	set_cache_headers(&mut res, &etag, immutable);
181	+	res
182	+	}
183	+
184	+	/// The revision and whether a patch was asked for. `{rev}.patch` is a
185	+	/// patch unless a ref with that literal name exists.
186	+	fn resolve(ctx: &Ctx, segments: &[Vec<u8>]) -> Option<(Rev, bool)> {
187	+	let name = std::str::from_utf8(&segments.join(&b'/')).ok()?.to_string();
188	+	if name.is_empty() {
189	+	return None;
190	+	}
191	+	if let Some(stem) = name.strip_suffix(".patch")
192	+	&& let Some(rev) = refs::resolve(&ctx.git, stem)
193	+	&& refs::resolve(&ctx.git, &name).is_none()
194	+	{
195	+	return Some((rev, true));
196	+	}
197	+	refs::resolve(&ctx.git, &name).map(\|rev\| (rev, false))
198	+	}
199	+
200	+	fn commit_page<'a>(
201	+	ctx: &Ctx,
202	+	rev: &Rev,
203	+	detail: &CommitDetail,
204	+	built: &'a CommitDiff,
205	+	parent: Option<git::ObjectId>,
206	+	) -> CommitPage<'a> {
207	+	let mailmap = ctx.mailmap();
208	+	let id = detail.info.id.to_string();
209	+	let (author, author_email) = mailmap.resolve(&detail.author.name, &detail.author.email);
210	+	let (committer, committer_email) =
211	+	mailmap.resolve(&detail.committer.name, &detail.committer.email);
212	+
213	+	let mut meta = vec![Meta {
214	+	label: "Author",
215	+	value: author.clone(),
216	+	title: Some(author_email.clone()),
217	+	links: Vec::new(),
218	+	}];
219	+	meta.push(Meta {
220	+	label: "Date",
221	+	value: time::local(detail.author.time, detail.author.offset),
222	+	title: Some(time::iso(detail.author.time)),
223	+	links: Vec::new(),
224	+	});
225	+	if (&committer, &committer_email) != (&author, &author_email)
226	+	\|\| detail.committer.time != detail.author.time
227	+	{
228	+	meta.push(Meta {
229	+	label: "Committer",
230	+	value: format!(
231	+	"{committer} · {}",
232	+	time::local(detail.committer.time, detail.committer.offset)
233	+	),
234	+	title: Some(committer_email),
235	+	links: Vec::new(),
236	+	});
237	+	}
238	+	meta.push(Meta {
239	+	label: if detail.parents.len() == 1 {
240	+	"Parent"
241	+	} else {
242	+	"Parents"
243	+	},
244	+	value: if detail.parents.is_empty() {
245	+	"None".into()
246	+	} else {
247	+	String::new()
248	+	},
249	+	title: None,
250	+	links: detail
251	+	.parents
252	+	.iter()
253	+	.map(\|p\| (short(&p.to_string()), ctx.commit_url(p)))
254	+	.collect(),
255	+	});
256	+	meta.push(Meta {
257	+	label: "Commit",
258	+	value: id.clone(),
259	+	title: None,
260	+	links: Vec::new(),
261	+	});
262	+
263	+	let tree_url = ctx.url("tree", &id, b"");
264	+	let parent_id = parent.map(\|p\| p.to_string());
265	+	let files = built
266	+	.files
267	+	.iter()
268	+	.enumerate()
269	+	.map(\|(i, file)\| {
270	+	let change = &file.change;
271	+	let path = change.path().to_str_lossy().into_owned();
272	+	let url = match change.status {
273	+	Status::Deleted => parent_id
274	+	.as_ref()
275	+	.map(\|p\| ctx.url("blob", p, change.path())),
276	+	_ => Some(ctx.url("blob", &id, change.path())),
277	+	};
278	+	let from = match change.status {
279	+	Status::Renamed \| Status::Copied => change
280	+	.old
281	+	.as_ref()
282	+	.map(\|o\| o.path.to_str_lossy().into_owned()),
283	+	_ => None,
284	+	};
285	+	let (status, letter) = match change.status {
286	+	Status::Added => ("Added", "A"),
287	+	Status::Deleted => ("Deleted", "D"),
288	+	Status::Modified => ("Modified", "M"),
289	+	Status::Renamed => ("Renamed", "R"),
290	+	Status::Copied => ("Copied", "C"),
291	+	};
292	+	// Submodules and binaries have no line counts but still have
293	+	// a URL; only blobs get one.
294	+	let url = url.filter(\|_\| !matches!(file.body, Body::Submodule { .. }));
295	+	FileRow {
296	+	file,
297	+	anchor: format!("f{}", i + 1),
298	+	path,
299	+	from,
300	+	status,
301	+	letter,
302	+	bar: bar(file.stat),
303	+	url,
304	+	}
305	+	})
306	+	.collect();
307	+
308	+	CommitPage {
309	+	layout: Layout::new(
310	+	ctx.state,
311	+	ctx.config,
312	+	Some(&format!("{} · {}", detail.info.subject, ctx.repo.name)),
313	+	),
314	+	nav: ctx.nav(Active::Log, Some(rev), \|name\| ctx.url("log", name, b"")),
315	+	crumbs: vec![Crumb {
316	+	name: ctx.repo.name.clone(),
317	+	url: ctx.repo_url(),
318	+	}],
319	+	here: Some(short(&id)),
320	+	subject: detail.info.subject.clone(),
321	+	body: detail.body.clone(),
322	+	meta,
323	+	added: built.added,
324	+	removed: built.removed,
325	+	files,
326	+	diff: built,
327	+	patch_url: format!("{}.patch", ctx.commit_url(&detail.info.id)),
328	+	tree_url,
329	+	ws_toggle: Vec::new(),
330	+	context_less: None,
331	+	context_more: None,
332	+	context: DEFAULT_CONTEXT,
333	+	}
334	+	}
335	+
336	+	/// Five blocks split between additions and removals; fewer than five
337	+	/// changed lines leave the rest empty.
338	+	fn bar(stat: Option<(u32, u32)>) -> [&'static str; 5] {
339	+	let mut out = ["none"; 5];
340	+	let Some((added, removed)) = stat else {
341	+	return out;
342	+	};
343	+	let total = added + removed;
344	+	if total == 0 {
345	+	return out;
346	+	}
347	+	let filled = total.min(5);
348	+	let mut adds = ((filled * added) as f64 / total as f64).round() as u32;
349	+	// Keep at least one block for each side that changed.
350	+	if added > 0 && adds == 0 {
351	+	adds = 1;
352	+	}
353	+	if removed > 0 && adds == filled {
354	+	adds = filled - 1;
355	+	}
356	+	for (i, slot) in out.iter_mut().enumerate().take(filled as usize) {
357	+	*slot = if (i as u32) < adds { "add" } else { "del" };
358	+	}
359	+	out
360	+	}
361	+
362	+	#[cfg(test)]
363	+	mod tests {
364	+	use super::bar;
365	+
366	+	#[test]
367	+	fn diffstat_bars() {
368	+	assert_eq!(bar(None), ["none"; 5]);
369	+	assert_eq!(bar(Some((0, 0))), ["none"; 5]);
370	+	assert_eq!(bar(Some((2, 0))), ["add", "add", "none", "none", "none"]);
371	+	assert_eq!(bar(Some((100, 1))), ["add", "add", "add", "add", "del"]);
372	+	assert_eq!(bar(Some((1, 100))), ["add", "del", "del", "del", "del"]);
373	+	assert_eq!(bar(Some((30, 20))), ["add", "add", "add", "del", "del"]);
374	+	}
375	+	}