1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
package main
import (
"flag"
"fmt"
"io/fs"
"os"
"path"
"path/filepath"
"runtime/pprof"
"slices"
"strings"
"time"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/martinlehoux/kagamigo/kcore"
"github.com/samber/lo"
"github.com/schollz/progressbar/v3"
"golang.org/x/exp/slog"
)
type Record struct {
keyword string
path string
line int
date time.Time
}
var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
var sortBy = flag.String("sort", "date", "Sort by date or random")
var maxRecords = flag.Int("max", 25, "Maximum number of records to display")
var repoPath = flag.String("repo", ".", "Path to the repository")
var afterS = flag.String("after", "2022-09-01", "Only show records after this date")
func main() {
var err error
flag.Parse()
after, err := time.Parse(time.DateOnly, *afterS)
kcore.Expect(err, "Error parsing date")
excludes := []string{".venv", ".git", ".ruff_cache", "db_dumps", ".mypy_cache", "uploads", "__pycache__", ".coverage"}
keywords := []string{"# TODO"}
records := []Record{}
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
kcore.Expect(err, "Error creating CPU profile")
kcore.Expect(pprof.StartCPUProfile(f), "Error starting CPU profile")
defer pprof.StopCPUProfile()
}
slog.Info("Scanning repository", "repo", *repoPath, "sort", *sortBy, "max", *maxRecords)
repo, err := git.PlainOpen(path.Join(*repoPath, ".git"))
// repo, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{URL: path.Join(*repoPath, ".git")})
kcore.Expect(err, "Error opening repository")
ref, err := repo.Head()
kcore.Expect(err, "Error getting HEAD")
head, err := repo.CommitObject(ref.Hash())
kcore.Expect(err, "Error getting commit object")
progress := progressbar.Default(-1, "Scanning")
err = filepath.WalkDir(*repoPath, func(path string, d fs.DirEntry, err error) error {
relativePath := strings.TrimPrefix(path, *repoPath+"/")
if err != nil {
return err
}
if slices.Contains(excludes, d.Name()) {
return filepath.SkipDir
}
if d.Type()&fs.ModeSymlink != 0 {
return nil
}
if !d.IsDir() {
kcore.Expect(progress.Add(1), "Error incrementing progress")
return processFile(*repoPath, relativePath, keywords, &records, head)
}
return nil
})
kcore.Expect(err, "Error walking directory")
records = lo.Filter(records, func(record Record, index int) bool { return record.date.After(after) })
if *sortBy == "random" {
records = lo.Shuffle(records)
} else {
slices.SortFunc(records, func(a, b Record) int { return -int(a.date.Sub(b.date).Nanoseconds()) })
}
fmt.Println("")
for _, record := range records[:*maxRecords] {
fmt.Printf("%s\t %s:%d\n", record.date.Format("2006-01-02"), record.path, record.line)
}
}
type MatchingLine struct {
line int
keyword string
}
func processFile(repoPath string, relativePath string, keywords []string, records *[]Record, head *object.Commit) error {
absolutePath := path.Join(repoPath, relativePath)
content, err := os.ReadFile(absolutePath) // #nosec G304
if err != nil {
return err
}
lines := strings.Split(string(content), "\n")
matchingLines := lo.FilterMap(lines, func(line string, i int) (MatchingLine, bool) {
for _, keyword := range keywords {
if strings.Contains(line, keyword) {
return MatchingLine{i + 1, keyword}, true
}
}
return MatchingLine{}, false
})
if len(matchingLines) == 0 {
return nil
}
recordExtractor := NewStatRecordExtractor(absolutePath)
// recordExtractor = NewGoGitRecordExtractor(head, relativePath)
// recordExtractor := &GitRecordExtractor{repoPath: repoPath}
if recordExtractor == nil {
return nil
}
for _, line := range matchingLines {
*records = append(*records, recordExtractor.Extract(line.keyword, relativePath, line.line))
}
return nil
}
|
