ReleaseKit/internal/git/source.go

package git

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"path"
	"path/filepath"
	"strconv"
	"strings"

	"gitea.maximumdirect.net/eric/ReleaseKit/internal/process"
)

// TreeEntry records one committed path and its Git object metadata.
type TreeEntry struct {
	Path     string
	ObjectID string
	Mode     string
	Type     string
	Size     int64
	HasSize  bool
}

type TaggedSource struct {
	Head          string
	Status        string
	TagObject     string
	TagCommit     string
	TagObjectType string
}

// RepositoryRoot resolves the containing checkout, including independent
// worktrees and directories reached through filesystem aliases.
func RepositoryRoot(ctx context.Context, directory string) (string, error) {
	if directory == "" {
		directory = "."
	}
	root, err := run(ctx, directory, nil, "rev-parse", "--show-toplevel")
	if err != nil {
		return "", fmt.Errorf("resolve Git repository root: %w", err)
	}
	root = strings.TrimSuffix(root, "\n")
	resolved, err := filepath.EvalSymlinks(root)
	if err != nil {
		return "", fmt.Errorf("resolve Git repository directory: %w", err)
	}
	return resolved, nil
}

// CaptureHead records the checkout commit before identity derived from files
// in that commit is inspected.
func CaptureHead(ctx context.Context, repositoryDir string) (string, error) {
	head, err := run(ctx, repositoryDir, nil, "rev-parse", "--verify", "HEAD^{commit}")
	if err != nil {
		return "", fmt.Errorf("read checkout HEAD: %w", err)
	}
	head = strings.TrimSpace(head)
	if !validObjectID(head) {
		return "", fmt.Errorf("Git returned an invalid checkout commit %q", head)
	}
	return head, nil
}

// InspectTaggedSource reads the local HEAD, worktree state, and selected tag.
// Both lightweight historical tags and annotated tags are supported.
func InspectTaggedSource(ctx context.Context, repositoryDir, tag string) (TaggedSource, error) {
	if err := checkTagRef(ctx, repositoryDir, tag); err != nil {
		return TaggedSource{}, err
	}
	var source TaggedSource
	head, err := run(ctx, repositoryDir, nil, "rev-parse", "--verify", "HEAD^{commit}")
	if err != nil {
		return TaggedSource{}, fmt.Errorf("read checkout HEAD: %w", err)
	}
	source.Head = strings.TrimSpace(head)
	if !validObjectID(source.Head) {
		return TaggedSource{}, fmt.Errorf("Git returned an invalid checkout commit %q", source.Head)
	}
	status, err := run(ctx, repositoryDir, nil, "status", "--porcelain", "--untracked-files=all")
	if err != nil {
		return TaggedSource{}, fmt.Errorf("inspect tagged checkout state: %w", err)
	}
	source.Status = strings.TrimSpace(status)
	ref := "refs/tags/" + tag
	object, err := run(ctx, repositoryDir, nil, "rev-parse", "--verify", ref)
	if err != nil {
		return TaggedSource{}, fmt.Errorf("read local tag %s: %w", tag, err)
	}
	source.TagObject = strings.TrimSpace(object)
	if !validObjectID(source.TagObject) {
		return TaggedSource{}, fmt.Errorf("Git returned an invalid tag object %q", source.TagObject)
	}
	peeled, err := run(ctx, repositoryDir, nil, "rev-parse", "--verify", ref+"^{commit}")
	if err != nil {
		return TaggedSource{}, fmt.Errorf("resolve local tag %s to a commit: %w", tag, err)
	}
	source.TagCommit = strings.TrimSpace(peeled)
	if !validObjectID(source.TagCommit) {
		return TaggedSource{}, fmt.Errorf("Git returned an invalid tagged commit %q", source.TagCommit)
	}
	tagType, err := run(ctx, repositoryDir, nil, "cat-file", "-t", ref)
	if err != nil {
		return TaggedSource{}, fmt.Errorf("inspect local tag %s: %w", tag, err)
	}
	source.TagObjectType = strings.TrimSpace(tagType)
	if source.TagObjectType != "tag" && source.TagObjectType != "commit" {
		return TaggedSource{}, fmt.Errorf("local tag %s has unsupported object type %q", tag, source.TagObjectType)
	}
	return source, nil
}

// ReadCommitFile reads a repository-relative file from a specific commit.
func ReadCommitFile(ctx context.Context, repositoryDir, commit, name string) ([]byte, error) {
	if !validObjectID(commit) || name == "" || path.IsAbs(name) || path.Clean(name) != name || strings.HasPrefix(name, "../") || name == ".." || strings.Contains(name, "\\") {
		return nil, fmt.Errorf("invalid committed file identity %q at %q", name, commit)
	}
	content, err := readLocalObjects(ctx, repositoryDir, nil, "show", commit+":"+name)
	if err != nil {
		return nil, fmt.Errorf("read committed file %q: %w", name, err)
	}
	return content, nil
}

// CommittedPaths resolves individual paths from captured objects. It requests
// only metadata and link contents needed for traversal.
func CommittedPaths(repositoryDir, commit string) PathResolver {
	metadata := make(map[string]TreeEntry)
	return PathResolver{
		RepositoryDir: repositoryDir,
		Lookup: func(ctx context.Context, name string) (TreeEntry, bool, error) {
			if err := ctx.Err(); err != nil {
				return TreeEntry{}, false, err
			}
			if entry, seen := metadata[name]; seen {
				return entry, entry.ObjectID != "", nil
			}
			if !validObjectID(commit) || name == "" || path.IsAbs(name) || path.Clean(name) != name || name == ".." || strings.HasPrefix(name, "../") {
				return TreeEntry{}, false, fmt.Errorf("invalid committed path identity %q at %q", name, commit)
			}
			output, err := readLocalObjects(ctx, repositoryDir, nil, "--literal-pathspecs", "ls-tree", "-z", "--full-tree", commit, "--", name)
			if err != nil {
				return TreeEntry{}, false, fmt.Errorf("inspect committed path %q: %w", name, err)
			}
			entries, err := parseTreeEntries(output)
			if err != nil {
				return TreeEntry{}, false, err
			}
			for _, entry := range entries {
				if entry.Path == name {
					metadata[name] = entry
					return entry, true, nil
				}
			}
			metadata[name] = TreeEntry{}
			return TreeEntry{}, false, nil
		},
		ReadLink: func(ctx context.Context, entry TreeEntry) (string, error) {
			contents, err := ReadBlob(ctx, repositoryDir, entry.ObjectID)
			return string(contents), err
		},
	}
}

// ReadTree enumerates path, type, mode, and object metadata for a commit.
// Blob sizes and contents are inspected separately. Paths are NUL-delimited
// by Git so whitespace in a filename is preserved.
func ReadTree(ctx context.Context, repositoryDir, commit string) ([]TreeEntry, error) {
	if !validObjectID(commit) {
		return nil, fmt.Errorf("invalid commit object ID %q", commit)
	}
	output, err := readLocalObjects(ctx, repositoryDir, nil, "ls-tree", "-r", "-z", "--full-tree", commit)
	if err != nil {
		return nil, fmt.Errorf("enumerate committed tree %s: %w", commit, err)
	}
	entries, err := parseTreeEntries(output)
	if err != nil {
		return nil, fmt.Errorf("parse committed tree %s: %w", commit, err)
	}
	return entries, nil
}

// ReadBlob reads the bytes for a Git blob object ID without consulting the
// worktree.
func ReadBlob(ctx context.Context, repositoryDir, objectID string) ([]byte, error) {
	if !validObjectID(objectID) {
		return nil, fmt.Errorf("invalid blob object ID %q", objectID)
	}
	content, err := readLocalObjects(ctx, repositoryDir, nil, "cat-file", "blob", objectID)
	if err != nil {
		return nil, fmt.Errorf("read blob %s: %w", objectID, err)
	}
	return content, nil
}

func parseTreeEntries(output []byte) ([]TreeEntry, error) {
	if len(output) == 0 {
		return nil, nil
	}
	var entries []TreeEntry
	for _, record := range bytes.Split(output, []byte{0}) {
		if len(record) == 0 {
			continue
		}
		tab := bytes.IndexByte(record, '\t')
		if tab < 0 {
			return nil, fmt.Errorf("tree record has no path separator")
		}
		fields := strings.Fields(string(record[:tab]))
		if len(fields) != 3 || !validObjectID(fields[2]) {
			return nil, fmt.Errorf("invalid tree record metadata %q", record[:tab])
		}
		entries = append(entries, TreeEntry{
			Mode:     fields[0],
			Type:     fields[1],
			ObjectID: fields[2],
			Path:     string(record[tab+1:]),
		})
	}
	return entries, nil
}

// PopulateBlobSizes fills unknown sizes for the supplied blob entries using
// local objects. Callers select the entries whose sizes their check needs.
func PopulateBlobSizes(ctx context.Context, repositoryDir string, entries []TreeEntry) error {
	if err := ctx.Err(); err != nil {
		return err
	}
	var blobIndexes []int
	var input strings.Builder
	for index := range entries {
		if entries[index].Type != "blob" || entries[index].HasSize {
			continue
		}
		blobIndexes = append(blobIndexes, index)
		input.WriteString(entries[index].ObjectID)
		input.WriteByte('\n')
	}
	if len(blobIndexes) == 0 {
		return nil
	}
	output, err := readLocalObjects(ctx, repositoryDir, strings.NewReader(input.String()),
		"cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)")
	if err != nil {
		return err
	}
	lines := strings.Split(strings.TrimSuffix(string(output), "\n"), "\n")
	if len(lines) != len(blobIndexes) {
		return fmt.Errorf("git returned %d blob sizes for %d blobs", len(lines), len(blobIndexes))
	}
	for index, line := range lines {
		fields := strings.Fields(line)
		entry := &entries[blobIndexes[index]]
		if len(fields) == 2 && fields[0] == entry.ObjectID && fields[1] == "missing" {
			return fmt.Errorf("committed blob %s for %q is unavailable locally", entry.ObjectID, entry.Path)
		}
		if len(fields) != 3 || fields[0] != entry.ObjectID || fields[1] != "blob" {
			return fmt.Errorf("unexpected blob size record %q", line)
		}
		size, err := strconv.ParseInt(fields[2], 10, 64)
		if err != nil || size < 0 {
			return fmt.Errorf("invalid blob size in record %q", line)
		}
		entry.Size = size
		entry.HasSize = true
	}
	return nil
}

// readLocalObjects keeps source inspection separate from network preparation.
func readLocalObjects(ctx context.Context, repositoryDir string, input io.Reader, args ...string) ([]byte, error) {
	var stdout, stderr bytes.Buffer
	err := process.Run(ctx, process.Invocation{
		Args: append([]string{"git"}, args...),
		Dir:  repositoryDir,
		// Disable transports as well for Git versions predating lazy-fetch control.
		Env:    map[string]string{"GIT_NO_LAZY_FETCH": "1", "GIT_ALLOW_PROTOCOL": ""},
		Stdin:  input,
		Stdout: &stdout,
		Stderr: &stderr,
	})
	if err != nil {
		if message := strings.TrimSpace(stderr.String()); message != "" {
			return nil, fmt.Errorf("read local Git objects: %s: %w", message, err)
		}
		return nil, err
	}
	return stdout.Bytes(), nil
}