1
0
mirror of https://github.com/go-gitea/gitea.git synced 2024-12-30 04:18:06 +08:00
gitea/modules/git/blame.go

151 lines
3.6 KiB
Go
Raw Normal View History

2019-04-20 10:47:00 +08:00
// Copyright 2019 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package git
2019-04-20 10:47:00 +08:00
import (
"bufio"
"context"
2019-04-20 10:47:00 +08:00
"fmt"
"io"
"os"
"os/exec"
"regexp"
"code.gitea.io/gitea/modules/process"
)
// BlamePart represents block of blame - continuous lines with one sha
type BlamePart struct {
Sha string
Lines []string
}
// BlameReader returns part of file blame one by one
type BlameReader struct {
cmd *exec.Cmd
output io.ReadCloser
reader *bufio.Reader
lastSha *string
cancel context.CancelFunc // Cancels the context that this reader runs in
finished process.FinishedFunc // Tells the process manager we're finished and it can remove the associated process from the process table
2019-04-20 10:47:00 +08:00
}
var shaLineRegex = regexp.MustCompile("^([a-z0-9]{40})")
// NextPart returns next part of blame (sequential code lines with the same commit)
2019-04-20 10:47:00 +08:00
func (r *BlameReader) NextPart() (*BlamePart, error) {
var blamePart *BlamePart
reader := r.reader
2019-04-20 10:47:00 +08:00
if r.lastSha != nil {
2019-06-13 03:41:28 +08:00
blamePart = &BlamePart{*r.lastSha, make([]string, 0)}
2019-04-20 10:47:00 +08:00
}
var line []byte
var isPrefix bool
var err error
for err != io.EOF {
line, isPrefix, err = reader.ReadLine()
if err != nil && err != io.EOF {
return blamePart, err
}
2019-04-20 10:47:00 +08:00
if len(line) == 0 {
// isPrefix will be false
2019-04-20 10:47:00 +08:00
continue
}
lines := shaLineRegex.FindSubmatch(line)
2019-04-20 10:47:00 +08:00
if lines != nil {
sha1 := string(lines[1])
2019-04-20 10:47:00 +08:00
if blamePart == nil {
2019-06-13 03:41:28 +08:00
blamePart = &BlamePart{sha1, make([]string, 0)}
2019-04-20 10:47:00 +08:00
}
if blamePart.Sha != sha1 {
r.lastSha = &sha1
// need to munch to end of line...
for isPrefix {
_, isPrefix, err = reader.ReadLine()
if err != nil && err != io.EOF {
return blamePart, err
}
}
2019-04-20 10:47:00 +08:00
return blamePart, nil
}
} else if line[0] == '\t' {
code := line[1:]
blamePart.Lines = append(blamePart.Lines, string(code))
}
// need to munch to end of line...
for isPrefix {
_, isPrefix, err = reader.ReadLine()
if err != nil && err != io.EOF {
return blamePart, err
}
2019-04-20 10:47:00 +08:00
}
}
r.lastSha = nil
return blamePart, nil
}
// Close BlameReader - don't run NextPart after invoking that
func (r *BlameReader) Close() error {
defer r.finished() // Only remove the process from the process table when the underlying command is closed
r.cancel() // However, first cancel our own context early
_ = r.output.Close()
2019-04-20 10:47:00 +08:00
if err := r.cmd.Wait(); err != nil {
return fmt.Errorf("Wait: %w", err)
2019-04-20 10:47:00 +08:00
}
return nil
}
// CreateBlameReader creates reader for given repository, commit and file
func CreateBlameReader(ctx context.Context, repoPath, commitID, file string) (*BlameReader, error) {
return createBlameReader(ctx, repoPath, GitExecutable, "blame", commitID, "--porcelain", "--", file)
2019-04-20 10:47:00 +08:00
}
func createBlameReader(ctx context.Context, dir string, command ...string) (*BlameReader, error) {
// Here we use the provided context - this should be tied to the request performing the blame so that it does not hang around.
ctx, cancel, finished := process.GetManager().AddContext(ctx, fmt.Sprintf("GetBlame [repo_path: %s]", dir))
cmd := exec.CommandContext(ctx, command[0], command[1:]...)
2019-04-20 10:47:00 +08:00
cmd.Dir = dir
cmd.Stderr = os.Stderr
process.SetSysProcAttribute(cmd)
2019-04-20 10:47:00 +08:00
stdout, err := cmd.StdoutPipe()
if err != nil {
defer finished()
return nil, fmt.Errorf("StdoutPipe: %w", err)
2019-04-20 10:47:00 +08:00
}
if err = cmd.Start(); err != nil {
defer finished()
_ = stdout.Close()
return nil, fmt.Errorf("Start: %w", err)
2019-04-20 10:47:00 +08:00
}
reader := bufio.NewReader(stdout)
2019-04-20 10:47:00 +08:00
return &BlameReader{
cmd: cmd,
output: stdout,
reader: reader,
cancel: cancel,
finished: finished,
2019-04-20 10:47:00 +08:00
}, nil
}