442 lines
11 KiB
Go
442 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"embed"
|
|
"errors"
|
|
"fmt"
|
|
"html/template"
|
|
"io"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/alecthomas/kong"
|
|
"github.com/go-git/go-git/v5"
|
|
"github.com/go-git/go-git/v5/plumbing/object"
|
|
)
|
|
|
|
type RepoDir struct {
|
|
Name string
|
|
Description string
|
|
Owner string
|
|
LastCommit time.Time
|
|
}
|
|
|
|
// ToDo: replace has* with the filename, as it can be bare or .md
|
|
type RepoInfo struct {
|
|
Name string
|
|
Description string
|
|
Url string
|
|
HasReadme bool
|
|
HasLicense bool
|
|
HasContributing bool
|
|
}
|
|
|
|
type CommitFile struct {
|
|
Mode string
|
|
Path string
|
|
Name string
|
|
Lines int
|
|
IsBinary bool
|
|
Size int64
|
|
}
|
|
|
|
type FileStats struct {
|
|
Name string
|
|
Mode string // ToDo: is the name correct here?
|
|
Adds int
|
|
Dels int
|
|
Total int
|
|
}
|
|
|
|
type CommitInfo struct {
|
|
Hash string
|
|
ParentHash string
|
|
Date time.Time
|
|
Msg string
|
|
AuthorName string
|
|
AuthorEmail string
|
|
Files int
|
|
Adds int
|
|
Dels int
|
|
FileStats []*FileStats
|
|
}
|
|
|
|
//go:embed templates
|
|
var embedTmpl embed.FS
|
|
var timeShortFormatStr = "2006-01-02 15:04"
|
|
var timeLongFormatStr = time.RFC1123
|
|
var funcMap = template.FuncMap{
|
|
"inc": func(i int) int {
|
|
return i + 1
|
|
},
|
|
"menu": func(repoInfo *RepoInfo, relpath string) template.HTML {
|
|
menu := "<a href=\"" + relpath + "log.html\">Log</a>"
|
|
menu += " | <a href=\"" + relpath + "files.html\">Files</a>"
|
|
menu += " | <a href=\"" + relpath + "refs.html\">Refs</a>"
|
|
|
|
if repoInfo.HasReadme {
|
|
menu += "| <a href=\"" + relpath + "file/README.html\">README</a>"
|
|
}
|
|
|
|
if repoInfo.HasLicense {
|
|
menu += "| <a href=\"" + relpath + "file/LICENSE.html\">LICENSE</a>"
|
|
}
|
|
|
|
if repoInfo.HasContributing {
|
|
menu += "| <a href=\"" + relpath + "file/CONTRIBUTING.html\">CONTRIBUTING</a>"
|
|
}
|
|
|
|
return template.HTML(menu)
|
|
},
|
|
"firstLine": func(msg string) string {
|
|
return strings.Split(msg, "\n")[0]
|
|
},
|
|
"timeShortFormat": func(t time.Time) string {
|
|
return t.Format(timeShortFormatStr)
|
|
},
|
|
"timeLongFormat": func(t time.Time) string {
|
|
return t.Format(timeLongFormatStr)
|
|
},
|
|
"repeatStr": func(s string, n int) string {
|
|
return strings.Repeat(s, n)
|
|
},
|
|
}
|
|
|
|
func executeTemplate(name string, data any) ([]byte, error) {
|
|
path := filepath.Join("templates", fmt.Sprintf("%s.html.tmpl", name))
|
|
b, err := embedTmpl.ReadFile(path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot read embedded file %q: %w", path, err)
|
|
}
|
|
|
|
tmpl, err := template.New("").Funcs(funcMap).Parse(string(b))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cannot parse template %q: %w", path, err)
|
|
}
|
|
|
|
var strb bytes.Buffer
|
|
if err := tmpl.Execute(&strb, data); err != nil {
|
|
return nil, fmt.Errorf("cannot execute template %q: %w", path, err)
|
|
}
|
|
|
|
return strb.Bytes(), nil
|
|
}
|
|
|
|
func executeTemplateToFile(tmplName string, data any, filename string) error {
|
|
contents, err := executeTemplate(tmplName, data)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot execute %q template: %w", tmplName, err)
|
|
}
|
|
|
|
if err := os.WriteFile(filename, contents, 0755); err != nil {
|
|
return fmt.Errorf("cannot write %q contents to %q: %w", tmplName, filename, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func readFile(path string) (string, error) {
|
|
if fi, err := os.Stat(path); err == nil && !fi.IsDir() {
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return "", fmt.Errorf("cannot read contents of file %q: %w", path, err)
|
|
}
|
|
return strings.TrimSpace(string(b)), nil
|
|
}
|
|
|
|
return "", nil
|
|
}
|
|
|
|
func readRepoFile(dirname, name string) (contents string, err error) {
|
|
contents, err = readFile(filepath.Join(dirname, ".git", name))
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if contents == "" {
|
|
contents, err = readFile(filepath.Join(dirname, name))
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func getRelpath(name string) string {
|
|
return strings.Repeat("../", strings.Count(name, "/"))
|
|
}
|
|
|
|
func generateIndex(args []string) error {
|
|
slog.Debug("Generating index", "args", args)
|
|
|
|
repoDirs := []*RepoDir{}
|
|
for _, dirname := range args {
|
|
slog.Debug("Processing directory", "dirname", dirname)
|
|
reponame := strings.TrimSuffix(filepath.Base(dirname), ".git")
|
|
repoDir := &RepoDir{Name: reponame}
|
|
|
|
// read description
|
|
description, err := readRepoFile(dirname, "description")
|
|
if err != nil {
|
|
return fmt.Errorf("cannot read description for repository %q: %w", dirname, err)
|
|
}
|
|
repoDir.Description = description
|
|
|
|
// read owner
|
|
owner, err := readRepoFile(dirname, "owner")
|
|
if err != nil {
|
|
return fmt.Errorf("cannot read owner for repository %q: %w", dirname, err)
|
|
}
|
|
repoDir.Owner = owner
|
|
|
|
// get last commit date
|
|
repo, err := git.PlainOpen(dirname)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot open repository %q: %w", dirname, err)
|
|
}
|
|
|
|
head, err := repo.Head()
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get repository head for %q: %w", dirname, err)
|
|
}
|
|
|
|
c, err := repo.CommitObject(head.Hash())
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get commit %q for repository %q: %w", head.Hash(), dirname, err)
|
|
}
|
|
repoDir.LastCommit = c.Author.When
|
|
|
|
repoDirs = append(repoDirs, repoDir)
|
|
}
|
|
|
|
data := map[string]any{"repoDirs": repoDirs}
|
|
if err := executeTemplateToFile("index", data, "index.html"); err != nil {
|
|
return fmt.Errorf("cannot execute template %q to file %q: %w", "index", "index.html", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func generateRepo(path string, logLimit int) error {
|
|
slog.Debug("Generating repository", "path", path, "logLimit", logLimit)
|
|
|
|
repoInfo := &RepoInfo{Name: strings.TrimSuffix(filepath.Base(path), ".git")}
|
|
|
|
// create and clean destination directory
|
|
fi, err := os.Stat(repoInfo.Name)
|
|
if err == nil && !fi.IsDir() {
|
|
return fmt.Errorf("path %q is not a directory", repoInfo.Name)
|
|
}
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return fmt.Errorf("cannot stat %q: %w", repoInfo.Name, err)
|
|
}
|
|
if err == nil && fi.IsDir() {
|
|
if err := os.RemoveAll(repoInfo.Name); err != nil {
|
|
return fmt.Errorf("cannot delete directory for %q: %w", repoInfo.Name, err)
|
|
}
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(repoInfo.Name, "commit"), 0755); err != nil {
|
|
return fmt.Errorf("cannot create directory for %q: %w", repoInfo.Name, err)
|
|
}
|
|
|
|
// read description
|
|
description, err := readRepoFile(path, "description")
|
|
if err != nil {
|
|
return fmt.Errorf("cannot read description for repository %q: %w", path, err)
|
|
}
|
|
repoInfo.Description = description
|
|
|
|
// read url
|
|
url, err := readRepoFile(path, "url")
|
|
if err != nil {
|
|
return fmt.Errorf("cannot read url for repository %q: %w", path, err)
|
|
}
|
|
repoInfo.Url = url
|
|
|
|
// open repository
|
|
repo, err := git.PlainOpen(path)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot open repository %q: %w", path, err)
|
|
}
|
|
|
|
head, err := repo.Head()
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get repo head: %w", err)
|
|
}
|
|
|
|
c, err := repo.CommitObject(head.Hash())
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get commit for hash %s: %w", head.Hash(), err)
|
|
}
|
|
|
|
// ToDo: populate hasReadme, hasLicense and hasContributing
|
|
|
|
tree, err := c.Tree()
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get tree for commit %s: %w", c, err)
|
|
}
|
|
|
|
slog.Debug("Processing repository tree", "head", head.Hash())
|
|
files := []*CommitFile{}
|
|
iErr := tree.Files().ForEach(func(o *object.File) error {
|
|
slog.Debug("Processing tree file", "name", o.Name)
|
|
|
|
dirpath := filepath.Join(repoInfo.Name, "file", filepath.Dir(o.Name))
|
|
filename := filepath.Base(o.Name)
|
|
slog.Debug("Creating directory", "dirpath", dirpath)
|
|
if err := os.MkdirAll(dirpath, 0755); err != nil {
|
|
return fmt.Errorf("cannot create directory %q: %w", dirpath, err)
|
|
}
|
|
|
|
data := map[string]any{
|
|
"relpath": getRelpath(dirpath),
|
|
"repoInfo": repoInfo,
|
|
"filename": filename,
|
|
"filesize": o.Size,
|
|
}
|
|
|
|
isBinary, err := o.IsBinary()
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get binary state for file %q: %w", o.Name, err)
|
|
}
|
|
data["isBinary"] = isBinary
|
|
|
|
var lines []string
|
|
if !isBinary {
|
|
var err error
|
|
lines, err = o.Lines()
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get lines for %q: %w", o.Name, err)
|
|
}
|
|
data["filelines"] = lines
|
|
}
|
|
|
|
dstpath := filepath.Join(dirpath, fmt.Sprintf("%s.html", filename))
|
|
if err := executeTemplateToFile("file", data, dstpath); err != nil {
|
|
return fmt.Errorf("cannot execute template %q to file %q: %w", "file", dstpath, err)
|
|
}
|
|
|
|
file := &CommitFile{
|
|
Mode: o.Mode.String(), // ToDo: correctly calculate the mode string
|
|
Path: filepath.Join("file", fmt.Sprintf("%s.html", o.Name)),
|
|
Name: o.Name,
|
|
Lines: len(lines),
|
|
IsBinary: isBinary,
|
|
Size: o.Size,
|
|
}
|
|
files = append(files, file)
|
|
|
|
return nil
|
|
})
|
|
if iErr != nil {
|
|
return fmt.Errorf("error while processing tree: %w", iErr)
|
|
}
|
|
|
|
// generate the files index file
|
|
filesData := map[string]any{"repoInfo": repoInfo, "files": files, "relpath": ""}
|
|
filesDstpath := filepath.Join(repoInfo.Name, "files.html")
|
|
if err := executeTemplateToFile("files", filesData, filesDstpath); err != nil {
|
|
return fmt.Errorf("cannot execute template %q to file %q: %w", "file", filesDstpath, err)
|
|
}
|
|
|
|
// generate the log file
|
|
cIter, err := repo.Log(&git.LogOptions{All: true})
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get git log for repository: %w", err)
|
|
}
|
|
|
|
i := 0
|
|
remaining := 0
|
|
commits := []*CommitInfo{}
|
|
for {
|
|
i++
|
|
c, err := cIter.Next()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get next commit while processing log: %w", err)
|
|
}
|
|
|
|
slog.Debug("Processing commit", "hash", c.Hash)
|
|
|
|
if i > logLimit {
|
|
remaining++
|
|
slog.Debug("Limit reached while processing log", "iteration", i, "remaining", remaining)
|
|
continue
|
|
}
|
|
|
|
// ToDo: is this the best way to get the number of files?
|
|
fstats, err := c.Stats()
|
|
if err != nil {
|
|
return fmt.Errorf("cannot get commit stats %s: %w", c.Hash, err)
|
|
}
|
|
|
|
fileStats := make([]*FileStats, len(fstats))
|
|
for i, fs := range fstats {
|
|
fileStats[i] = &FileStats{
|
|
Name: fs.Name,
|
|
Mode: "",
|
|
Adds: fs.Addition,
|
|
Dels: fs.Deletion,
|
|
Total: fs.Addition + fs.Deletion,
|
|
}
|
|
}
|
|
|
|
commit := &CommitInfo{
|
|
Hash: c.Hash.String(),
|
|
Date: c.Author.When, // ToDo: author when vs commiter when?
|
|
Msg: c.Message,
|
|
AuthorName: c.Author.Name,
|
|
AuthorEmail: c.Author.Email,
|
|
Files: len(fstats), // ToDo: call len on FileStats
|
|
FileStats: fileStats,
|
|
}
|
|
|
|
if parent, _ := c.Parent(0); parent != nil {
|
|
commit.ParentHash = parent.Hash.String()
|
|
}
|
|
|
|
// ToDo: are there not global commit stats?
|
|
for _, fstat := range fstats {
|
|
commit.Adds += fstat.Addition
|
|
commit.Dels += fstat.Deletion
|
|
}
|
|
|
|
commits = append(commits, commit)
|
|
|
|
// generate commit file
|
|
data := map[string]any{"repoInfo": repoInfo, "commit": commit, "relpath": "../"}
|
|
dstpath := filepath.Join(repoInfo.Name, "commit", fmt.Sprintf("%s.html", commit.Hash))
|
|
if err := executeTemplateToFile("commit", data, dstpath); err != nil {
|
|
return fmt.Errorf("cannot execute template %q to file %q: %w", "commit", dstpath, err)
|
|
}
|
|
}
|
|
|
|
logData := map[string]any{
|
|
"repoInfo": repoInfo,
|
|
"commits": commits,
|
|
"relpath": "",
|
|
"remaining": remaining,
|
|
}
|
|
logDstpath := filepath.Join(repoInfo.Name, "log.html")
|
|
if err := executeTemplateToFile("log", logData, logDstpath); err != nil {
|
|
return fmt.Errorf("cannot execute template %q to file %q: %w", "file", logDstpath, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
ctx := kong.Parse(&cli)
|
|
if cli.Debug {
|
|
slog.SetLogLoggerLevel(slog.LevelDebug)
|
|
}
|
|
|
|
if err := ctx.Run(); err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: %s\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|