Merge pull request #146 from docker/highlight-all-references

Support highlighting for referenced networks, volumes, configs, and secrets

Author: rcjsuen

CHANGELOG.md

@@ -17,6 +17,7 @@ All notable changes to the Docker Language Server will be documented in this fil
   - textDocument/documentHighlight
     - support highlighting the short form `depends_on` syntax for services ([#70](https://github.com/docker/docker-language-server/issues/70))
     - support highlighting the long form `depends_on` syntax for services ([#71](https://github.com/docker/docker-language-server/issues/71))
+    - support highlighting referenced networks, volumes, configs, and secrets ([#145](https://github.com/docker/docker-language-server/issues/145))
 
 ### Fixed
 

README.md

@@ -16,6 +16,7 @@ The Docker Language Server relies on some features that are dependent on [Buildx
   - code completion
   - code navigation
   - document outline support
+  - highlight named references of services, networks, volumes, configs, and secrets
   - hover tooltips
   - open links to images
 - Bake files

internal/compose/documentHighlight.go

@@ -1,13 +1,15 @@
 package compose
 
 import (
+	"strings"
+
 	"github.com/docker/docker-language-server/internal/pkg/document"
 	"github.com/docker/docker-language-server/internal/tliron/glsp/protocol"
 	"github.com/goccy/go-yaml/ast"
 	"github.com/goccy/go-yaml/token"
 )
 
-func serviceReferences(node *ast.MappingValueNode, dependencyAttributeName string) []*token.Token {
+func serviceDependencyReferences(node *ast.MappingValueNode, dependencyAttributeName string, arrayOnly bool) []*token.Token {
 	if servicesNode, ok := node.Value.(*ast.MappingNode); ok {
 		tokens := []*token.Token{}
 		for _, serviceNode := range servicesNode.Values {
@@ -18,8 +20,52 @@ func serviceReferences(node *ast.MappingValueNode, dependencyAttributeName strin
 							for _, service := range sequenceNode.Values {
 								tokens = append(tokens, service.GetToken())
 							}
-						} else if dependentService, ok := attributeNode.Value.(*ast.StringNode); ok {
-							tokens = append(tokens, dependentService.GetToken())
+						} else if !arrayOnly {
+							if mappingNode, ok := attributeNode.Value.(*ast.MappingNode); ok {
+								for _, dependentService := range mappingNode.Values {
+									tokens = append(tokens, dependentService.Key.GetToken())
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		return tokens
+	}
+	return nil
+}
+
+func volumeToken(t *token.Token) *token.Token {
+	idx := strings.Index(t.Value, ":")
+	if idx != -1 {
+		return &token.Token{
+			Value:    t.Value[0:idx],
+			Position: t.Position,
+		}
+	}
+	return t
+}
+
+func volumeReferences(node *ast.MappingValueNode) []*token.Token {
+	if servicesNode, ok := node.Value.(*ast.MappingNode); ok {
+		tokens := []*token.Token{}
+		for _, serviceNode := range servicesNode.Values {
+			if serviceAttributes, ok := serviceNode.Value.(*ast.MappingNode); ok {
+				for _, attributeNode := range serviceAttributes.Values {
+					if attributeNode.Key.GetToken().Value == "volumes" {
+						if sequenceNode, ok := attributeNode.Value.(*ast.SequenceNode); ok {
+							for _, service := range sequenceNode.Values {
+								if volumeObjectNode, ok := service.(*ast.MappingNode); ok {
+									for _, volumeAttribute := range volumeObjectNode.Values {
+										if volumeAttribute.Key.GetToken().Value == "source" {
+											tokens = append(tokens, volumeAttribute.Value.GetToken())
+										}
+									}
+								} else {
+									tokens = append(tokens, volumeToken(service.GetToken()))
+								}
+							}
 						} else if mappingNode, ok := attributeNode.Value.(*ast.MappingNode); ok {
 							for _, dependentService := range mappingNode.Values {
 								tokens = append(tokens, dependentService.Key.GetToken())
@@ -56,51 +102,88 @@ func DocumentHighlight(doc document.ComposeDocument, position protocol.Position)
 	line := int(position.Line) + 1
 	character := int(position.Character) + 1
 	if mappingNode, ok := file.Docs[0].Body.(*ast.MappingNode); ok {
+		var networkRefs []*token.Token
+		var volumeRefs []*token.Token
+		var configRefs []*token.Token
+		var secretRefs []*token.Token
+		var networkDeclarations []*token.Token
+		var volumeDeclarations []*token.Token
+		var configDeclarations []*token.Token
+		var secretDeclarations []*token.Token
 		for _, node := range mappingNode.Values {
 			if s, ok := node.Key.(*ast.StringNode); ok {
 				switch s.Value {
 				case "services":
-					refs := serviceReferences(node, "depends_on")
+					refs := serviceDependencyReferences(node, "depends_on", false)
 					decls := declarations(node, "services")
-					highlights := highlightServiceReferences(refs, decls, line, character)
+					highlights := highlightReferences(refs, decls, line, character)
 					if len(highlights) > 0 {
 						return highlights, nil
 					}
+					networkRefs = serviceDependencyReferences(node, "networks", false)
+					configRefs = serviceDependencyReferences(node, "configs", true)
+					secretRefs = serviceDependencyReferences(node, "secrets", true)
+					volumeRefs = volumeReferences(node)
+				case "networks":
+					networkDeclarations = declarations(node, "networks")
+				case "volumes":
+					volumeDeclarations = declarations(node, "volumes")
+				case "configs":
+					configDeclarations = declarations(node, "configs")
+				case "secrets":
+					secretDeclarations = declarations(node, "secrets")
 				}
 			}
 		}
+		highlights := highlightReferences(networkRefs, networkDeclarations, line, character)
+		if len(highlights) > 0 {
+			return highlights, nil
+		}
+		highlights = highlightReferences(volumeRefs, volumeDeclarations, line, character)
+		if len(highlights) > 0 {
+			return highlights, nil
+		}
+		highlights = highlightReferences(configRefs, configDeclarations, line, character)
+		if len(highlights) > 0 {
+			return highlights, nil
+		}
+		highlights = highlightReferences(secretRefs, secretDeclarations, line, character)
+		if len(highlights) > 0 {
+			return highlights, nil
+		}
+		return highlights, nil
 	}
 	return nil, nil
 }
 
-func highlightServiceReferences(refs, decls []*token.Token, line, character int) []protocol.DocumentHighlight {
-	var match *token.Token
+func highlightReferences(refs, decls []*token.Token, line, character int) []protocol.DocumentHighlight {
+	var highlightedName *string
 	for _, reference := range refs {
 		if inToken(reference, line, character) {
-			match = reference
+			highlightedName = &reference.Value
 			break
 		}
 	}
 
-	if match == nil {
+	if highlightedName == nil {
 		for _, declaration := range decls {
 			if inToken(declaration, line, character) {
-				match = declaration
+				highlightedName = &declaration.Value
 				break
 			}
 		}
 	}
 
-	if match != nil {
+	if highlightedName != nil {
 		highlights := []protocol.DocumentHighlight{}
 		for _, reference := range refs {
-			if reference.Value == match.Value {
+			if reference.Value == *highlightedName {
 				highlights = append(highlights, documentHighlightFromToken(reference, protocol.DocumentHighlightKindRead))
 			}
 		}
 
 		for _, declaration := range decls {
-			if declaration.Value == match.Value {
+			if declaration.Value == *highlightedName {
 				highlights = append(highlights, documentHighlightFromToken(declaration, protocol.DocumentHighlightKindWrite))
 			}
 		}