prime8dev

git.go (6394B)

---

 package external
 
 import (
 	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
 	"git.prime8.dev/moncheeta/prime8dev/internal/config"
 )
 
 const (
 	defaultGitReposDir = "/srv/git/repos"
 	gitCommandTimeout  = 10 * time.Second
 )
 
 // readmeNames are tried in order when reading a repository README from HEAD.
 var readmeNames = []string{"README.md", "readme.md", "README", "README.markdown"}
 
 // Git reads project metadata from local bare repositories.
 type Git struct {
 	reposDir string
 	webBase  string
 }
 
 func NewGit() *Git {
 	reposDir := strings.TrimSpace(os.Getenv("GIT_REPOS_DIR"))
 	if reposDir == "" {
 		reposDir = defaultGitReposDir
 	}
 
 	return &Git{
 		reposDir: reposDir,
 		webBase:  config.GitWebBase(),
 	}
 }
 
 type GitMetadata struct {
 	Readme       string
 	DateCreated  time.Time
 	DateModified time.Time
 }
 
 func (s *Git) FetchMetadata(ctx context.Context, project config.Project) (*GitMetadata, error) {
 	if ctx == nil {
 		ctx = context.Background()
 	}
 
 	return s.readMetadata(ctx, project)
 }
 
 func (s *Git) RefreshMetadata(ctx context.Context, project config.Project) error {
 	if ctx == nil {
 		ctx = context.Background()
 	}
 
 	_, err := s.readMetadata(ctx, project)
 	return err
 }
 
 func (s *Git) repoDir(repo string) string {
 	return filepath.Join(s.reposDir, repo+".git")
 }
 
 func (s *Git) readMetadata(ctx context.Context, project config.Project) (*GitMetadata, error) {
 	repo := strings.TrimSpace(project.Repo)
 	if repo == "" {
 		return nil, fmt.Errorf("project %q has no repo configured", project.ID)
 	}
 	if strings.Contains(repo, "/") || strings.Contains(repo, "..") {
 		return nil, fmt.Errorf("invalid repo name %q", repo)
 	}
 
 	dir := s.repoDir(repo)
 	if info, err := os.Stat(dir); err != nil {
 		return nil, fmt.Errorf("repo %s: %w", repo, err)
 	} else if !info.IsDir() {
 		return nil, fmt.Errorf("repo %s: %s is not a directory", repo, dir)
 	}
 
 	modified, err := s.commitTime(ctx, dir, "log", "-1", "--format=%ct", "HEAD")
 	if err != nil {
 		return nil, fmt.Errorf("repo %s: last commit: %w", repo, err)
 	}
 	created, err := s.commitTime(ctx, dir, "log", "--reverse", "--format=%ct", "HEAD")
 	if err != nil {
 		return nil, fmt.Errorf("repo %s: first commit: %w", repo, err)
 	}
 
 	readme := ""
 	for _, name := range readmeNames {
 		out, err := s.git(ctx, dir, "show", "HEAD:"+name)
 		if err != nil {
 			continue
 		}
 		readme = fixRelativePaths(s.webBase, repo, string(out))
 		break
 	}
 
 	return &GitMetadata{
 		Readme:       readme,
 		DateCreated:  created,
 		DateModified: modified,
 	}, nil
 }
 
 // commitTime runs a git log command printing %ct per line and returns the
 // time on the first line.
 func (s *Git) commitTime(ctx context.Context, dir string, args ...string) (time.Time, error) {
 	out, err := s.git(ctx, dir, args...)
 	if err != nil {
 		return time.Time{}, err
 	}
 
 	line, _, _ := strings.Cut(strings.TrimSpace(string(out)), "\n")
 	line = strings.TrimSpace(line)
 	if line == "" {
 		return time.Time{}, errors.New("no commits")
 	}
 
 	sec, err := strconv.ParseInt(line, 10, 64)
 	if err != nil {
 		return time.Time{}, fmt.Errorf("parse commit time %q: %w", line, err)
 	}
 
 	return time.Unix(sec, 0).UTC(), nil
 }
 
 func (s *Git) git(ctx context.Context, dir string, args ...string) ([]byte, error) {
 	ctx, cancel := context.WithTimeout(ctx, gitCommandTimeout)
 	defer cancel()
 
 	cmd := exec.CommandContext(ctx, "git", append([]string{"--git-dir=" + dir}, args...)...)
 	var stderr bytes.Buffer
 	cmd.Stderr = &stderr
 	out, err := cmd.Output()
 	if err != nil {
 		if msg := strings.TrimSpace(stderr.String()); msg != "" {
 			return nil, fmt.Errorf("git %s: %w: %s", args[0], err, msg)
 		}
 		return nil, fmt.Errorf("git %s: %w", args[0], err)
 	}
 
 	return out, nil
 }
 
 // imageRegex and linkRegex match inline markdown images and links with an
 // optional title: [text](target "title").
 var (
 	imageRegex     = regexp.MustCompile(`!\[([^\]]*)\]\(\s*([^)\s]+)((?:\s+"[^"]*")?)\s*\)`)
 	linkRegex      = regexp.MustCompile(`\[([^\]]*)\]\(\s*([^)\s]+)((?:\s+"[^"]*")?)\s*\)`)
 	urlSchemeRegex = regexp.MustCompile(`^[a-zA-Z][a-zA-Z0-9+.-]*:`)
 )
 
 const imagePlaceholder = "\x00img%d\x00"
 
 // fixRelativePaths rewrites repo-relative links and images in a README to the
 // stagit web layout: links to <base>/<repo>/file/<path>.html and images to
 // <base>/<repo>/raw/<path>. Absolute URLs and #anchors are left unchanged.
 func fixRelativePaths(webBase, repo, markdown string) string {
 	repoBase := strings.TrimSuffix(webBase, "/") + "/" + repo
 
 	// Images first, swapped for placeholders so that links wrapping an image
 	// ([![badge](img.svg)](target)) are still matched as links afterwards.
 	images := []string{}
 	markdown = imageRegex.ReplaceAllStringFunc(markdown, func(match string) string {
 		parts := imageRegex.FindStringSubmatch(match)
 		if path, ok := repoRelativePath(parts[2]); ok {
 			match = fmt.Sprintf("![%s](%s/raw/%s%s)", parts[1], repoBase, path, parts[3])
 		}
 		images = append(images, match)
 		return fmt.Sprintf(imagePlaceholder, len(images)-1)
 	})
 
 	markdown = linkRegex.ReplaceAllStringFunc(markdown, func(match string) string {
 		parts := linkRegex.FindStringSubmatch(match)
 		target := parts[2]
 		path, ok := repoRelativePath(target)
 		if !ok {
 			return match
 		}
 
 		var rewritten string
 		if strings.HasSuffix(path, "/") {
 			rewritten = repoBase + "/files.html"
 		} else {
 			rewritten = fmt.Sprintf("%s/file/%s.html", repoBase, path)
 			if _, fragment, found := strings.Cut(target, "#"); found && fragment != "" {
 				rewritten += "#" + fragment
 			}
 		}
 
 		return fmt.Sprintf("[%s](%s%s)", parts[1], rewritten, parts[3])
 	})
 
 	for i, image := range images {
 		markdown = strings.Replace(markdown, fmt.Sprintf(imagePlaceholder, i), image, 1)
 	}
 
 	return markdown
 }
 
 // repoRelativePath returns the cleaned repo-relative path for a markdown
 // target, or false when the target is absolute (has a scheme or is
 // protocol-relative) or is a bare #anchor.
 func repoRelativePath(target string) (string, bool) {
 	if target == "" || strings.HasPrefix(target, "#") || strings.HasPrefix(target, "//") || urlSchemeRegex.MatchString(target) {
 		return "", false
 	}
 
 	path, _, _ := strings.Cut(target, "#")
 	path, _, _ = strings.Cut(path, "?")
 	for strings.HasPrefix(path, "./") {
 		path = strings.TrimPrefix(path, "./")
 	}
 	path = strings.TrimLeft(path, "/")
 	if path == "" {
 		return "", false
 	}
 
 	return path, true
 }