make the codes smaller

Author: collapsinghierarchy

internal/rendezvous/codes.go

@@ -22,12 +22,15 @@ type CodeEntry struct {
 }
 
 type Store struct {
-	mu        sync.RWMutex
-	codes     map[string]*CodeEntry // code -> entry
-	appToCode map[string]string     // appID -> code
-	pregen    chan string           // optional pregen pool
-	ttl       time.Duration
-	words     []string
+	mu           sync.RWMutex
+	codes        map[string]*CodeEntry // code -> entry
+	appToCode    map[string]string     // appID -> code
+	pregen       chan string           // optional pregen pool
+	ttl          time.Duration
+	words        []string
+	perm         []int // permutation of [0..len(words)-1], set once
+	singleIdx    int   // rotating cursor for single-word picks
+	pairA, pairB int   // rotating cursors for two-word pairs
 }
 
 func NewStore(words []string, ttl time.Duration, pregenCap int) *Store {
@@ -40,6 +43,19 @@ func NewStore(words []string, ttl time.Duration, pregenCap int) *Store {
 		ttl:       ttl,
 		words:     words,
 	}
+	if n := len(words); n > 0 {
+		s.perm = make([]int, n)
+		for i := 0; i < n; i++ {
+			s.perm[i] = i
+		}
+		// Fisher–Yates with crypto/rand
+		for i := n - 1; i > 0; i-- {
+			j, err := randInt(i + 1)
+			if err == nil && j != i {
+				s.perm[i], s.perm[j] = s.perm[j], s.perm[i]
+			}
+		}
+	}
 	if pregenCap > 0 {
 		s.pregen = make(chan string, pregenCap)
 		go s.pregenerator()
@@ -177,6 +193,84 @@ func (s *Store) newUniqueCode() (string, error) {
 }
 
 func (s *Store) generateCode() (string, error) {
+	// We need to see what's currently allocated, and advance our fair cursors.
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// 1) Try single-word pool.
+	if code, ok := s.pickSingleLocked(); ok {
+		return code, nil
+	}
+	// 2) All single words are currently allocated -> try two-word pool.
+	if code, ok := s.pickPairLocked(); ok {
+		return code, nil
+	}
+	// 3) Extremely unlikely to get here. Fall back to legacy generator (4 words + 4 digits).
+	return s.generateLegacyUnlocked()
+}
+
+// pickSingleLocked returns an unused single-word code if available.
+// Requires s.mu to be held (write lock) because it advances s.singleIdx.
+func (s *Store) pickSingleLocked() (string, bool) {
+	n := len(s.words)
+	if n == 0 {
+		return "", false
+	}
+	if len(s.perm) != n {
+		// Safety: build a basic permutation if not set (shouldn't happen).
+		s.perm = make([]int, n)
+		for i := range s.perm {
+			s.perm[i] = i
+		}
+	}
+	for tried := 0; tried < n; tried++ {
+		idx := s.perm[(s.singleIdx+tried)%n]
+		w := s.words[idx]
+		if _, inUse := s.codes[w]; !inUse {
+			// Reserve this candidate by advancing the cursor; actual insertion happens in CreateCode.
+			s.singleIdx = (s.singleIdx + tried + 1) % n
+			return w, true
+		}
+	}
+	return "", false
+}
+
+// pickPairLocked returns an unused two-word code "w1-w2" if available.
+// Requires s.mu to be held (write lock) because it advances s.pairA/B.
+func (s *Store) pickPairLocked() (string, bool) {
+	n := len(s.words)
+	if n == 0 {
+		return "", false
+	}
+	if len(s.perm) != n {
+		s.perm = make([]int, n)
+		for i := range s.perm {
+			s.perm[i] = i
+		}
+	}
+	// Scan n*n pairs in a rotating manner.
+	for scanned := 0; scanned < n*n; scanned++ {
+		a := s.words[s.perm[s.pairA]]
+		b := s.words[s.perm[s.pairB]]
+		code := a + "-" + b
+
+		// Move pairB then roll into pairA
+		s.pairB++
+		if s.pairB >= n {
+			s.pairB = 0
+			s.pairA = (s.pairA + 1) % n
+		}
+
+		if _, inUse := s.codes[code]; !inUse {
+			return code, true
+		}
+	}
+	return "", false
+}
+
+// generateLegacyUnlocked reproduces the old style code (4 words + 4 digits).
+// Requires s.mu to be held (write lock) only because we share randInt; it doesn't mutate s.
+func (s *Store) generateLegacyUnlocked() (string, error) {
 	const wordsPerCode = 4
 	if len(s.words) < 2 {
 		return "", errors.New("wordlist too small")
@@ -194,7 +288,7 @@ func (s *Store) generateCode() (string, error) {
 		return "", err
 	}
 	parts = append(parts, fmt.Sprintf("%04d", d))
-	return strings.Join(parts, "-"), nil
+	return strings.ToLower(strings.Join(parts, "-")), nil
 }
 
 func randInt(n int) (int, error) {

internal/rendezvous/codes_smart_test.go

@@ -0,0 +1,47 @@
+package rendezvous
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func Test_SingleThenPairs(t *testing.T) {
+	words := []string{"alpha", "bravo", "charlie"}
+	s := NewStore(words, 5*time.Minute, 0)
+
+	seen := map[string]bool{}
+	var singles int
+
+	// Allocate more than len(words) to force pairs.
+	for i := 0; i < len(words)+2; i++ {
+		code, appID, _, err := s.CreateCode(context.Background())
+		if err != nil {
+			t.Fatalf("create: %v", err)
+		}
+		if seen[code] {
+			t.Fatalf("duplicate code: %s", code)
+		}
+		seen[code] = true
+		if appID == "" {
+			t.Fatalf("missing appID")
+		}
+		if countHyphens(code) == 0 {
+			singles++
+		}
+	}
+
+	if singles != len(words) {
+		t.Fatalf("expected %d singles first, got %d", len(words), singles)
+	}
+}
+
+func countHyphens(s string) int {
+	n := 0
+	for _, r := range s {
+		if r == '-' {
+			n++
+		}
+	}
+	return n
+}