refactor a little

Author: bigbes

namer/key.go

@@ -17,23 +17,22 @@ type Key interface {
 	Name() string     // Get object name.
 	Type() KeyType    // Get key type.
 	Property() string // Get metadata (e.g., algorithm version).
-	Raw() []byte      // Get raw data.
 	Build() string    // Reconstruct raw key string.
 }
 
 // DefaultKey implements default realization.
 type DefaultKey struct {
 	name     string  // Object identifier.
-	keytype  KeyType // Type of object (hash/signature/value).
+	keyType  KeyType // Type of object (hash/signature/value).
 	property string  // Additional metadata (version/algorithm).
-	raw      []byte  // Raw key string.
+	raw      string  // Raw key string.
 }
 
 // NewDefaultKey returns new Key object.
-func NewDefaultKey(name string, keytype KeyType, property string, raw []byte) DefaultKey {
+func NewDefaultKey(name string, keytype KeyType, property string, raw string) DefaultKey {
 	return DefaultKey{
 		name:     name,
-		keytype:  keytype,
+		keyType:  keytype,
 		property: property,
 		raw:      raw,
 	}
@@ -46,25 +45,15 @@ func (k DefaultKey) Name() string {
 
 // Type returns type of the key.
 func (k DefaultKey) Type() KeyType {
-	return k.keytype
+	return k.keyType
 }
 
 // Property returns property of the key.
 func (k DefaultKey) Property() string {
 	return k.property
 }
 
-// Raw returns raw of the key.
-func (k DefaultKey) Raw() []byte {
-	return k.raw
-}
-
-// Build should reconstruct key from signature and digest or not?
+// Build reconstructs key string.
 func (k DefaultKey) Build() string {
-	return string(k.raw)
-}
-
-// String returns string representation of the `raw` field.
-func (k DefaultKey) String() string {
-	return string(k.raw)
+	return k.raw
 }

namer/namer.go

@@ -2,7 +2,6 @@
 package namer
 
 import (
-	"errors"
 	"fmt"
 	"iter"
 	"strings"
@@ -11,29 +10,66 @@ import (
 const (
 	hashName      = "hash"
 	signatureName = "sig"
-	keysPerName   = 3
 )
 
-var (
-	// ErrInvalidKey is returned when missing key, hash or signature.
-	ErrInvalidKey = errors.New("missing key, hash or signature")
-	// ErrInvalidInput is returned when input data is invalid.
-	ErrInvalidInput = errors.New("failed to generate: invalid input data")
-	// ErrInvalidPrefix is returned when prefix didn't match.
-	ErrInvalidPrefix = errors.New("invalid prefix")
-)
+type InvalidKeyError struct {
+	Key     string
+	Problem string
+}
+
+func (e InvalidKeyError) Error() string {
+	return fmt.Sprintf("invalid key '%s': %s", e.Key, e.Problem)
+}
+
+func errInvalidKey(key string, problem string) error {
+	return InvalidKeyError{
+		Key:     key,
+		Problem: problem,
+	}
+}
+
+type InvalidNameError struct {
+	Name    string
+	Problem string
+}
+
+func (e InvalidNameError) Error() string {
+	return fmt.Sprintf("invalid name '%s': %s", e.Name, e.Problem)
+}
+
+func errInvalidName(name string, problem string) error {
+	return InvalidNameError{
+		Name:    name,
+		Problem: problem,
+	}
+}
 
 // Results represents Namer working result.
 type Results struct {
-	IsSingle     bool             // True if result contains only one object name.
-	IsSingleName string           // Cached name when isSingle=true.
-	Result       map[string][]Key // Grouped keys: object name -> key list.
+	isSingle     bool             // True if result contains only one object name.
+	isSingleName string           // Cached name when isSingle=true.
+	result       map[string][]Key // Grouped keys: object name -> key list.
+}
+
+func getFirstFromMap(m map[string][]Key) string {
+	for name := range m {
+		return name
+	}
+	return ""
+}
+
+func NewResults(initial map[string][]Key) Results {
+	return Results{
+		isSingle:     len(initial) == 1,
+		isSingleName: getFirstFromMap(initial),
+		result:       initial,
+	}
 }
 
 // SelectSingle gets keys for single-name case (if applicable).
 func (r *Results) SelectSingle() ([]Key, bool) {
-	if r.IsSingle {
-		return r.Result[r.IsSingleName], true
+	if r.isSingle {
+		return r.result[r.isSingleName], true
 	}
 
 	return nil, false
@@ -42,17 +78,21 @@ func (r *Results) SelectSingle() ([]Key, bool) {
 // Items return iterator over all name->keys groups.
 func (r *Results) Items() iter.Seq2[string, []Key] {
 	return func(yield func(str string, res []Key) bool) {
-		for i, v := range r.Result {
+		for i, v := range r.result {
 			if !yield(i, v) {
 				return
 			}
 		}
 	}
 }
 
+func (r *Results) Result() map[string][]Key {
+	return r.result
+}
+
 // Select gets keys for a specific object name.
 func (r *Results) Select(name string) ([]Key, bool) {
-	if i, ok := r.Result[name]; ok {
+	if i, ok := r.result[name]; ok {
 		return i, true
 	}
 
@@ -61,7 +101,7 @@ func (r *Results) Select(name string) ([]Key, bool) {
 
 // Len returns the number of unique object names.
 func (r *Results) Len() int {
-	return len(r.Result)
+	return len(r.result)
 }
 
 // DefaultNamer represents default namer.
@@ -73,110 +113,138 @@ type DefaultNamer struct {
 
 // NewDefaultNamer returns new DefaultNamer object with hash/signature names configuration.
 func NewDefaultNamer(prefix string, hashNames []string, sigNames []string) *DefaultNamer {
-	prefix = strings.TrimPrefix(prefix, "/")
-	prefix = strings.TrimSuffix(prefix, "/")
-
 	return &DefaultNamer{
-		prefix:    prefix,    // "storage/".
-		hashNames: hashNames, // "sha256".
-		sigNames:  sigNames,  // "RSAPSS".
+		prefix:    strings.Trim(prefix, "/"),
+		hashNames: hashNames,
+		sigNames:  sigNames,
 	}
 }
 
 // GenerateNames all keys for an object name.
-func (n *DefaultNamer) GenerateNames(name string) []Key {
+func (n *DefaultNamer) GenerateNames(name string) ([]Key, error) {
+	switch {
+	case name == "":
+		return nil, errInvalidName(name, "should not be empty")
+	case strings.HasSuffix(name, "/"):
+		return nil, errInvalidName(name, "should not be prefix")
+	}
+
 	name = strings.TrimPrefix(name, "/")
 
 	out := make([]Key, 0, len(n.hashNames)+len(n.sigNames)+1)
 
 	out = append(out,
 		NewDefaultKey(
-			fmt.Sprintf("/%s/%s", n.prefix, name),
+			name,
 			KeyTypeValue,
 			"",
-			[]byte{},
+			fmt.Sprintf("/%s/%s", n.prefix, name),
 		))
 
 	for _, hash := range n.hashNames {
 		out = append(out,
 			NewDefaultKey(
-				fmt.Sprintf("/%s/%s/%s/%s", n.prefix, hashName, hash, name),
+				name,
 				KeyTypeHash,
 				hash,
-				[]byte{},
+				fmt.Sprintf("/%s/%s/%s/%s", n.prefix, hashName, hash, name),
 			),
 		)
 	}
 
 	for _, sig := range n.sigNames {
 		out = append(out,
 			NewDefaultKey(
-				fmt.Sprintf("/%s/%s/%s/%s", n.prefix, signatureName, sig, name),
+				name,
 				KeyTypeSignature,
 				sig,
-				[]byte{},
+				fmt.Sprintf("/%s/%s/%s/%s", n.prefix, signatureName, sig, name),
 			),
 		)
 	}
 
-	return out
+	return out, nil
 }
 
-// ParseKeys combine multiple raw keys into grouped results.
-func (n *DefaultNamer) ParseKeys(names []string) (Results, error) {
-	var out Results
+func (n *DefaultNamer) ParseKey(name string) (DefaultKey, error) {
+	originalName := name
 
-	out.Result = map[string][]Key{}
-
-	if len(names) == 0 {
-		return out, ErrInvalidInput
-	}
-
-	if len(names) == 1 {
-		out.IsSingle = true
-		out.IsSingleName = names[0]
+	name, found := strings.CutPrefix(strings.TrimPrefix(name, "/"), n.prefix)
+	if !found {
+		return DefaultKey{}, errInvalidKey(originalName, "prefix not found")
 	}
 
-	for _, name := range names {
-		originName := name
-
-		name = strings.TrimPrefix(name, "/")
-
-		name, found := strings.CutPrefix(name, n.prefix)
-		if !found {
-			return out, ErrInvalidInput
+	name = strings.TrimPrefix(name, "/")
+	nameParts := strings.SplitN(name, "/", 3)
+
+	switch {
+	case len(nameParts) <= 0 || len(nameParts) > 3:
+		panic("illegal state") // Unreachable.
+
+	case nameParts[0] == signatureName:
+		switch {
+		case len(nameParts) != 3:
+			return DefaultKey{}, errInvalidKey(originalName, "found sig prefix, but key name is incomplete")
+		case len(nameParts[1]) == 0:
+			return DefaultKey{}, errInvalidKey(originalName, "found sig prefix, but hash name is invalid")
+		case len(nameParts[2]) == 0:
+			return DefaultKey{}, errInvalidKey(originalName, "found sig prefix, but key name is invalid")
+		case strings.HasSuffix(nameParts[2], "/"):
+			return DefaultKey{}, errInvalidKey(originalName, "found hash prefix, but key name is prefix")
 		}
 
-		name = strings.TrimSuffix(name, "/")
+		return NewDefaultKey(
+			nameParts[2],
+			KeyTypeSignature,
+			nameParts[1],
+			originalName,
+		), nil
+	case nameParts[0] == hashName:
+		switch {
+		case len(nameParts) != 3:
+			return DefaultKey{}, errInvalidKey(originalName, "found hash prefix, but key name is incomplete")
+		case len(nameParts[1]) == 0:
+			return DefaultKey{}, errInvalidKey(originalName, "found hash prefix, but hash name is invalid")
+		case len(nameParts[2]) == 0:
+			return DefaultKey{}, errInvalidKey(originalName, "found hash prefix, but key name is invalid")
+		case strings.HasSuffix(nameParts[2], "/"):
+			return DefaultKey{}, errInvalidKey(originalName, "found hash prefix, but key name is prefix")
+		}
 
-		parts := strings.Split(name, "/")
-		partslen := len(parts)
+		return NewDefaultKey(
+			nameParts[2],
+			KeyTypeHash,
+			nameParts[1],
+			originalName,
+		), nil
+	default:
+		if strings.HasSuffix(name, "/") {
+			return DefaultKey{}, errInvalidKey(originalName, "key name should not be prefix")
+		}
 
-		var keyType KeyType
+		return NewDefaultKey(
+			name,
+			KeyTypeValue,
+			"",
+			originalName,
+		), nil
+	}
+}
 
-		var keyProp string
+// ParseKeys combine multiple raw keys into grouped results.
+func (n *DefaultNamer) ParseKeys(names []string, ignoreError bool) (Results, error) {
+	out := map[string][]Key{}
 
-		switch parts[0] {
-		case hashName:
-			keyType = KeyTypeHash
-			keyProp = parts[1]
-		case signatureName:
-			keyType = KeyTypeSignature
-			keyProp = parts[1]
-		default:
-			keyType = KeyTypeValue
-			keyProp = ""
+	for _, name := range names {
+		key, err := n.ParseKey(name)
+		switch {
+		case err != nil && ignoreError:
+			continue
+		case err != nil:
+			return Results{}, err
 		}
-
-		key := NewDefaultKey(
-			originName,
-			keyType,
-			keyProp,
-			[]byte{},
-		)
-
-		out.Result[parts[partslen-1]] = append(out.Result[parts[partslen-1]], key)
+		out[key.name] = append(out[key.name], key)
 	}
 
-	return out, nil
+	return NewResults(out), nil
 }