Identifiers with configurable prefixes. (#727)

Co-authored-by: Helio Machado <0x2b3bfa0+git@googlemail.com>

Author: Domas Monkus

task/common/identifier.go

@@ -10,56 +10,73 @@ import (
 	"crypto/sha256"
 
 	"github.com/aohorodnyk/uid"
-	"github.com/dustinkirkland/golang-petname"
+	petname "github.com/dustinkirkland/golang-petname"
 )
 
 type Identifier struct {
-	name string
-	salt string
+	prefix string
+	name   string
+	salt   string
 }
 
 var ErrWrongIdentifier = errors.New("wrong identifier")
 
 const (
-	maximumLongLength = 50
-	shortLength       = 16
-	nameLength        = maximumLongLength-shortLength-uint32(len("tpi---"))
+	defaultIdentifierPrefix = "tpi"
+	maximumLongLength       = 50
+	shortLength             = 16
+	nameLength              = maximumLongLength - shortLength - uint32(len("tpi---"))
 )
 
+// ParseIdentifier parses the string representation of the identifier.
 func ParseIdentifier(identifier string) (Identifier, error) {
-	re := regexp.MustCompile(`(?s)^tpi-([a-z0-9]+(?:[a-z0-9-]*[a-z0-9])?)-([a-z0-9]+)-([a-z0-9]+)$`)
+	re := regexp.MustCompile(`(?s)^([a-z0-9]{3})-([a-z0-9]+(?:[a-z0-9-]*[a-z0-9])?)-([a-z0-9]+)-([a-z0-9]+)$`)
 
-	if match := re.FindStringSubmatch(string(identifier)); len(match) > 0 && hash(match[1]+match[2], shortLength/2) == match[3] {
-		return Identifier{name: match[1], salt: match[2]}, nil
+	if match := re.FindStringSubmatch(string(identifier)); len(match) > 0 && hash(match[2]+match[3], shortLength/2) == match[4] {
+		return Identifier{prefix: match[1], name: match[2], salt: match[3]}, nil
 	}
 
 	return Identifier{}, ErrWrongIdentifier
 }
 
+// NewDeterministicIdentifierWithPrefix returns a new deterministic Identifier, with
+// the specified prefix, using the provided name as a seed. Repeated calls to this
+// function are guaranteed to generate the same Identifier.
+func NewDeterministicIdentifierWithPrefix(prefix, name string) Identifier {
+	seed := normalize(name, nameLength)
+	return Identifier{prefix: prefix[0:3], name: name, salt: hash(seed, shortLength/2)}
+}
+
 // NewDeterministicIdentifier returns a new deterministic Identifier, using the
 // provided name as a seed. Repeated calls to this function are guaranteed to
 // generate the same Identifier.
 func NewDeterministicIdentifier(name string) Identifier {
-	seed := normalize(name, nameLength)
-	return Identifier{name: name, salt: hash(seed, shortLength/2)}
+	return NewDeterministicIdentifierWithPrefix(defaultIdentifierPrefix, name)
 }
 
-// NewRandomIdentifier returns a new random Identifier. Repeated calls to this
-// function are guaranteed to generate different Identifiers, as long as there
-// are no collisions.
-func NewRandomIdentifier(name string) Identifier {
+// NewRandomIdentifierWithPrefix returns a new random Identifier with the
+// specified prefix. Only the first 3 symbols of the prefix are used.
+// Repeated calls to this function are guaranteed to generate different
+// Identifiers, as long as there are no collisions.
+func NewRandomIdentifierWithPrefix(prefix, name string) Identifier {
 	seed := uid.NewProvider36Size(8).MustGenerate().String()
 	if name == "" {
 		petname.NonDeterministicMode()
 		name = petname.Generate(3, "-")
 	}
+	return Identifier{prefix: prefix[0:3], name: name, salt: hash(seed, shortLength/2)}
+}
 
-	return Identifier{name: name, salt: hash(seed, shortLength/2)}
+// NewRandomIdentifier returns a new random Identifier.
+// Repeated calls to this function are guaranteed to generate different
+// Identifiers, as long as there are no collisions.
+func NewRandomIdentifier(name string) Identifier {
+	return NewRandomIdentifierWithPrefix(defaultIdentifierPrefix, name)
 }
 
 func (i Identifier) Long() string {
 	name := normalize(i.name, nameLength)
-	return fmt.Sprintf("tpi-%s-%s-%s", name, i.salt, hash(name+i.salt, shortLength/2))
+	return fmt.Sprintf("%s-%s-%s-%s", i.prefix, name, i.salt, hash(name+i.salt, shortLength/2))
 }
 
 func (i Identifier) Short() string {

task/common/identifier_test.go

@@ -51,7 +51,7 @@ func TestIdentifier(t *testing.T) {
 
 	t.Run("randomness", func(t *testing.T) {
 		name := "test"
-		
+
 		first := NewRandomIdentifier(name)
 		second := NewRandomIdentifier(name)
 
@@ -61,4 +61,15 @@ func TestIdentifier(t *testing.T) {
 		require.Contains(t, first.Long(), name)
 		require.Contains(t, second.Long(), name)
 	})
+
+	t.Run("prefix", func(t *testing.T) {
+		identifier := NewDeterministicIdentifierWithPrefix("ipsum", "test")
+
+		require.Equal(t, "ips-test-3z4xlzwq-3u0vweb4", identifier.Long())
+		require.Equal(t, "3z4xlzwq3u0vweb4", identifier.Short())
+
+		parsed, err := ParseIdentifier(identifier.Long())
+		require.Equal(t, parsed.Long(), identifier.Long())
+		require.NoError(t, err)
+	})
 }