peezy-tech/jojo
2
0
Fork 0
mirror of https://codeberg.org/forgejo/forgejo.git synced 2026-05-12 22:10:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix: relocate PR review comments using git blame --reverse, improving comment placement (#12015)

Browse source 
When a review comment is placed on a PR in Forgejo, Forgejo performs a `git blame` to identify which commit originated the line, and records that commit and line number in the comment's database record.  Later when the review is viewed, Forgejo currently makes no effort to place that comment in the correct *current* location, which may vary -- for example, if a PR had two commits and the comment was made on a line in the first commit, but the second commit changes line numbers in that file, the comment will appear in the incorrect location.

This PR adds the usage of `git blame --reverse` to calculate the correct location to display the comment in the current view (whether reviewing the PR commit-by-commit, or "Files changed").  It certainly does not fix all problems with comment placement (see comments).

Another major addition in this PR is a test harness for making relatively complex PRs and reviewing the diffs on the per-commit view and PR-diff views.

## Checklist

The [contributor guide](https://forgejo.org/docs/next/contributor/) contains information that will be helpful to first time contributors. All work and communication must conform to Forgejo's [AI Agreement](https://codeberg.org/forgejo/governance/src/branch/main/AIAgreement.md). There also are a few [conditions for merging Pull Requests in Forgejo repositories](https://codeberg.org/forgejo/governance/src/branch/main/PullRequestsAgreement.md). You are also welcome to join the [Forgejo development chatroom](https://matrix.to/#/#forgejo-development:matrix.org).

### Tests for Go changes

- I added test coverage for Go changes...
  - [x] in their respective `*_test.go` for unit tests.
  - [x] in the `tests/integration` directory if it involves interactions with a live Forgejo server.
- I ran...
  - [ ] `make pr-go` before pushing

### Documentation

- [ ] I created a pull request [to the documentation](https://codeberg.org/forgejo/docs) to explain to Forgejo users how to use this change.
- [x] I did not document these changes and I do not expect someone else to do it.

### Release notes

- [x] This change will be noticed by a Forgejo user or admin (feature, bug fix, performance, etc.). I suggest to include a release note for this change.
- [ ] This change is not visible to a Forgejo user or admin (refactor, dependency upgrade, etc.). I think there is no need to add a release note for this change.

<!--start release-notes-assistant-->

## Release notes
<!--URL:https://codeberg.org/forgejo/forgejo-->
- Bug fixes
  - [PR](https://codeberg.org/forgejo/forgejo/pulls/12015): <!--number 12015 --><!--line 0 --><!--description cmVsb2NhdGUgUFIgcmV2aWV3IGNvbW1lbnRzIHVzaW5nIGBnaXQgYmxhbWUgLS1yZXZlcnNlYCwgaW1wcm92aW5nIGNvbW1lbnQgcGxhY2VtZW50-->relocate PR review comments using `git blame --reverse`, improving comment placement<!--description-->
<!--end release-notes-assistant-->

Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/12015
Reviewed-by: Andreas Ahlenstorf <aahlenst@noreply.codeberg.org>
Co-authored-by: Mathieu Fenniak <mathieu@fenniak.net>
Co-committed-by: Mathieu Fenniak <mathieu@fenniak.net>
This commit is contained in:
Mathieu Fenniak 2026-04-11 21:45:39 +02:00 • committed by Mathieu Fenniak
parent 92b95414e8
commit 9fe0cbee02
9 changed files with 936 additions and 19 deletions
Download patch file Download diff file Expand all files Collapse all files

53
models/issues/comment.go
View file

@ -19,7 +19,9 @@ import (
project_model "forgejo.org/models/project"
repo_model "forgejo.org/models/repo"
user_model "forgejo.org/models/user"
"forgejo.org/modules/cache"
"forgejo.org/modules/container"
"forgejo.org/modules/git"
"forgejo.org/modules/gitrepo"
"forgejo.org/modules/json"
"forgejo.org/modules/log"
@ -321,6 +323,8 @@ type Comment struct {
CommitsNum int64 `xorm:"-"`
IsForcePush bool `xorm:"-"`
reverseLineBlame *git.ReverseLineBlame `xorm:"-"`
// If you add new fields that might be used to store abusive content (mainly string fields),
// please also add them in the CommentData struct and the corresponding constructor.
}
@ -744,6 +748,55 @@ func (c *Comment) UnsignedLine() uint64 {
return uint64(c.Line)
}
func (c *Comment) ResolveCurrentLine(ctx context.Context, repo *repo_model.Repository, currentHead string) (*git.ReverseLineBlame, error) {
if c.reverseLineBlame != nil {
return c.reverseLineBlame, nil
}
// When a PR is viewed, the requirement to perform `git blame --reverse...` on every comment is a bit of a
// performance risk. To minimize this risk, cache the results relative to the requested head, so it only needs to be
// recalculated when head changes (or on cache eviction).
//
// Some performance testing was done which showed that a hot cache is much faster than the blame reverse
// operation -- 500-1000x runtime difference:
//
// - cache miss (Forgejo repo) took 7,690,574 ns
// - cache miss (~1000 commit repo) took 1,671,223 ns
// - cache hit (in-memory adapter) took 3,710 ns
// - cache hit (redis adapter) took 77,311 ns
resolveJSON, err := cache.GetString(fmt.Sprintf("comment.Resolve;ID=%d;HEAD=%s", c.ID, currentHead), func() (string, error) {
gitRepo, closer, err := gitrepo.RepositoryFromContextOrOpen(ctx, repo)
if err != nil {
return "", fmt.Errorf("failed to open repo: %w", err)
}
defer closer.Close()
reverseBlame, err := gitRepo.ReverseLineBlame(c.CommitSHA, c.TreePath, c.UnsignedLine(), currentHead)
if err != nil {
return "", fmt.Errorf("failed to perform `git blame --reverse` to resolve current line for comment (id=%d): %w", c.ID, err)
}
data, err := json.Marshal(reverseBlame)
if err != nil {
return "", err
}
return string(data), nil
})
if err != nil {
return nil, err
}
var reverseBlame *git.ReverseLineBlame
err = json.Unmarshal([]byte(resolveJSON), &reverseBlame)
if err != nil {
return nil, err
}
c.reverseLineBlame = reverseBlame
return c.reverseLineBlame, nil
}
// CodeCommentLink returns the url to a comment in code
func (c *Comment) CodeCommentLink(ctx context.Context) string {
err := c.LoadIssue(ctx)

56
models/issues/comment_code.go
View file

@ -7,7 +7,10 @@ import (
"context"
"forgejo.org/models/db"
repo_model "forgejo.org/models/repo"
user_model "forgejo.org/models/user"
"forgejo.org/modules/git"
"forgejo.org/modules/log"
"forgejo.org/modules/markup"
"forgejo.org/modules/markup/markdown"
@ -23,33 +26,62 @@ type CodeConversationsAtLine map[int64][]CodeConversation
// CodeConversationsAtLineAndTreePath contains the conversations for a given TreePath and line
type CodeConversationsAtLineAndTreePath map[string]CodeConversationsAtLine
func newCodeConversationsAtLineAndTreePath(comments []*Comment) CodeConversationsAtLineAndTreePath {
func newCodeConversationsAtLineAndTreePath(ctx context.Context, comments []*Comment, repo *repo_model.Repository, headCommitID string) (CodeConversationsAtLineAndTreePath, error) {
tree := make(CodeConversationsAtLineAndTreePath)
for _, comment := range comments {
tree.insertComment(comment)
blame, err := comment.ResolveCurrentLine(ctx, repo, headCommitID)
if err != nil {
// ResolveCurrentLine can fail in at least one known situation -- where a comment is left on a line in a
// file that is being deleted. The blame would be for the commit that deleted the file, and a reverse git
// blame won't work because the file is missing in the target sha.
log.Warn("ResolveCurrentLine failed: %s", err.Error())
// handle gracefully -- insertComment will use the original values which may be usable
blame = nil
} else if blame.CommitID != headCommitID {
// Commit was made on a line that can't be reverse-blamed to the currently viewing head. This can happen
// because:
// - line of code was removed between the commit it was tagged on, and the head commit
// - force push on the repo caused there to be no git relationship between blame.CommitID->headCommitID
// We won't insert this comment into the comment tree because we don't know where to place it; it may appear
// when the user views a different commit in the PR, and it will always appear on the "Conversations" tab.
continue
}
tree.insertComment(comment, blame)
}
return tree
return tree, nil
}
func (tree CodeConversationsAtLineAndTreePath) insertComment(comment *Comment) {
func (tree CodeConversationsAtLineAndTreePath) insertComment(comment *Comment, blame *git.ReverseLineBlame) {
treePath := comment.TreePath
line := comment.Line
if blame != nil {
treePath = blame.FilePath
line = int64(blame.LineNumber)
if comment.Line < 0 {
line *= -1
}
}
// attempt to append comment to existing conversations (i.e. list of comments belonging to the same review)
for i, conversation := range tree[comment.TreePath][comment.Line] {
for i, conversation := range tree[treePath][line] {
if conversation[0].ReviewID == comment.ReviewID {
tree[comment.TreePath][comment.Line][i] = append(conversation, comment)
tree[treePath][line][i] = append(conversation, comment)
return
}
}
// no previous conversation was found at this line, create it
if tree[comment.TreePath] == nil {
tree[comment.TreePath] = make(map[int64][]CodeConversation)
if tree[treePath] == nil {
tree[treePath] = make(map[int64][]CodeConversation)
}
tree[comment.TreePath][comment.Line] = append(tree[comment.TreePath][comment.Line], CodeConversation{comment})
tree[treePath][line] = append(tree[treePath][line], CodeConversation{comment})
}
// FetchCodeConversations will return a 2d-map: ["Path"]["Line"] = List of CodeConversation (one per review) for this line
func FetchCodeConversations(ctx context.Context, issue *Issue, doer *user_model.User, showOutdatedComments bool) (CodeConversationsAtLineAndTreePath, error) {
// FetchCodeConversations will return a 2d-map: ["Path"]["Line"] = List of CodeConversation (one per review) for this
// line. headCommitID will be used to reverse-blame the comment into the correct path & line for the current context
// that is being viewed.
func FetchCodeConversations(ctx context.Context, issue *Issue, doer *user_model.User, showOutdatedComments bool, headCommitID string) (CodeConversationsAtLineAndTreePath, error) {
opts := FindCommentsOptions{
Type: CommentTypeCode,
IssueID: issue.ID,
@ -59,7 +91,7 @@ func FetchCodeConversations(ctx context.Context, issue *Issue, doer *user_model.
return nil, err
}
return newCodeConversationsAtLineAndTreePath(comments), nil
return newCodeConversationsAtLineAndTreePath(ctx, comments, issue.Repo, headCommitID)
}
// CodeComments represents comments on code by using this structure: FILENAME -> LINE (+ == proposed; - == previous) -> COMMENTS

4
models/issues/comment_test.go
View file

@ -63,7 +63,7 @@ func TestFetchCodeConversations(t *testing.T) {
unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 4}),
user, true))
res, err := issues_model.FetchCodeConversations(db.DefaultContext, issue, user, false)
res, err := issues_model.FetchCodeConversations(db.DefaultContext, issue, user, false, "")
require.NoError(t, err)
require.Contains(t, res, "README.md")
require.Contains(t, res["README.md"], int64(4))
@ -77,7 +77,7 @@ func TestFetchCodeConversations(t *testing.T) {
assert.NotNil(t, r.User)
user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
res, err = issues_model.FetchCodeConversations(db.DefaultContext, issue, user2, false)
res, err = issues_model.FetchCodeConversations(db.DefaultContext, issue, user2, false, "")
require.NoError(t, err)
assert.Len(t, res, 1)
}