feat: process values.yaml files

internal/adapter/yamlls/diagnostics.go

@@ -7,13 +7,14 @@ import (
 	"strings"
 
 	lsplocal "github.com/mrjosh/helm-ls/internal/lsp"
+	templateast "github.com/mrjosh/helm-ls/internal/lsp/template_ast"
 	sitter "github.com/smacker/go-tree-sitter"
 	"go.lsp.dev/protocol"
 	lsp "go.lsp.dev/protocol"
 )
 
 func (c Connector) PublishDiagnostics(ctx context.Context, params *protocol.PublishDiagnosticsParams) (err error) {
-	doc, ok := c.documents.Get(params.URI)
+	doc, ok := c.documents.GetTemplateDoc(params.URI)
 	if !ok {
 		logger.Println("Error handling diagnostic. Could not get document: " + params.URI.Filename())
 		return fmt.Errorf("Could not get document: %s", params.URI.Filename())
@@ -32,16 +33,16 @@ func (c Connector) PublishDiagnostics(ctx context.Context, params *protocol.Publ
 	return nil
 }
 
-func filterDiagnostics(diagnostics []lsp.Diagnostic, ast *sitter.Tree, content string) (filtered []lsp.Diagnostic) {
+func filterDiagnostics(diagnostics []lsp.Diagnostic, ast *sitter.Tree, content []byte) (filtered []lsp.Diagnostic) {
 	filtered = []lsp.Diagnostic{}
 
 	for _, diagnostic := range diagnostics {
-		node := lsplocal.NodeAtPosition(ast, diagnostic.Range.Start)
-		childNode := lsplocal.FindRelevantChildNode(ast.RootNode(), lsplocal.GetSitterPointForLspPos(diagnostic.Range.Start))
+		node := templateast.NodeAtPosition(ast, diagnostic.Range.Start)
+		childNode := templateast.FindRelevantChildNode(ast.RootNode(), templateast.GetSitterPointForLspPos(diagnostic.Range.Start))
 
 		if node.Type() == "text" && childNode.Type() == "text" {
 			logger.Debug("Diagnostic", diagnostic)
-			logger.Debug("Node", node.Content([]byte(content)))
+			logger.Debug("Node", node.Content(content))
 
 			if diagnisticIsRelevant(diagnostic, childNode) {
 				diagnostic.Message = "Yamlls: " + diagnostic.Message

internal/adapter/yamlls/diagnostics_integration_test.go

@@ -11,7 +11,7 @@ import (
 	"testing"
 	"time"
 
-	lsplocal "github.com/mrjosh/helm-ls/internal/lsp"
+	"github.com/mrjosh/helm-ls/internal/lsp/document"
 	"github.com/mrjosh/helm-ls/internal/util"
 	"github.com/stretchr/testify/assert"
 	"go.lsp.dev/protocol"
@@ -44,7 +44,7 @@ func readTestFiles(dir string, channel chan<- string, doneChan chan<- int) {
 	doneChan <- count
 }
 
-func sendTestFilesToYamlls(documents *lsplocal.DocumentStore, yamllsConnector *Connector,
+func sendTestFilesToYamlls(documents *document.DocumentStore, yamllsConnector *Connector,
 	doneReadingFilesChan <-chan int,
 	doneSendingFilesChan chan<- int,
 	filesChan <-chan string,

internal/adapter/yamlls/document_sync.go

@@ -4,12 +4,13 @@ import (
 	"context"
 
 	lsplocal "github.com/mrjosh/helm-ls/internal/lsp"
+	"github.com/mrjosh/helm-ls/internal/lsp/document"
 	"github.com/mrjosh/helm-ls/internal/util"
 	sitter "github.com/smacker/go-tree-sitter"
 	lsp "go.lsp.dev/protocol"
 )
 
-func (yamllsConnector Connector) InitiallySyncOpenDocuments(docs []*lsplocal.Document) {
+func (yamllsConnector Connector) InitiallySyncOpenDocuments(docs []*document.TemplateDocument) {
 	if yamllsConnector.server == nil {
 		return
 	}
@@ -19,15 +20,16 @@ func (yamllsConnector Connector) InitiallySyncOpenDocuments(docs []*lsplocal.Doc
 			continue
 		}
 
-		doc.IsYaml = lsplocal.IsYamlDocument(doc.URI, yamllsConnector.config)
+		doc.IsYaml = yamllsConnector.IsYamllsEnabled(doc.URI)
+
 		if !yamllsConnector.isRelevantFile(doc.URI) {
 			continue
 		}
 
 		yamllsConnector.DocumentDidOpen(doc.Ast, lsp.DidOpenTextDocumentParams{
 			TextDocument: lsp.TextDocumentItem{
 				URI:  doc.URI,
-				Text: doc.Content,
+				Text: string(doc.Content),
 			},
 		})
 	}
@@ -39,15 +41,15 @@ func (yamllsConnector Connector) DocumentDidOpen(ast *sitter.Tree, params lsp.Di
 	if !yamllsConnector.shouldRun(params.TextDocument.URI) {
 		return
 	}
-	params.TextDocument.Text = lsplocal.TrimTemplate(ast, params.TextDocument.Text)
+	params.TextDocument.Text = lsplocal.TrimTemplate(ast, []byte(params.TextDocument.Text))
 
 	err := yamllsConnector.server.DidOpen(context.Background(), &params)
 	if err != nil {
 		logger.Error("Error calling yamlls for didOpen", err)
 	}
 }
 
-func (yamllsConnector Connector) DocumentDidSave(doc *lsplocal.Document, params lsp.DidSaveTextDocumentParams) {
+func (yamllsConnector Connector) DocumentDidSave(doc *document.TemplateDocument, params lsp.DidSaveTextDocumentParams) {
 	if !yamllsConnector.shouldRun(doc.URI) {
 		return
 	}
@@ -66,7 +68,7 @@ func (yamllsConnector Connector) DocumentDidSave(doc *lsplocal.Document, params
 	})
 }
 
-func (yamllsConnector Connector) DocumentDidChange(doc *lsplocal.Document, params lsp.DidChangeTextDocumentParams) {
+func (yamllsConnector Connector) DocumentDidChange(doc *document.TemplateDocument, params lsp.DidChangeTextDocumentParams) {
 	if !yamllsConnector.shouldRun(doc.URI) {
 		return
 	}
@@ -95,12 +97,12 @@ func (yamllsConnector Connector) DocumentDidChange(doc *lsplocal.Document, param
 	}
 }
 
-func (yamllsConnector Connector) DocumentDidChangeFullSync(doc *lsplocal.Document, params lsp.DidChangeTextDocumentParams) {
+func (yamllsConnector Connector) DocumentDidChangeFullSync(doc *document.TemplateDocument, params lsp.DidChangeTextDocumentParams) {
 	if !yamllsConnector.shouldRun(doc.URI) {
 		return
 	}
 
-	logger.Debug("Sending DocumentDidChange with full sync, current content:", doc.Content)
+	logger.Debug("Sending DocumentDidChange with full sync, current content:", string(doc.Content))
 	trimmedText := lsplocal.TrimTemplate(doc.Ast.Copy(), doc.Content)
 
 	params.ContentChanges = []lsp.TextDocumentContentChangeEvent{
@@ -115,3 +117,7 @@ func (yamllsConnector Connector) DocumentDidChangeFullSync(doc *lsplocal.Documen
 		logger.Println("Error calling yamlls for didChange", err)
 	}
 }
+
+func (yamllsConnector Connector) IsYamllsEnabled(uri lsp.URI) bool {
+	return yamllsConnector.EnabledForFilesGlobObject.Match(uri.Filename())
+}

internal/adapter/yamlls/hover.go

@@ -53,6 +53,8 @@ func (yamllsConnector Connector) getHoverFromCompletion(ctx context.Context, par
 		}
 	}
 
+	logger.Debug("Got completion for hover from yamlls", completionList)
+
 	return protocol.BuildHoverResponse(documentation, resultRange), nil
 }
 

internal/adapter/yamlls/integration_test_utils.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 	"testing"
 
-	lsplocal "github.com/mrjosh/helm-ls/internal/lsp"
+	"github.com/mrjosh/helm-ls/internal/lsp/document"
 	"github.com/mrjosh/helm-ls/internal/util"
 	"go.lsp.dev/jsonrpc2"
 	"go.lsp.dev/protocol"
@@ -47,9 +47,9 @@ func (proc readWriteCloseMock) Close() error {
 	return nil
 }
 
-func getYamlLsConnector(t *testing.T, config util.YamllsConfiguration) (*Connector, *lsplocal.DocumentStore, chan lsp.PublishDiagnosticsParams) {
+func getYamlLsConnector(t *testing.T, config util.YamllsConfiguration) (*Connector, *document.DocumentStore, chan lsp.PublishDiagnosticsParams) {
 	dir := t.TempDir()
-	documents := lsplocal.NewDocumentStore()
+	documents := document.NewDocumentStore()
 	diagnosticsChan := make(chan lsp.PublishDiagnosticsParams)
 	con := jsonrpc2.NewConn(jsonrpc2.NewStream(readWriteCloseMock{diagnosticsChan}))
 	zapLogger, _ := zap.NewProduction()
@@ -66,7 +66,7 @@ func getYamlLsConnector(t *testing.T, config util.YamllsConfiguration) (*Connect
 	return yamllsConnector, documents, diagnosticsChan
 }
 
-func openFile(t *testing.T, documents *lsplocal.DocumentStore, path string, yamllsConnector *Connector) {
+func openFile(t *testing.T, documents *document.DocumentStore, path string, yamllsConnector *Connector) {
 	fileURI := uri.File(path)
 
 	content, err := os.ReadFile(path)
@@ -81,6 +81,6 @@ func openFile(t *testing.T, documents *lsplocal.DocumentStore, path string, yaml
 			Text:       string(content),
 		},
 	}
-	doc, err := documents.DidOpen(&d, util.DefaultConfig)
+	doc, err := documents.DidOpenTemplateDocument(&d, util.DefaultConfig)
 	yamllsConnector.DocumentDidOpen(doc.Ast, d)
 }

internal/adapter/yamlls/yamlls.go

@@ -6,8 +6,9 @@
 	"os"
 	"os/exec"
 
+	"github.com/gobwas/glob"
 	"github.com/mrjosh/helm-ls/internal/log"
-	lsplocal "github.com/mrjosh/helm-ls/internal/lsp"
+	"github.com/mrjosh/helm-ls/internal/lsp/document"
 	"github.com/mrjosh/helm-ls/internal/util"
 	"go.lsp.dev/jsonrpc2"
 	"go.lsp.dev/protocol"
@@ -18,13 +19,14 @@
 var logger = log.GetLogger()
 
 type Connector struct {
-	config    util.YamllsConfiguration
-	server    protocol.Server
-	documents *lsplocal.DocumentStore
-	client    protocol.Client
+	config                    util.YamllsConfiguration
+	server                    protocol.Server
+	documents                 *document.DocumentStore
+	client                    protocol.Client
+	EnabledForFilesGlobObject glob.Glob
 }
 
-func NewConnector(ctx context.Context, yamllsConfiguration util.YamllsConfiguration, client protocol.Client, documents *lsplocal.DocumentStore) *Connector {
+func NewConnector(ctx context.Context, yamllsConfiguration util.YamllsConfiguration, client protocol.Client, documents *document.DocumentStore) *Connector {
 	yamllsCmd := exec.Command(yamllsConfiguration.Path, "--stdio")
 
 	stdin, err := yamllsCmd.StdinPipe()
@@ -65,7 +67,7 @@
 	}
 
 	go func() {
 		io.Copy(os.Stderr, strderr)
 	}()
 
 	yamllsConnector := Connector{
@@ -82,7 +84,7 @@
 }
 
 func (yamllsConnector *Connector) isRelevantFile(uri lsp.URI) bool {
-	doc, ok := yamllsConnector.documents.Get(uri)
+	doc, ok := yamllsConnector.documents.GetTemplateDoc(uri)
 	if !ok {
 		logger.Error("Could not find document", uri)
 		return true

internal/adapter/yamlls/yamlls_test.go

@@ -4,7 +4,7 @@ import (
 	"os"
 	"testing"
 
-	lsplocal "github.com/mrjosh/helm-ls/internal/lsp"
+	"github.com/mrjosh/helm-ls/internal/lsp/document"
 	"github.com/mrjosh/helm-ls/internal/util"
 	"github.com/stretchr/testify/assert"
 	"go.lsp.dev/uri"
@@ -17,7 +17,7 @@ func TestIsRelevantFile(t *testing.T) {
 		},
 	}
 
-	connector.documents = &lsplocal.DocumentStore{}
+	connector.documents = document.NewDocumentStore()
 	yamlFile := "../../../testdata/example/templates/deployment.yaml"
 	nonYamlFile := "../../../testdata/example/templates/_helpers.tpl"
 
@@ -27,8 +27,8 @@ func TestIsRelevantFile(t *testing.T) {
 	nonYamlFileContent, err := os.ReadFile(nonYamlFile)
 	assert.NoError(t, err)
 
-	connector.documents.Store(yamlFile, yamlFileContent, util.DefaultConfig)
-	connector.documents.Store(nonYamlFile, nonYamlFileContent, util.DefaultConfig)
+	connector.documents.StoreTemplateDocument(yamlFile, yamlFileContent, util.DefaultConfig)
+	connector.documents.StoreTemplateDocument(nonYamlFile, nonYamlFileContent, util.DefaultConfig)
 
 	assert.True(t, connector.isRelevantFile(uri.File(yamlFile)))
 	assert.False(t, connector.isRelevantFile(uri.File(nonYamlFile)))

internal/handler/completion.go

@@ -3,44 +3,15 @@ package handler
 import (
 	"context"
 
-	languagefeatures "github.com/mrjosh/helm-ls/internal/language_features"
-	lsplocal "github.com/mrjosh/helm-ls/internal/lsp"
-	"github.com/mrjosh/helm-ls/internal/protocol"
 	lsp "go.lsp.dev/protocol"
-
-	helmdocs "github.com/mrjosh/helm-ls/internal/documentation/helm"
 )
 
-func (h *langHandler) Completion(ctx context.Context, params *lsp.CompletionParams) (result *lsp.CompletionList, err error) {
+func (h *ServerHandler) Completion(ctx context.Context, params *lsp.CompletionParams) (result *lsp.CompletionList, err error) {
 	logger.Debug("Running completion with params", params)
 
-	genericDocumentUseCase, err := h.NewGenericDocumentUseCase(params.TextDocumentPositionParams, lsplocal.NestedNodeAtPositionForCompletion)
+	handler, err := h.selectLangHandler(ctx, params.TextDocument.URI)
 	if err != nil {
 		return nil, err
 	}
-
-	usecases := []languagefeatures.CompletionUseCase{
-		languagefeatures.NewTemplateContextFeature(genericDocumentUseCase),
-		languagefeatures.NewFunctionCallFeature(genericDocumentUseCase),
-		languagefeatures.NewTextFeature(ctx, genericDocumentUseCase, h.yamllsConnector, &params.TextDocumentPositionParams),
-		languagefeatures.NewIncludesCallFeature(genericDocumentUseCase),
-	}
-
-	for _, usecase := range usecases {
-		if usecase.AppropriateForNode() {
-			return usecase.Completion()
-		}
-	}
-
-	// If no usecase matched, we assume we are at {{ }}
-	// and provide the basic BuiltInObjects and functions
-	items := []helmdocs.HelmDocumentation{}
-	for _, v := range helmdocs.BuiltInObjects {
-		v.Name = "." + v.Name
-		items = append(items, v)
-	}
-
-	return protocol.CompletionResults{}.
-		WithDocs(items, lsp.CompletionItemKindConstant).
-		WithDocs(helmdocs.AllFuncs, lsp.CompletionItemKindFunction).ToList(), nil
+	return handler.Completion(ctx, params)
 }

internal/handler/configuration.go

@@ -10,13 +10,13 @@ import (
 	lsp "go.lsp.dev/protocol"
 )
 
-func (h *langHandler) DidChangeConfiguration(ctx context.Context, params *lsp.DidChangeConfigurationParams) (err error) {
+func (h *ServerHandler) DidChangeConfiguration(ctx context.Context, params *lsp.DidChangeConfigurationParams) (err error) {
 	// go h.retrieveWorkspaceConfiguration(ctx)
 	logger.Println("Changing workspace config is not implemented")
 	return nil
 }
 
-func (h *langHandler) retrieveWorkspaceConfiguration(ctx context.Context) {
+func (h *ServerHandler) retrieveWorkspaceConfiguration(ctx context.Context) {
 	logger.Debug("Calling workspace/configuration")
 	configurationParams := lsp.ConfigurationParams{
 		Items: []lsp.ConfigurationItem{{Section: "helm-ls"}},

internal/handler/configuration_test.go

@@ -15,11 +15,14 @@ import (
 	"go.lsp.dev/uri"
 )
 
-var configurationParams = lsp.ConfigurationParams{Items: []lsp.ConfigurationItem{{Section: "helm-ls"}}}
+var (
+	addChartCallback    = func(chart *charts.Chart) {}
+	configurationParams = lsp.ConfigurationParams{Items: []lsp.ConfigurationItem{{Section: "helm-ls"}}}
+)
 
 func TestConfigurationWorks(t *testing.T) {
 	mockClient := mocks.NewMockClient(t)
-	handler := &langHandler{
+	handler := &ServerHandler{
 		helmlsConfig: util.DefaultConfig,
 		chartStore:   charts.NewChartStore(uri.File("/"), charts.NewChart, addChartCallback),
 	}
@@ -41,7 +44,7 @@ func TestConfigurationWorks(t *testing.T) {
 
 func TestConfigurationWorksForEmptyConfig(t *testing.T) {
 	mockClient := mocks.NewMockClient(t)
-	handler := &langHandler{
+	handler := &ServerHandler{
 		helmlsConfig: util.DefaultConfig,
 		chartStore:   charts.NewChartStore(uri.File("/"), charts.NewChart, addChartCallback),
 	}
@@ -60,7 +63,7 @@ func TestConfigurationWorksForEmptyConfig(t *testing.T) {
 
 func TestConfigurationWorksForError(t *testing.T) {
 	mockClient := mocks.NewMockClient(t)
-	handler := &langHandler{
+	handler := &ServerHandler{
 		helmlsConfig: util.DefaultConfig,
 		chartStore:   charts.NewChartStore(uri.File("/"), charts.NewChart, addChartCallback),
 	}
@@ -82,7 +85,7 @@ func TestConfigurationWorksForError(t *testing.T) {
 
 func TestConfigurationWorksForJsonError(t *testing.T) {
 	mockClient := mocks.NewMockClient(t)
-	handler := &langHandler{
+	handler := &ServerHandler{
 		helmlsConfig: util.DefaultConfig,
 		chartStore:   charts.NewChartStore(uri.File("/"), charts.NewChart, addChartCallback),
 	}

internal/handler/definition.go

@@ -3,30 +3,15 @@ package handler
 import (
 	"context"
 
-	languagefeatures "github.com/mrjosh/helm-ls/internal/language_features"
-	lsplocal "github.com/mrjosh/helm-ls/internal/lsp"
 	lsp "go.lsp.dev/protocol"
 )
 
-func (h *langHandler) Definition(_ context.Context, params *lsp.DefinitionParams) (result []lsp.Location, err error) {
-	genericDocumentUseCase, err := h.NewGenericDocumentUseCase(params.TextDocumentPositionParams, lsplocal.NodeAtPosition)
+func (h *ServerHandler) Definition(ctx context.Context, params *lsp.DefinitionParams) (result []lsp.Location, err error) {
+	logger.Debug("Running Definition with params", params)
+
+	handler, err := h.selectLangHandler(ctx, params.TextDocument.URI)
 	if err != nil {
 		return nil, err
 	}
-
-	usecases := []languagefeatures.DefinitionUseCase{
-		languagefeatures.NewBuiltInObjectsFeature(genericDocumentUseCase), // has to be before template context
-		languagefeatures.NewVariablesFeature(genericDocumentUseCase),
-		languagefeatures.NewTemplateContextFeature(genericDocumentUseCase),
-		languagefeatures.NewIncludesCallFeature(genericDocumentUseCase),
-	}
-
-	for _, usecase := range usecases {
-		if usecase.AppropriateForNode() {
-			result, err := usecase.Definition()
-			return result, err
-		}
-	}
-
-	return nil, nil
+	return handler.Definition(ctx, params)
 }