Naming, layout and comments: descriptive full-word names, one item per line in wrapped calls and literals, and doc comments on exported names

Short and single-letter names in application code become full words (tests
keep theirs). Wrapped calls, signatures and composite literals put one item
per line, and one-line function bodies are expanded. Exported names and
groups of constants get doc comments, and comments refer to the renamed
identifiers.

internal/websocket/client.go

@@ -55,18 +55,18 @@ var errUnsupportedData = errors.New("binary frames are not supported")
 // runs with; the client calls it when it finishes or is closed. The client's
 // messages are limited by websocket.message_rate_limit if it is enabled.
 func newClient(
-	h *Hub, conn msgConn, ip string, cancel context.CancelFunc,
+	hub *Hub, conn msgConn, ip string, cancel context.CancelFunc,
 ) *client {
 	limiter := rate.NewLimiter(rate.Inf, 0)
-	if rule := h.conf.MessageRateLimit; rule.Enabled && rule.PerSecond > 0 {
+	if rule := hub.conf.MessageRateLimit; rule.Enabled && rule.PerSecond > 0 {
 		limiter = rate.NewLimiter(
 			rate.Limit(rule.PerSecond),
 			max(rule.Burst, 1),
 		)
 	}
 
-	c := &client{
-		hub:     h,
+	client := &client{
+		hub:     hub,
 		conn:    conn,
 		id:      rand.Text()[:12],
 		ip:      ip,
@@ -74,9 +74,9 @@ func newClient(
 		cancel:  cancel,
 		limiter: limiter,
 	}
-	c.lastSeen.Store(time.Now().UnixNano())
+	client.lastSeen.Store(time.Now().UnixNano())
 
-	return c
+	return client
 }
 
 // run starts the writer and keepalive goroutines and reads until the
@@ -84,8 +84,14 @@ func newClient(
 func (c *client) run(ctx context.Context) {
 	var wg sync.WaitGroup
 	wg.Add(2)
-	go func() { defer wg.Done(); c.writeLoop(ctx) }()
-	go func() { defer wg.Done(); c.pingLoop(ctx) }()
+	go func() {
+		defer wg.Done()
+		c.writeLoop(ctx)
+	}()
+	go func() {
+		defer wg.Done()
+		c.pingLoop(ctx)
+	}()
 
 	c.sendEnvelope(Envelope{
 		Type: TypeWelcome,
@@ -134,35 +140,35 @@ func (c *client) readLoop(ctx context.Context) error {
 			continue
 		}
 		// Unpack the envelope and pass to handle to process if valid
-		var env Envelope
-		if err := json.Unmarshal(data, &env); err != nil {
+		var envelope Envelope
+		if err := json.Unmarshal(data, &envelope); err != nil {
 			c.sendError("", "invalid JSON envelope")
 			continue
 		}
-		c.handle(env)
+		c.handle(envelope)
 	}
 }
 
 // handle answers one envelope from the client: ping and echo, or an error
 // for any other type.
-func (c *client) handle(env Envelope) {
-	switch env.Type {
+func (c *client) handle(envelope Envelope) {
+	switch envelope.Type {
 	case TypePing:
 		c.sendEnvelope(Envelope{
 			Type:    TypePong,
-			ID:      env.ID,
+			ID:      envelope.ID,
 			Payload: mustRaw(map[string]any{"time": time.Now().UTC()}),
 		})
 
 	case TypeEcho:
 		c.sendEnvelope(Envelope{
 			Type:    TypeEcho,
-			ID:      env.ID,
-			Payload: env.Payload,
+			ID:      envelope.ID,
+			Payload: envelope.Payload,
 		})
 
 	default:
-		c.sendError(env.ID, "unknown message type")
+		c.sendError(envelope.ID, "unknown message type")
 	}
 }
 
@@ -235,10 +241,10 @@ func (c *client) trySend(msg []byte) bool {
 	}
 }
 
-// sendEnvelope queues env for the client, closing the client as a slow
+// sendEnvelope queues envelope for the client, closing the client as a slow
 // consumer if its queue is full.
-func (c *client) sendEnvelope(env Envelope) {
-	encoded, err := json.Marshal(env)
+func (c *client) sendEnvelope(envelope Envelope) {
+	encoded, err := json.Marshal(envelope)
 	if err != nil {
 		c.hub.logger().Error("marshal", "client", c.id, "error", err)
 		return
@@ -298,7 +304,8 @@ func withTimeout(
 	ctx context.Context, timeout time.Duration,
 ) (context.Context, context.CancelFunc) {
 	if timeout <= 0 {
-		return ctx, func() {}
+		return ctx, func() {
+		}
 	}
 	return context.WithTimeout(ctx, timeout)
 }