fix: compute ref and ref_name prioritising HEAD pointer if tag is not set

pkg/common/git/git.go

@@ -86,78 +86,52 @@
 // FindGitRef get the current git ref
 func FindGitRef(ctx context.Context, file string) (string, error) {
 	logger := common.Logger(ctx)
-
 	logger.Debugf("Loading revision from git directory")
-	_, ref, err := FindGitRevision(ctx, file)
-	if err != nil {
-		return "", err
-	}
-
-	logger.Debugf("HEAD points to '%s'", ref)
-
 	// Prefer the git library to iterate over the references and find a matching tag or branch.
-	var refTag = ""
-	var refBranch = ""
+	refName := ""
 	repo, err := git.PlainOpenWithOptions(
 		file,
 		&git.PlainOpenOptions{
 			DetectDotGit:          true,
 			EnableDotGitCommonDir: true,
 		},
 	)
-
 	if err != nil {
 		return "", err
 	}
 
-	iter, err := repo.References()
+	headRef, err := repo.Head()
 	if err != nil {
 		return "", err
 	}
+	logger.Debugf("HEAD points to revision '%s'", headRef.Hash().String())
 
-	// find the reference that matches the revision's has
-	err = iter.ForEach(func(r *plumbing.Reference) error {
-		/* tags and branches will have the same hash
-		 * when a user checks out a tag, it is not mentioned explicitly
-		 * in the go-git package, we must identify the revision
-		 * then check if any tag matches that revision,
-		 * if so then we checked out a tag
-		 * else we look for branches and if matches,
-		 * it means we checked out a branch
-		 *
-		 * If a branches matches first we must continue and check all tags (all references)
-		 * in case we match with a tag later in the interation
-		 */
-		if r.Hash().String() == ref {
-			if r.Name().IsTag() {
-				refTag = r.Name().String()
-			}
-			if r.Name().IsBranch() {
-				refBranch = r.Name().String()
-			}
-		}
+	// The assumption is made that if the revision has a tag associated with it the ref and ref_name should reference it.
+	// This is relevant for the release workflow trigger.
+	// The Tags iterator is the most reliable method to lookup if a revision is tagged (the go-git repository.TagObject method only returns annotated tags).
+	tags, _ := repo.Tags()
 
-		// we found what we where looking for
-		if refTag != "" && refBranch != "" {
+	t := tags.ForEach(func(r *plumbing.Reference) error {
+		if r.Hash().String() == headRef.Hash().String() {
+			refName = r.Name().String()
 			return storer.ErrStop
 		}
-
-		return nil
+		return err
 	})
 
-	if err != nil {
-		return "", err
+	if t != nil {
+		logger.WithError(t).Error("Tag lookup failed.")
 	}
 
-	// order matters here see above comment.
-	if refTag != "" {
-		return refTag, nil
+	if refName == "" {
+		refName = headRef.Name().String()
 	}
-	if refBranch != "" {
-		return refBranch, nil
+
+	if refName != "" {
+		return refName, err
 	}
 
-	return "", fmt.Errorf("failed to identify reference (tag/branch) for the checked-out revision '%s'", ref)
+	return "", fmt.Errorf("Failed to identify preference (tag/branch) for the checked-out revision '%s'", headRef.Hash().String())
 }
 
 // FindGithubRepo get the repo

pkg/common/git/git_test.go

@@ -162,6 +162,17 @@ func TestGitFindRef(t *testing.T) {
 				require.Equal(t, "refs/heads/mybranch", ref)
 			},
 		},
+		"current_head_is_master_and_pointer_exists_to_another_branch": {
+			Prepare: func(t *testing.T, dir string) {
+				require.NoError(t, gitCmd("-C", dir, "commit", "--allow-empty", "-m", "msg"))
+				require.NoError(t, gitCmd("-C", dir, "checkout", "-b", "mybranch"))
+				require.NoError(t, gitCmd("-C", dir, "checkout", "master"))
+			},
+			Assert: func(t *testing.T, ref string, err error) {
+				require.NoError(t, err)
+				require.Equal(t, "refs/heads/master", ref)
+			},
+		},
 	} {
 		tt := tt
 		name := name