tree_reader.go

package gitlib

import (
	"fmt"
	"os"
	"sort"
	"strings"
)

type rawTreeEntry struct {
	Mode string
	Name string
	Hash Hash
}

func GetTreeEntries(repoPath string, branch string, treePath string) ([]TreeEntry, error) {
	st, treeHash, err := resolveTreeHashForPath(repoPath, branch, treePath)
	if err != nil {
		return nil, err
	}

	entries, err := readTreeEntries(st, treeHash)
	if err != nil {
		return nil, err
	}

	out := make([]TreeEntry, 0, len(entries))
	for _, e := range entries {
		typ := "file"
		if e.Mode == treeModeDir {
			typ = "dir"
		}
		out = append(out, TreeEntry{
			Name: e.Name,
			Type: typ,
		})
	}

	sort.Slice(out, func(i, j int) bool {
		return out[i].Name < out[j].Name
	})

	return out, nil
}

func GetTreeNames(repoPath string, branch string) ([]string, error) {
	entries, err := GetTreeEntries(repoPath, branch, "")
	if err != nil {
		return nil, err
	}

	out := make([]string, 0, len(entries))
	for _, e := range entries {
		out = append(out, e.Name)
	}

	return out, nil
}

func ShowFile(repoPath string, branch string, path string) ([]byte, error) {
	st, treeHash, err := openRepoStorageWithRootTree(repoPath, branch)
	if err != nil {
		return nil, err
	}

	cleanPath, err := normalizePath(path)
	if err != nil {
		return nil, err
	}

	entry, err := resolveTreeEntryForPath(st, treeHash, cleanPath)
	if err != nil {
		return nil, err
	}

	if entry.Mode == treeModeDir {
		return nil, fmt.Errorf("%s: это директория", cleanPath)
	}

	obj, err := st.ReadLoose(entry.Hash)
	if err != nil {
		return nil, err
	}

	if obj.Type != ObjectBlob {
		return nil, fmt.Errorf("%s: объект не является блобом", cleanPath)
	}

	return obj.Data, nil
}

func resolveRootTreeHash(repo *Repository, branch string) (Hash, error) {
	st := repo.Storage()
	commitHash, err := resolveCommitHash(repo, branch)
	if err != nil {
		return Hash{}, err
	}

	obj, err := st.ReadLoose(commitHash)
	if err != nil {
		return Hash{}, err
	}

	if obj.Type != ObjectCommit {
		return Hash{}, fmt.Errorf("ссылка не указывает на коммит")
	}

	info := parseCommitData(obj.Data)

	return ParseHash(info.Tree)
}

func openRepoStorageWithRootTree(repoPath, branch string) (*Storage, Hash, error) {
	repo, err := Open(repoPath)
	if err != nil {
		return nil, Hash{}, err
	}

	st := repo.Storage()
	treeHash, err := resolveRootTreeHash(repo, branch)
	if err != nil {
		return nil, Hash{}, err
	}

	return st, treeHash, nil
}

func resolveTreeHashForPath(repoPath, branch, treePath string) (*Storage, Hash, error) {
	st, treeHash, err := openRepoStorageWithRootTree(repoPath, branch)
	if err != nil {
		return nil, Hash{}, err
	}

	cleanPath := strings.Trim(strings.TrimSpace(treePath), "/")
	if cleanPath == "" {
		return st, treeHash, nil
	}

	parts := strings.SplitSeq(cleanPath, "/")
	for p := range parts {
		entries, err := readTreeEntries(st, treeHash)
		if err != nil {
			return nil, Hash{}, err
		}

		found := false
		for _, entry := range entries {
			if entry.Name != p {
				continue
			}

			if entry.Mode != treeModeDir {
				return nil, Hash{}, os.ErrNotExist
			}

			treeHash = entry.Hash
			found = true
			break
		}

		if !found {
			return nil, Hash{}, os.ErrNotExist
		}
	}

	return st, treeHash, nil
}

func resolveTreeEntryForPath(st *Storage, rootTreeHash Hash, path string) (rawTreeEntry, error) {
	cleanPath, err := normalizePath(path)
	if err != nil {
		return rawTreeEntry{}, err
	}

	treeHash := rootTreeHash
	parts := strings.Split(cleanPath, "/")
	for i, p := range parts {
		entries, err := readTreeEntries(st, treeHash)
		if err != nil {
			return rawTreeEntry{}, err
		}

		matched, ok := findTreeEntryByName(entries, p)
		if !ok {
			return rawTreeEntry{}, os.ErrNotExist
		}

		if i == len(parts)-1 {
			return matched, nil
		}

		if matched.Mode != treeModeDir {
			return rawTreeEntry{}, os.ErrNotExist
		}

		treeHash = matched.Hash
	}

	return rawTreeEntry{}, os.ErrNotExist
}

func findTreeEntryByName(entries []rawTreeEntry, name string) (rawTreeEntry, bool) {
	for _, entry := range entries {
		if entry.Name == name {
			return entry, true
		}
	}

	return rawTreeEntry{}, false
}

func normalizePath(path string) (string, error) {
	cleanPath := strings.Trim(strings.TrimSpace(path), "/")
	if cleanPath == "" {
		return "", fmt.Errorf("пустой путь")
	}

	return cleanPath, nil
}

func readTreeEntries(st *Storage, treeHash Hash) ([]rawTreeEntry, error) {
	obj, err := st.ReadLoose(treeHash)
	if err != nil {
		return nil, err
	}
	if obj.Type != ObjectTree {
		return nil, fmt.Errorf("объект %s не является деревом", treeHash.String())
	}

	data := obj.Data
	entries := make([]rawTreeEntry, 0)
	i := 0
	for i < len(data) {
		modeStart := i
		for i < len(data) && data[i] != ' ' {
			i++
		}

		if i >= len(data) {
			return nil, fmt.Errorf("некорректное дерево: нет разделителя режима")
		}

		mode := string(data[modeStart:i])
		i++

		nameStart := i
		for i < len(data) && data[i] != 0 {
			i++
		}

		if i >= len(data) {
			return nil, fmt.Errorf("некорректное дерево: нет терминатора имени")
		}

		name := string(data[nameStart:i])
		i++

		if i+HashSize > len(data) {
			return nil, fmt.Errorf("некорректное дерево: обрезанный хеш")
		}

		var h Hash
		copy(h[:], data[i:i+HashSize])
		i += HashSize

		entries = append(entries, rawTreeEntry{
			Mode: mode,
			Name: name,
			Hash: h,
		})
	}
	return entries, nil
}