prime8dev

git.go (7757B)

---

 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
 }
 
 func NewGit() *Git {
 	reposDir := strings.TrimSpace(os.Getenv("GIT_REPOS_DIR"))
 	if reposDir == "" {
 		reposDir = defaultGitReposDir
 	}
 
 	return &Git{reposDir: reposDir}
 }
 
 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
 }
 
 // HeadSHA returns the commit HEAD points at, a cheap freshness key for
 // anything derived from the repo.
 func (s *Git) HeadSHA(ctx context.Context, project config.Project) (string, error) {
 	if ctx == nil {
 		ctx = context.Background()
 	}
 	dir, err := s.projectRepoDir(project)
 	if err != nil {
 		return "", err
 	}
 	out, err := s.git(ctx, dir, "rev-parse", "HEAD")
 	if err != nil {
 		return "", err
 	}
 	return strings.TrimSpace(string(out)), nil
 }
 
 // ErrNotFound is returned by ReadFile when the path is not a file at HEAD.
 var ErrNotFound = errors.New("not found")
 
 func (s *Git) repoDir(repo string) string {
 	return filepath.Join(s.reposDir, repo+".git")
 }
 
 // projectRepoDir validates a project's repo name and returns its bare repo
 // directory.
 func (s *Git) projectRepoDir(project config.Project) (string, error) {
 	repo := strings.TrimSpace(project.Repo)
 	if repo == "" {
 		return "", fmt.Errorf("project %q has no repo configured", project.ID)
 	}
 	if strings.Contains(repo, "/") || strings.Contains(repo, "..") {
 		return "", fmt.Errorf("invalid repo name %q", repo)
 	}
 
 	dir := s.repoDir(repo)
 	if info, err := os.Stat(dir); err != nil {
 		return "", fmt.Errorf("repo %s: %w", repo, err)
 	} else if !info.IsDir() {
 		return "", fmt.Errorf("repo %s: %s is not a directory", repo, dir)
 	}
 
 	return dir, nil
 }
 
 // ReadFile returns the contents of a file at HEAD of a project's repo.
 func (s *Git) ReadFile(ctx context.Context, project config.Project, path string) ([]byte, error) {
 	if ctx == nil {
 		ctx = context.Background()
 	}
 
 	path = strings.Trim(path, "/")
 	if path == "" || strings.HasPrefix(path, ".git/") {
 		return nil, ErrNotFound
 	}
 	for _, part := range strings.Split(path, "/") {
 		if part == "" || part == "." || part == ".." {
 			return nil, ErrNotFound
 		}
 	}
 
 	dir, err := s.projectRepoDir(project)
 	if err != nil {
 		return nil, err
 	}
 
 	kind, err := s.git(ctx, dir, "cat-file", "-t", "HEAD:"+path)
 	if err != nil || strings.TrimSpace(string(kind)) != "blob" {
 		return nil, ErrNotFound
 	}
 
 	return s.git(ctx, dir, "cat-file", "blob", "HEAD:"+path)
 }
 
 func (s *Git) readMetadata(ctx context.Context, project config.Project) (*GitMetadata, error) {
 	repo := strings.TrimSpace(project.Repo)
 	dir, err := s.projectRepoDir(project)
 	if err != nil {
 		return nil, err
 	}
 
 	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(project.ID, 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
 // files served from HEAD by the site (config.ProjectRawURL). Links to
 // directories point at the project page. Absolute URLs and #anchors are left
 // unchanged.
 func fixRelativePaths(projectID, markdown string) string {
 	// 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%s)", parts[1], config.ProjectRawURL(projectID, 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)
 		path, ok := repoRelativePath(parts[2])
 		if !ok {
 			return match
 		}
 
 		rewritten := config.ProjectRawURL(projectID, path)
 		if strings.HasSuffix(path, "/") {
 			rewritten = config.SiteURL + "/projects/" + projectID
 		}
 
 		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
 }