syntax: polish

atproto/syntax/handle.go

···
 	"strings"
 )
 
+var handleRegex = regexp.MustCompile(`^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$`)
+
 // String type which represents a syntaxtually valid handle identifier, as would pass Lexicon syntax validation.
 //
 // Always use [ParseHandle] instead of wrapping strings directly, especially when working with input.
···
 	if len(raw) > 253 {
 		return "", fmt.Errorf("handle is too long (253 chars max)")
 	}
-	var handleRegex = regexp.MustCompile(`^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$`)
 	if !handleRegex.MatchString(raw) {
 		return "", fmt.Errorf("handle syntax didn't validate via regex")
 	}

atproto/syntax/handle_test.go

···
 		}
 		_, err := ParseHandle(line)
 		if err != nil {
-			fmt.Println("GOOD: " + line)
-		} else {
-			fmt.Println("BAD: " + line)
+			fmt.Println("FAILED, GOOD: " + line)
 		}
 		assert.NoError(err)
 	}
···
 		}
 		_, err := ParseHandle(line)
 		if err == nil {
-			fmt.Println("BAD: " + line)
+			fmt.Println("FAILED, BAD: " + line)
 		}
 		assert.Error(err)
 	}

atproto/syntax/nsid.go

···
 	"strings"
 )
 
+var nsidRegex = regexp.MustCompile(`^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z]{0,61}[a-zA-Z])?)$`)
+
 // String type which represents a syntaxtually valid Namespace Identifier (NSID), as would pass Lexicon syntax validation.
 //
 // Always use [ParseNSID] instead of wrapping strings directly, especially when working with input.
···
 	if len(raw) > 317 {
 		return "", fmt.Errorf("NSID is too long (317 chars max)")
 	}
-	var nsidRegex = regexp.MustCompile(`^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z]{0,61}[a-zA-Z])?)$`)
 	if !nsidRegex.MatchString(raw) {
 		return "", fmt.Errorf("NSID syntax didn't validate via regex")
 	}

atproto/syntax/nsid_test.go

···
 		}
 		_, err := ParseNSID(line)
 		if err != nil {
-			fmt.Println("GOOD: " + line)
+			fmt.Println("FAILED, GOOD: " + line)
 		}
 		assert.NoError(err)
 	}
···
 		}
 		_, err := ParseNSID(line)
 		if err == nil {
-			fmt.Println("BAD: " + line)
+			fmt.Println("FAILED, BAD: " + line)
 		}
 		assert.Error(err)
 	}

atproto/syntax/recordkey.go

···
 	"regexp"
 )
 
+var recordKeyRegex = regexp.MustCompile(`^[a-zA-Z0-9_~.-]{1,512}$`)
+
 // String type which represents a syntaxtually valid RecordKey identifier, as could be included in an AT URI
 //
 // Always use [ParseRecordKey] instead of wrapping strings directly, especially when working with input.
···
 type RecordKey string
 
 func ParseRecordKey(raw string) (RecordKey, error) {
-	if len(raw) > 253 {
+	if len(raw) > 512 {
 		return "", fmt.Errorf("recordkey is too long (512 chars max)")
 	}
 	if raw == "" || raw == "." || raw == ".." {
 		return "", fmt.Errorf("recordkey can not be empty, '.', or '..'")
 	}
-	var recordkeyRegex = regexp.MustCompile(`^[a-zA-Z0-9_~.-]{1,512}$`)
-	if !recordkeyRegex.MatchString(raw) {
+	if !recordKeyRegex.MatchString(raw) {
 		return "", fmt.Errorf("recordkey syntax didn't validate via regex")
 	}
 	return RecordKey(raw), nil
 }
 
-func (h RecordKey) String() string {
-	return string(h)
+func (r RecordKey) String() string {
+	return string(r)
 }

atproto/syntax/recordkey_test.go

···
 		}
 		_, err := ParseRecordKey(line)
 		if err != nil {
-			fmt.Println("GOOD: " + line)
-		} else {
-			fmt.Println("FAIL: " + line)
+			fmt.Println("FAILED, GOOD: " + line)
 		}
 		assert.NoError(err)
 	}
···
 		}
 		_, err := ParseRecordKey(line)
 		if err == nil {
-			fmt.Println("BAD: " + line)
+			fmt.Println("FAILED, BAD: " + line)
 		}
 		assert.Error(err)
 	}

atproto/syntax/testdata/handle_syntax_invalid.txt

···
 john.-est
 john.tes-
 
-# TODO: short/long examples
+# max over all handle: 'shoooort' + '.loooooooooooooooooooooooooong'.repeat(9) + '.test'
+shoooort.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.test
+
+# max segment: 'short.' + 'o'.repeat(64) + '.test'
+short.oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo.test
 
 # throws on "dotless" TLD handles
 org

atproto/syntax/testdata/handle_syntax_valid.txt

···
 jaymome-johnber123456.test
 jay.mome-johnber123456.test
 john.test.bsky.app
-# TODO: short and long
+
+# max over all handle: 'shoooort' + '.loooooooooooooooooooooooooong'.repeat(8) + '.test'
+shoooort.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.loooooooooooooooooooooooooong.test
+
+# max segment: 'short.' + 'o'.repeat(63) + '.test'
+short.ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo.test
 
 # NOTE: this probably isn't ever going to be a real domain, but my read of the RFC is that it would be possible
 john.t

atproto/syntax/testdata/recordkey_syntax_valid.txt

···
 example.com
 ~1.2-3_
 dHJ1ZQ
+
+# very long: 'o'.repeat(512)
+oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo