switch from fmt.Errorf to errors.New for static strings

atproto/syntax/atidentifier.go

···
 package syntax
 
 import (
-	"fmt"
+	"errors"
 	"strings"
 )
 
···
 
 func ParseAtIdentifier(raw string) (*AtIdentifier, error) {
 	if raw == "" {
-		return nil, fmt.Errorf("expected AT account identifier, got empty string")
+		return nil, errors.New("expected AT account identifier, got empty string")
 	}
 	if strings.HasPrefix(raw, "did:") {
 		did, err := ParseDID(raw)
···
 	if ok {
 		return handle, nil
 	}
-	return "", fmt.Errorf("AT Identifier is not a Handle")
+	return "", errors.New("AT Identifier is not a Handle")
 }
 
 func (n AtIdentifier) IsDID() bool {
···
 	if ok {
 		return did, nil
 	}
-	return "", fmt.Errorf("AT Identifier is not a DID")
+	return "", errors.New("AT Identifier is not a DID")
 }
 
 func (n AtIdentifier) Normalize() AtIdentifier {

atproto/syntax/aturi.go

···
 package syntax
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"strings"
···
 
 func ParseATURI(raw string) (ATURI, error) {
 	if len(raw) > 8192 {
-		return "", fmt.Errorf("ATURI is too long (8192 chars max)")
+		return "", errors.New("ATURI is too long (8192 chars max)")
 	}
 	parts := aturiRegex.FindStringSubmatch(raw)
 	if parts == nil || len(parts) < 2 || parts[0] == "" {
-		return "", fmt.Errorf("AT-URI syntax didn't validate via regex")
+		return "", errors.New("AT-URI syntax didn't validate via regex")
 	}
 	// verify authority as either a DID or NSID
 	_, err := ParseAtIdentifier(parts[1])

atproto/syntax/cid.go

···
 package syntax
 
 import (
-	"fmt"
+	"errors"
 	"regexp"
 	"strings"
 )
···
 
 func ParseCID(raw string) (CID, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected CID, got empty string")
+		return "", errors.New("expected CID, got empty string")
 	}
 	if len(raw) > 256 {
-		return "", fmt.Errorf("CID is too long (256 chars max)")
+		return "", errors.New("CID is too long (256 chars max)")
 	}
 	if len(raw) < 8 {
-		return "", fmt.Errorf("CID is too short (8 chars min)")
+		return "", errors.New("CID is too short (8 chars min)")
 	}
 
 	if !cidRegex.MatchString(raw) {
-		return "", fmt.Errorf("CID syntax didn't validate via regex")
+		return "", errors.New("CID syntax didn't validate via regex")
 	}
 	if strings.HasPrefix(raw, "Qmb") {
-		return "", fmt.Errorf("CIDv0 not allowed in this version of atproto")
+		return "", errors.New("CIDv0 not allowed in this version of atproto")
 	}
 	return CID(raw), nil
 }

atproto/syntax/datetime.go

···
 package syntax
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"strings"
···
 
 func ParseDatetime(raw string) (Datetime, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected datetime, got empty string")
+		return "", errors.New("expected datetime, got empty string")
 	}
 	if len(raw) > 64 {
-		return "", fmt.Errorf("Datetime too long (max 64 chars)")
+		return "", errors.New("Datetime too long (max 64 chars)")
 	}
 
 	if !datetimeRegex.MatchString(raw) {
-		return "", fmt.Errorf("Datetime syntax didn't validate via regex")
+		return "", errors.New("Datetime syntax didn't validate via regex")
 	}
 	if strings.HasSuffix(raw, "-00:00") {
-		return "", fmt.Errorf("Datetime can't use '-00:00' for UTC timezone, must use '+00:00', per ISO-8601")
+		return "", errors.New("Datetime can't use '-00:00' for UTC timezone, must use '+00:00', per ISO-8601")
 	}
 	// ensure that the datetime actually parses using golang time lib
 	_, err := time.Parse(time.RFC3339Nano, raw)

atproto/syntax/did.go

···
 package syntax
 
 import (
-	"fmt"
+	"errors"
 	"regexp"
 	"strings"
 )
···
 
 func ParseDID(raw string) (DID, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected DID, got empty string")
+		return "", errors.New("expected DID, got empty string")
 	}
 	if len(raw) > 2*1024 {
-		return "", fmt.Errorf("DID is too long (2048 chars max)")
+		return "", errors.New("DID is too long (2048 chars max)")
 	}
 	if !didRegex.MatchString(raw) {
-		return "", fmt.Errorf("DID syntax didn't validate via regex")
+		return "", errors.New("DID syntax didn't validate via regex")
 	}
 	return DID(raw), nil
 }

atproto/syntax/handle.go

···
 package syntax
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"strings"
···
 
 func ParseHandle(raw string) (Handle, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected handle, got empty string")
+		return "", errors.New("expected handle, got empty string")
 	}
 	if len(raw) > 253 {
-		return "", fmt.Errorf("handle is too long (253 chars max)")
+		return "", errors.New("handle is too long (253 chars max)")
 	}
 	if !handleRegex.MatchString(raw) {
 		return "", fmt.Errorf("handle syntax didn't validate via regex: %s", raw)

atproto/syntax/language.go

···
 package syntax
 
 import (
-	"fmt"
+	"errors"
 	"regexp"
 )
 
···
 
 func ParseLanguage(raw string) (Language, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected language code, got empty string")
+		return "", errors.New("expected language code, got empty string")
 	}
 	if len(raw) > 128 {
-		return "", fmt.Errorf("Language is too long (128 chars max)")
+		return "", errors.New("Language is too long (128 chars max)")
 	}
 	if !langRegex.MatchString(raw) {
-		return "", fmt.Errorf("Language syntax didn't validate via regex")
+		return "", errors.New("Language syntax didn't validate via regex")
 	}
 	return Language(raw), nil
 }

atproto/syntax/nsid.go

···
 package syntax
 
 import (
-	"fmt"
+	"errors"
 	"regexp"
 	"strings"
 )
···
 
 func ParseNSID(raw string) (NSID, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected NSID, got empty string")
+		return "", errors.New("expected NSID, got empty string")
 	}
 	if len(raw) > 317 {
-		return "", fmt.Errorf("NSID is too long (317 chars max)")
+		return "", errors.New("NSID is too long (317 chars max)")
 	}
 	if !nsidRegex.MatchString(raw) {
-		return "", fmt.Errorf("NSID syntax didn't validate via regex")
+		return "", errors.New("NSID syntax didn't validate via regex")
 	}
 	return NSID(raw), nil
 }

atproto/syntax/recordkey.go

···
 package syntax
 
 import (
-	"fmt"
+	"errors"
 	"regexp"
 )
 
···
 
 func ParseRecordKey(raw string) (RecordKey, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected record key, got empty string")
+		return "", errors.New("expected record key, got empty string")
 	}
 	if len(raw) > 512 {
-		return "", fmt.Errorf("recordkey is too long (512 chars max)")
+		return "", errors.New("recordkey is too long (512 chars max)")
 	}
 	if raw == "" || raw == "." || raw == ".." {
-		return "", fmt.Errorf("recordkey can not be empty, '.', or '..'")
+		return "", errors.New("recordkey can not be empty, '.', or '..'")
 	}
 	if !recordKeyRegex.MatchString(raw) {
-		return "", fmt.Errorf("recordkey syntax didn't validate via regex")
+		return "", errors.New("recordkey syntax didn't validate via regex")
 	}
 	return RecordKey(raw), nil
 }

atproto/syntax/tid.go

···
 
 import (
 	"encoding/base32"
-	"fmt"
+	"errors"
 	"regexp"
 	"strings"
 	"sync"
···
 
 func ParseTID(raw string) (TID, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected TID, got empty string")
+		return "", errors.New("expected TID, got empty string")
 	}
 	if len(raw) != 13 {
-		return "", fmt.Errorf("TID is wrong length (expected 13 chars)")
+		return "", errors.New("TID is wrong length (expected 13 chars)")
 	}
 	if !tidRegex.MatchString(raw) {
-		return "", fmt.Errorf("TID syntax didn't validate via regex")
+		return "", errors.New("TID syntax didn't validate via regex")
 	}
 	return TID(raw), nil
 }

atproto/syntax/uri.go

···
 package syntax
 
 import (
-	"fmt"
+	"errors"
 	"regexp"
 )
 
···
 
 func ParseURI(raw string) (URI, error) {
 	if raw == "" {
-		return "", fmt.Errorf("expected URI, got empty string")
+		return "", errors.New("expected URI, got empty string")
 	}
 	if len(raw) > 8192 {
-		return "", fmt.Errorf("URI is too long (8192 chars max)")
+		return "", errors.New("URI is too long (8192 chars max)")
 	}
 	var uriRegex = regexp.MustCompile(`^[a-z][a-z.-]{0,80}:[[:graph:]]+$`)
 	if !uriRegex.MatchString(raw) {
-		return "", fmt.Errorf("URI syntax didn't validate via regex")
+		return "", errors.New("URI syntax didn't validate via regex")
 	}
 	return URI(raw), nil
 }