Debounde index updates

Author: kindermax

internal/lsp/debounce.go

@@ -0,0 +1,62 @@
+package lsp
+
+import (
+	"sync"
+	"time"
+)
+
+type documentDebouncer struct {
+	delay   time.Duration
+	refresh func(string)
+
+	mu     sync.Mutex
+	timers map[string]*time.Timer
+}
+
+func newDocumentDebouncer(delay time.Duration, refresh func(string)) *documentDebouncer {
+	return &documentDebouncer{
+		delay:   delay,
+		refresh: refresh,
+		timers:  make(map[string]*time.Timer),
+	}
+}
+
+func (d *documentDebouncer) Schedule(uri string) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if timer, ok := d.timers[uri]; ok {
+		timer.Stop()
+	}
+
+	var timer *time.Timer
+	timer = time.AfterFunc(d.delay, func() {
+		d.fire(uri, timer)
+	})
+
+	d.timers[uri] = timer
+}
+
+func (d *documentDebouncer) Stop() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	for uri, timer := range d.timers {
+		timer.Stop()
+		delete(d.timers, uri)
+	}
+}
+
+func (d *documentDebouncer) fire(uri string, timer *time.Timer) {
+	d.mu.Lock()
+	current, ok := d.timers[uri]
+	if !ok || current != timer {
+		d.mu.Unlock()
+		return
+	}
+
+	delete(d.timers, uri)
+	d.mu.Unlock()
+
+	d.refresh(uri)
+}

internal/lsp/debounce_test.go

@@ -0,0 +1,91 @@
+package lsp
+
+import (
+	"testing"
+	"time"
+
+	"github.com/tliron/glsp"
+	lsp "github.com/tliron/glsp/protocol_3_16"
+)
+
+func TestDocumentDebouncerCoalescesRepeatedSchedules(t *testing.T) {
+	events := make(chan string, 2)
+	debouncer := newDocumentDebouncer(20*time.Millisecond, func(uri string) {
+		events <- uri
+	})
+	defer debouncer.Stop()
+
+	debouncer.Schedule("file:///tmp/lets.yaml")
+	debouncer.Schedule("file:///tmp/lets.yaml")
+
+	select {
+	case got := <-events:
+		if got != "file:///tmp/lets.yaml" {
+			t.Fatalf("refresh uri = %q, want %q", got, "file:///tmp/lets.yaml")
+		}
+	case <-time.After(200 * time.Millisecond):
+		t.Fatal("timed out waiting for debounced refresh")
+	}
+
+	select {
+	case got := <-events:
+		t.Fatalf("unexpected extra refresh for %q", got)
+	case <-time.After(60 * time.Millisecond):
+	}
+}
+
+func TestTextDocumentDidChangeUsesLatestDocumentAfterDebounce(t *testing.T) {
+	server := &lspServer{
+		storage: newStorage(),
+		parser:  newParser(logger),
+		index:   newIndex(logger),
+		log:     logger,
+	}
+	server.refresh = newDocumentDebouncer(20*time.Millisecond, server.refreshDocument)
+	defer server.refresh.Stop()
+
+	params := &lsp.DidChangeTextDocumentParams{
+		TextDocument: lsp.VersionedTextDocumentIdentifier{
+			TextDocumentIdentifier: lsp.TextDocumentIdentifier{URI: "file:///tmp/lets.yaml"},
+		},
+	}
+
+	params.ContentChanges = []any{
+		lsp.TextDocumentContentChangeEventWhole{
+			Text: `commands:
+  build:
+    cmd: echo build`,
+		},
+	}
+
+	if err := server.textDocumentDidChange(&glsp.Context{}, params); err != nil {
+		t.Fatalf("first textDocumentDidChange() error = %v", err)
+	}
+
+	params.ContentChanges = []any{
+		lsp.TextDocumentContentChangeEventWhole{
+			Text: `commands:
+  release:
+    cmd: echo release`,
+		},
+	}
+
+	if err := server.textDocumentDidChange(&glsp.Context{}, params); err != nil {
+		t.Fatalf("second textDocumentDidChange() error = %v", err)
+	}
+
+	deadline := time.Now().Add(300 * time.Millisecond)
+	for time.Now().Before(deadline) {
+		if _, ok := server.index.findCommand("release"); ok {
+			if _, ok := server.index.findCommand("build"); ok {
+				t.Fatal("expected stale command to be removed after debounced refresh")
+			}
+
+			return
+		}
+
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	t.Fatal("timed out waiting for debounced document refresh")
+}

internal/lsp/handlers.go

@@ -35,6 +35,10 @@ func (s *lspServer) initialized(context *glsp.Context, params *lsp.InitializedPa
 }
 
 func (s *lspServer) shutdown(context *glsp.Context) error {
+	if s.refresh != nil {
+		s.refresh.Stop()
+	}
+
 	lsp.SetTraceValue(lsp.TraceValueOff)
 	return nil
 }
@@ -74,11 +78,20 @@ func (s *lspServer) loadMixins(uri string) {
 	}
 }
 
+func (s *lspServer) refreshDocument(uri string) {
+	doc := s.storage.GetDocument(uri)
+	if doc == nil {
+		return
+	}
+
+	s.index.IndexDocument(uri, *doc)
+	s.loadMixins(uri)
+}
+
 func (s *lspServer) textDocumentDidOpen(context *glsp.Context, params *lsp.DidOpenTextDocumentParams) error {
 	s.storage.AddDocument(params.TextDocument.URI, params.TextDocument.Text)
 
-	go s.index.IndexDocument(params.TextDocument.URI, params.TextDocument.Text)
-	go s.loadMixins(params.TextDocument.URI)
+	go s.refreshDocument(params.TextDocument.URI)
 
 	return nil
 }
@@ -88,9 +101,11 @@ func (s *lspServer) textDocumentDidChange(context *glsp.Context, params *lsp.Did
 		switch c := change.(type) {
 		case lsp.TextDocumentContentChangeEventWhole:
 			s.storage.AddDocument(params.TextDocument.URI, c.Text)
-
-			go s.index.IndexDocument(params.TextDocument.URI, c.Text)
-			go s.loadMixins(params.TextDocument.URI)
+			if s.refresh != nil {
+				s.refresh.Schedule(params.TextDocument.URI)
+			} else {
+				go s.refreshDocument(params.TextDocument.URI)
+			}
 		case lsp.TextDocumentContentChangeEvent:
 			return errors.New("incremental changes not supported")
 		}

internal/lsp/server.go

@@ -2,6 +2,7 @@ package lsp
 
 import (
 	"context"
+	"time"
 
 	"github.com/lets-cli/lets/internal/env"
 	"github.com/tliron/commonlog"
@@ -11,6 +12,7 @@ import (
 )
 
 const lsName = "lets_ls"
+const documentRefreshDebounce = 200 * time.Millisecond
 
 var handler lsp.Handler
 
@@ -20,6 +22,7 @@ type lspServer struct {
 	storage *storage
 	parser  *parser
 	index   *index
+	refresh *documentDebouncer
 	log     commonlog.Logger
 }
 
@@ -60,6 +63,7 @@ func Run(ctx context.Context, version string) error {
 		index:   newIndex(logger),
 		log:     logger,
 	}
+	lspServer.refresh = newDocumentDebouncer(documentRefreshDebounce, lspServer.refreshDocument)
 
 	handler.Initialize = lspServer.initialize
 	handler.Initialized = lspServer.initialized