gitech

1
// Copyright 2015 The Gogs Authors. All rights reserved.
2
// Copyright 2018 The Gitea Authors. All rights reserved.
3
// SPDX-License-Identifier: MIT
4

5
//go:build gogit
6

7
package git
8

9
import (
10
	"sort"
11
	"strings"
12

13
	"github.com/go-git/go-git/v5/plumbing"
14
	"github.com/go-git/go-git/v5/plumbing/storer"
15
)
16

17
// IsObjectExist returns true if given reference exists in the repository.
18
func (repo *Repository) IsObjectExist(name string) bool {
19
	if name == "" {
20
		return false
21
	}
22

23
	_, err := repo.gogitRepo.ResolveRevision(plumbing.Revision(name))
24

25
	return err == nil
26
}
27

28
// IsReferenceExist returns true if given reference exists in the repository.
29
func (repo *Repository) IsReferenceExist(name string) bool {
30
	if name == "" {
31
		return false
32
	}
33

34
	reference, err := repo.gogitRepo.Reference(plumbing.ReferenceName(name), true)
35
	if err != nil {
36
		return false
37
	}
38
	return reference.Type() != plumbing.InvalidReference
39
}
40

41
// IsBranchExist returns true if given branch exists in current repository.
42
func (repo *Repository) IsBranchExist(name string) bool {
43
	if name == "" {
44
		return false
45
	}
46
	reference, err := repo.gogitRepo.Reference(plumbing.ReferenceName(BranchPrefix+name), true)
47
	if err != nil {
48
		return false
49
	}
50
	return reference.Type() != plumbing.InvalidReference
51
}
52

53
// GetBranches returns branches from the repository, skipping "skip" initial branches and
54
// returning at most "limit" branches, or all branches if "limit" is 0.
55
// Branches are returned with sort of `-commiterdate` as the nogogit
56
// implementation. This requires full fetch, sort and then the
57
// skip/limit applies later as gogit returns in undefined order.
58
func (repo *Repository) GetBranchNames(skip, limit int) ([]string, int, error) {
59
	type BranchData struct {
60
		name          string
61
		committerDate int64
62
	}
63
	var branchData []BranchData
64

65
	branchIter, err := repo.gogitRepo.Branches()
66
	if err != nil {
67
		return nil, 0, err
68
	}
69

70
	_ = branchIter.ForEach(func(branch *plumbing.Reference) error {
71
		obj, err := repo.gogitRepo.CommitObject(branch.Hash())
72
		if err != nil {
73
			// skip branch if can't find commit
74
			return nil
75
		}
76

77
		branchData = append(branchData, BranchData{strings.TrimPrefix(branch.Name().String(), BranchPrefix), obj.Committer.When.Unix()})
78
		return nil
79
	})
80

81
	sort.Slice(branchData, func(i, j int) bool {
82
		return !(branchData[i].committerDate < branchData[j].committerDate)
83
	})
84

85
	var branchNames []string
86
	maxPos := len(branchData)
87
	if limit > 0 {
88
		maxPos = min(skip+limit, maxPos)
89
	}
90
	for i := skip; i < maxPos; i++ {
91
		branchNames = append(branchNames, branchData[i].name)
92
	}
93

94
	return branchNames, len(branchData), nil
95
}
96

97
// WalkReferences walks all the references from the repository
98
func (repo *Repository) WalkReferences(arg ObjectType, skip, limit int, walkfn func(sha1, refname string) error) (int, error) {
99
	i := 0
100
	var iter storer.ReferenceIter
101
	var err error
102
	switch arg {
103
	case ObjectTag:
104
		iter, err = repo.gogitRepo.Tags()
105
	case ObjectBranch:
106
		iter, err = repo.gogitRepo.Branches()
107
	default:
108
		iter, err = repo.gogitRepo.References()
109
	}
110
	if err != nil {
111
		return i, err
112
	}
113
	defer iter.Close()
114

115
	err = iter.ForEach(func(ref *plumbing.Reference) error {
116
		if i < skip {
117
			i++
118
			return nil
119
		}
120
		err := walkfn(ref.Hash().String(), string(ref.Name()))
121
		i++
122
		if err != nil {
123
			return err
124
		}
125
		if limit != 0 && i >= skip+limit {
126
			return storer.ErrStop
127
		}
128
		return nil
129
	})
130
	return i, err
131
}
132

133
// GetRefsBySha returns all references filtered with prefix that belong to a sha commit hash
134
func (repo *Repository) GetRefsBySha(sha, prefix string) ([]string, error) {
135
	var revList []string
136
	iter, err := repo.gogitRepo.References()
137
	if err != nil {
138
		return nil, err
139
	}
140
	err = iter.ForEach(func(ref *plumbing.Reference) error {
141
		if ref.Hash().String() == sha && strings.HasPrefix(string(ref.Name()), prefix) {
142
			revList = append(revList, string(ref.Name()))
143
		}
144
		return nil
145
	})
146
	return revList, err
147
}
148