From 21f106e6647ce70d1d40df65cd85e2e86264d2f0 Mon Sep 17 00:00:00 2001
From: Máximo Cuadros <mcuadros@gmail.com>
Date: Sun, 10 May 2020 11:02:21 +0200
Subject: config: RefSpec.IsExactSHA1, validates if the refspec describes an
 exact SHA1 ref

---
 config/refspec.go      |  9 +++++++--
 config/refspec_test.go | 16 +++++++++++++++-
 plumbing/hash.go       | 10 ++++++++++
 plumbing/hash_test.go  |  6 ++++++
 4 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/config/refspec.go b/config/refspec.go
index 87cf2a6..4bfaa37 100644
--- a/config/refspec.go
+++ b/config/refspec.go
@@ -25,7 +25,7 @@ var (
 // reference even if it isn’t a fast-forward.
 // eg.: "+refs/heads/*:refs/remotes/origin/*"
 //
-// https://git-scm.com/book/es/v2/Git-Internals-The-Refspec
+// https://git-scm.com/book/en/v2/Git-Internals-The-Refspec
 type RefSpec string
 
 // Validate validates the RefSpec
@@ -59,6 +59,11 @@ func (s RefSpec) IsDelete() bool {
 	return s[0] == refSpecSeparator[0]
 }
 
+// IsExactSHA1 returns true if the source is a SHA1 hash.
+func (s RefSpec) IsExactSHA1() bool {
+	return plumbing.IsHash(s.Src())
+}
+
 // Src return the src side.
 func (s RefSpec) Src() string {
 	spec := string(s)
@@ -69,8 +74,8 @@ func (s RefSpec) Src() string {
 	} else {
 		start = 0
 	}
-	end := strings.Index(spec, refSpecSeparator)
 
+	end := strings.Index(spec, refSpecSeparator)
 	return spec[start:end]
 }
 
diff --git a/config/refspec_test.go b/config/refspec_test.go
index b9c43b2..3be7573 100644
--- a/config/refspec_test.go
+++ b/config/refspec_test.go
@@ -3,8 +3,8 @@ package config
 import (
 	"testing"
 
-	. "gopkg.in/check.v1"
 	"github.com/go-git/go-git/v5/plumbing"
+	. "gopkg.in/check.v1"
 )
 
 type RefSpecSuite struct{}
@@ -37,6 +37,12 @@ func (s *RefSpecSuite) TestRefSpecIsValid(c *C) {
 
 	spec = RefSpec("refs/heads:")
 	c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedSeparator)
+
+	spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/foo")
+	c.Assert(spec.Validate(), Equals, nil)
+
+	spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/*")
+	c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard)
 }
 
 func (s *RefSpecSuite) TestRefSpecIsForceUpdate(c *C) {
@@ -58,6 +64,14 @@ func (s *RefSpecSuite) TestRefSpecIsDelete(c *C) {
 	c.Assert(spec.IsDelete(), Equals, false)
 }
 
+func (s *RefSpecSuite) TestRefSpecIsExactSHA1(c *C) {
+	spec := RefSpec("foo:refs/heads/master")
+	c.Assert(spec.IsExactSHA1(), Equals, false)
+
+	spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/foo")
+	c.Assert(spec.IsExactSHA1(), Equals, true)
+}
+
 func (s *RefSpecSuite) TestRefSpecSrc(c *C) {
 	spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
 	c.Assert(spec.Src(), Equals, "refs/heads/*")
diff --git a/plumbing/hash.go b/plumbing/hash.go
index 637a425..afc602a 100644
--- a/plumbing/hash.go
+++ b/plumbing/hash.go
@@ -71,3 +71,13 @@ type HashSlice []Hash
 func (p HashSlice) Len() int           { return len(p) }
 func (p HashSlice) Less(i, j int) bool { return bytes.Compare(p[i][:], p[j][:]) < 0 }
 func (p HashSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
+// IsHash returns true if the given string is a valid hash.
+func IsHash(s string) bool {
+	if len(s) != 40 {
+		return false
+	}
+
+	_, err := hex.DecodeString(s)
+	return err == nil
+}
diff --git a/plumbing/hash_test.go b/plumbing/hash_test.go
index fc2428b..0f836b0 100644
--- a/plumbing/hash_test.go
+++ b/plumbing/hash_test.go
@@ -52,3 +52,9 @@ func (s *HashSuite) TestHashesSort(c *C) {
 	c.Assert(i[0], Equals, NewHash("1111111111111111111111111111111111111111"))
 	c.Assert(i[1], Equals, NewHash("2222222222222222222222222222222222222222"))
 }
+
+func (s *HashSuite) TestIsHash(c *C) {
+	c.Assert(IsHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d"), Equals, true)
+	c.Assert(IsHash("foo"), Equals, false)
+	c.Assert(IsHash("zab686eafeb1f44702738c8b0f24f2567c36da6d"), Equals, false)
+}
-- 
cgit