Fixes go-gitea#2738 - /git/tags API

Author: richmahn

models/repo_tag.go

@@ -8,7 +8,7 @@ import (
 	"code.gitea.io/gitea/modules/git"
 )
 
-// GetTagsByPath returns repo tags by it's path
+// GetTagsByPath returns repo tags by its path
 func GetTagsByPath(path string) ([]*git.Tag, error) {
 	gitRepo, err := git.OpenRepository(path)
 	if err != nil {

modules/git/repo_ref.go

@@ -31,15 +31,19 @@ func (repo *Repository) GetRefsFiltered(pattern string) ([]*Reference, error) {
 	if err = refsIter.ForEach(func(ref *plumbing.Reference) error {
 		if ref.Name() != plumbing.HEAD && !ref.Name().IsRemote() &&
 			(pattern == "" || strings.HasPrefix(ref.Name().String(), pattern)) {
+			refType := string(ObjectCommit)
+			if ref.Name().IsTag() {
+				// tags can be of type `commit` (lightweight) or `tag` (annotated)
+				if tagType, _ := repo.GetTagType(SHA1(ref.Hash())); err == nil {
+					refType = tagType
+				}
+			}
 			r := &Reference{
 				Name:   ref.Name().String(),
 				Object: SHA1(ref.Hash()),
-				Type:   string(ObjectCommit),
+				Type:   refType,
 				repo:   repo,
 			}
-			if ref.Name().IsTag() {
-				r.Type = string(ObjectTag)
-			}
 			refs = append(refs, r)
 		}
 		return nil

modules/git/repo_tag.go

@@ -6,6 +6,7 @@
 package git
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/mcuadros/go-version"
@@ -42,27 +43,52 @@ func (repo *Repository) getTag(id SHA1) (*Tag, error) {
 		return t.(*Tag), nil
 	}
 
-	// Get tag type
-	tp, err := NewCommand("cat-file", "-t", id.String()).RunInDir(repo.Path)
+	// Get tag name
+	name, err := repo.GetTagNameBySHA(id.String())
 	if err != nil {
 		return nil, err
 	}
-	tp = strings.TrimSpace(tp)
 
-	// Tag is a commit.
+	tp, err := repo.GetTagType(id)
+	if err != nil {
+		return nil, err
+	}
+
+	// The id passed in could be a tag object ID or a commit ID, so getting both
+	tagID := id
+	if tagIDStr, _ := repo.GetTagID(name); tagIDStr != "" {
+		if tID, err := NewIDFromString(tagIDStr); err == nil {
+			tagID = tID
+		}
+	}
+	commitID := id
+	if commitIDStr, _ := repo.GetTagCommitID(name); commitIDStr != "" {
+		if cID, err := NewIDFromString(commitIDStr); err == nil {
+			commitID = cID
+		}
+	}
+
+	// If type is "commit, the tag is a lightweight tag
 	if ObjectType(tp) == ObjectCommit {
+		commit, err := repo.GetCommit(id.String())
+		if err != nil {
+			return nil, err
+		}
 		tag := &Tag{
-			ID:     id,
-			Object: id,
+			Name:   name,
+			ID:     tagID,
+			Object: commitID,
 			Type:   string(ObjectCommit),
+			Tagger: commit.Committer,
+			Message: commit.Message(),
 			repo:   repo,
 		}
 
 		repo.tagCache.Set(id.String(), tag)
 		return tag, nil
 	}
 
-	// Tag with message.
+	// The tag is an annotated tag with a message.
 	data, err := NewCommand("cat-file", "-p", id.String()).RunInDirBytes(repo.Path)
 	if err != nil {
 		return nil, err
@@ -73,13 +99,53 @@ func (repo *Repository) getTag(id SHA1) (*Tag, error) {
 		return nil, err
 	}
 
+	tag.Name = name
 	tag.ID = id
 	tag.repo = repo
 
 	repo.tagCache.Set(id.String(), tag)
 	return tag, nil
 }
 
+// GetTagNameBySHA returns the name of a tag from its tag object SHA or commit SHA
+func (repo *Repository) GetTagNameBySHA(sha string) (string, error) {
+	if len(sha) < 5 {
+		return "", fmt.Errorf("SHA is too short: %s", sha)
+	}
+
+	stdout, err := NewCommand("show-ref", "--tags", "-d").RunInDir(repo.Path)
+	if err != nil {
+		return "", err
+	}
+
+	tagRefs := strings.Split(stdout, "\n")
+	for _, tagRef := range tagRefs {
+		if len(strings.TrimSpace(tagRef)) > 0 {
+			fields := strings.Fields(tagRef)
+			if strings.HasPrefix(fields[0], sha) && strings.HasPrefix(fields[1], "refs/tags/") {
+				name := strings.Split(fields[1], "/")[2]
+				// annotated tags show up twice, their name for commit ID is suffixed with ^{}
+				name = strings.TrimSuffix(name, "^{}")
+				return name, nil
+			}
+		}
+	}
+	return "", ErrNotExist{ID: sha}
+}
+
+// GetTagID returns the object ID for a tag (annotated tags have both an object SHA AND a commit SHA)
+func (repo *Repository) GetTagID(name string) (string, error) {
+	stdout, err := NewCommand("show-ref", name).RunInDir(repo.Path)
+	if err != nil {
+		return "", err
+	}
+	fields := strings.Fields(stdout)
+	if len(fields) != 2 {
+		return "", ErrNotExist{ID: name}
+	}
+	return fields[0], nil
+}
+
 // GetTag returns a Git tag by given name.
 func (repo *Repository) GetTag(name string) (*Tag, error) {
 	idStr, err := repo.GetTagCommitID(name)
@@ -96,7 +162,6 @@ func (repo *Repository) GetTag(name string) (*Tag, error) {
 	if err != nil {
 		return nil, err
 	}
-	tag.Name = name
 	return tag, nil
 }
 
@@ -150,3 +215,38 @@ func (repo *Repository) GetTags() ([]string, error) {
 
 	return tagNames, nil
 }
+
+// GetTagType gets the type of the tag, either commit (simple) or tag (annotated)
+func (repo *Repository) GetTagType(id SHA1) (string, error) {
+	// Get tag type
+	stdout, err := NewCommand("cat-file", "-t", id.String()).RunInDir(repo.Path)
+	if err != nil {
+		return "", err
+	}
+	if len(stdout) == 0 {
+		return "", ErrNotExist{ID: id.String()}
+	}
+	return strings.TrimSpace(stdout), nil
+}
+
+// GetAnnotatedTag returns a Git tag by its SHA, must be an annotated tag
+func (repo *Repository) GetAnnotatedTag(sha string) (*Tag, error) {
+	id, err := NewIDFromString(sha)
+	if err != nil {
+		return nil, err
+	}
+
+	// Tag type must be "tag" (annotated) and not a "commit" (lightweight) tag
+	if tagType, err := repo.GetTagType(id); err != nil {
+		return nil, err
+	} else if ObjectType(tagType) != ObjectTag {
+		// not an annotated tag
+		return nil, ErrNotExist{ID: id.String()}
+	}
+
+	tag, err := repo.getTag(id)
+	if err != nil {
+		return nil, err
+	}
+	return tag, nil
+}

modules/structs/repo_tag.go

@@ -4,13 +4,32 @@
 
 package structs
 
-// Tag represents a repository tag
+// Tag represents a repository tag for the /tags API endpoint
 type Tag struct {
 	Name   string `json:"name"`
+	ID     string `json:"id"`
 	Commit struct {
 		SHA string `json:"sha"`
 		URL string `json:"url"`
 	} `json:"commit"`
 	ZipballURL string `json:"zipball_url"`
 	TarballURL string `json:"tarball_url"`
 }
+
+// GitTag represents a git tag for the /git/tags API endpoint
+type GitTag struct {
+	Tag          string                     `json:"tag"`
+	SHA          string                     `json:"sha"`
+	URL          string                     `json:"url"`
+	Message      string                     `json:"message"`
+	Tagger       *CommitUser                `json:"tagger"`
+	Object       *GitTagObject              `json:"object"`
+	Verification *PayloadCommitVerification `json:"verification"`
+}
+
+// GitTagObject contains meta information of the tag object
+type GitTagObject struct {
+	Type string `json:"type"`
+	URL  string `json:"url"`
+	SHA  string `json:"sha"`
+}

routers/api/v1/api.go

@@ -761,6 +761,7 @@ func RegisterRoutes(m *macaron.Macaron) {
 					m.Get("/refs/*", repo.GetGitRefs)
 					m.Get("/trees/:sha", context.RepoRef(), repo.GetTree)
 					m.Get("/blobs/:sha", context.RepoRef(), repo.GetBlob)
+					m.Get("/tags/:sha", context.RepoRef(), repo.GetTag)
 				}, reqRepoReader(models.UnitTypeCode))
 				m.Group("/contents", func() {
 					m.Get("/*", repo.GetFileContents)

routers/api/v1/convert/convert.go

@@ -6,6 +6,7 @@ package convert
 
 import (
 	"fmt"
+	"time"
 
 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/modules/git"
@@ -38,6 +39,7 @@ func ToBranch(repo *models.Repository, b *git.Branch, c *git.Commit) *api.Branch
 func ToTag(repo *models.Repository, t *git.Tag) *api.Tag {
 	return &api.Tag{
 		Name: t.Name,
+		ID:   t.ID.String(),
 		Commit: struct {
 			SHA string `json:"sha"`
 			URL string `json:"url"`
@@ -66,13 +68,6 @@ func ToCommit(repo *models.Repository, c *git.Commit) *api.PayloadCommit {
 		log.Error("GetUserByEmail: %v", err)
 	}
 
-	verif := models.ParseCommitWithSignature(c)
-	var signature, payload string
-	if c.Signature != nil {
-		signature = c.Signature.Signature
-		payload = c.Signature.Payload
-	}
-
 	return &api.PayloadCommit{
 		ID:      c.ID.String(),
 		Message: c.Message(),
@@ -87,13 +82,23 @@ func ToCommit(repo *models.Repository, c *git.Commit) *api.PayloadCommit {
 			Email:    c.Committer.Email,
 			UserName: committerUsername,
 		},
-		Timestamp: c.Author.When,
-		Verification: &api.PayloadCommitVerification{
-			Verified:  verif.Verified,
-			Reason:    verif.Reason,
-			Signature: signature,
-			Payload:   payload,
-		},
+		Timestamp:    c.Author.When,
+		Verification: ToVerification(c),
+	}
+}
+
+func ToVerification(c *git.Commit) *api.PayloadCommitVerification {
+	verif := models.ParseCommitWithSignature(c)
+	var signature, payload string
+	if c.Signature != nil {
+		signature = c.Signature.Signature
+		payload = c.Signature.Payload
+	}
+	return &api.PayloadCommitVerification{
+		Verified:  verif.Verified,
+		Reason:    verif.Reason,
+		Signature: signature,
+		Payload:   payload,
 	}
 }
 
@@ -241,3 +246,33 @@ func ToUser(user *models.User, signed, admin bool) *api.User {
 	}
 	return result
 }
+
+// ToGitTag convert git.Tag to api.GitTag
+func ToGitTag(repo *models.Repository, t *git.Tag, c *git.Commit) *api.GitTag {
+	return &api.GitTag{
+		Tag:          t.Name,
+		SHA:          t.ID.String(),
+		Object:       ToGitTagObject(repo, c),
+		Message:      t.Message,
+		Tagger:       ToCommitUser(t.Tagger),
+		Verification: ToVerification(c),
+	}
+}
+
+func ToGitTagObject(repo *models.Repository, commit *git.Commit) *api.GitTagObject {
+	return &api.GitTagObject{
+		SHA:  commit.ID.String(),
+		Type: string(git.ObjectCommit),
+		URL:  util.URLJoin(repo.Link(), "git/commits", commit.ID.String()),
+	}
+}
+
+func ToCommitUser(sig *git.Signature) *api.CommitUser {
+	return &api.CommitUser{
+		Identity: api.Identity{
+			Name:  sig.Name,
+			Email: sig.Email,
+		},
+		Date: sig.When.UTC().Format(time.RFC3339),
+	}
+}

routers/api/v1/repo/git_ref.go

@@ -100,8 +100,7 @@ func getGitRefsInternal(ctx *context.APIContext, filter string) {
 			Object: &api.GitObject{
 				SHA:  refs[i].Object.String(),
 				Type: refs[i].Type,
-				// TODO: Add commit/tag info URL
-				//URL:  ctx.Repo.Repository.APIURL() + "/git/" + refs[i].Type + "s/" + refs[i].Object.String(),
+				URL:  ctx.Repo.Repository.APIURL() + "/git/" + refs[i].Type + "s/" + refs[i].Object.String(),
 			},
 		}
 	}