code.gitea.io/gitea@v1.19.3/modules/git/repo_branch_gogit.go (about)

     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  	"context"
    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  func (repo *Repository) GetBranchNames(skip, limit int) ([]string, int, error) {
    56  	var branchNames []string
    57  
    58  	branches, err := repo.gogitRepo.Branches()
    59  	if err != nil {
    60  		return nil, 0, err
    61  	}
    62  
    63  	i := 0
    64  	count := 0
    65  	_ = branches.ForEach(func(branch *plumbing.Reference) error {
    66  		count++
    67  		if i < skip {
    68  			i++
    69  			return nil
    70  		} else if limit != 0 && count > skip+limit {
    71  			return nil
    72  		}
    73  
    74  		branchNames = append(branchNames, strings.TrimPrefix(branch.Name().String(), BranchPrefix))
    75  		return nil
    76  	})
    77  
    78  	// TODO: Sort?
    79  
    80  	return branchNames, count, nil
    81  }
    82  
    83  // WalkReferences walks all the references from the repository
    84  // refType should be empty, ObjectTag or ObjectBranch. All other values are equivalent to empty.
    85  func WalkReferences(ctx context.Context, repoPath string, walkfn func(sha1, refname string) error) (int, error) {
    86  	repo := RepositoryFromContext(ctx, repoPath)
    87  	if repo == nil {
    88  		var err error
    89  		repo, err = OpenRepository(ctx, repoPath)
    90  		if err != nil {
    91  			return 0, err
    92  		}
    93  		defer repo.Close()
    94  	}
    95  
    96  	i := 0
    97  	iter, err := repo.gogitRepo.References()
    98  	if err != nil {
    99  		return i, err
   100  	}
   101  	defer iter.Close()
   102  
   103  	err = iter.ForEach(func(ref *plumbing.Reference) error {
   104  		err := walkfn(ref.Hash().String(), string(ref.Name()))
   105  		i++
   106  		return err
   107  	})
   108  	return i, err
   109  }
   110  
   111  // WalkReferences walks all the references from the repository
   112  func (repo *Repository) WalkReferences(arg ObjectType, skip, limit int, walkfn func(sha1, refname string) error) (int, error) {
   113  	i := 0
   114  	var iter storer.ReferenceIter
   115  	var err error
   116  	switch arg {
   117  	case ObjectTag:
   118  		iter, err = repo.gogitRepo.Tags()
   119  	case ObjectBranch:
   120  		iter, err = repo.gogitRepo.Branches()
   121  	default:
   122  		iter, err = repo.gogitRepo.References()
   123  	}
   124  	if err != nil {
   125  		return i, err
   126  	}
   127  	defer iter.Close()
   128  
   129  	err = iter.ForEach(func(ref *plumbing.Reference) error {
   130  		if i < skip {
   131  			i++
   132  			return nil
   133  		}
   134  		err := walkfn(ref.Hash().String(), string(ref.Name()))
   135  		i++
   136  		if err != nil {
   137  			return err
   138  		}
   139  		if limit != 0 && i >= skip+limit {
   140  			return storer.ErrStop
   141  		}
   142  		return nil
   143  	})
   144  	return i, err
   145  }
   146  
   147  // GetRefsBySha returns all references filtered with prefix that belong to a sha commit hash
   148  func (repo *Repository) GetRefsBySha(sha, prefix string) ([]string, error) {
   149  	var revList []string
   150  	iter, err := repo.gogitRepo.References()
   151  	if err != nil {
   152  		return nil, err
   153  	}
   154  	err = iter.ForEach(func(ref *plumbing.Reference) error {
   155  		if ref.Hash().String() == sha && strings.HasPrefix(string(ref.Name()), prefix) {
   156  			revList = append(revList, string(ref.Name()))
   157  		}
   158  		return nil
   159  	})
   160  	return revList, err
   161  }