feat: support for std.extVar variables (#37)

* config support inital pass

* feat: support for extVars via lsp runtime configuration

Author: entombedvirus

pkg/server/configuration.go

@@ -0,0 +1,56 @@
+package server
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/google/go-jsonnet"
+	"github.com/jdbaldry/go-language-server-protocol/jsonrpc2"
+	"github.com/jdbaldry/go-language-server-protocol/lsp/protocol"
+)
+
+func (s *server) DidChangeConfiguration(ctx context.Context, params *protocol.DidChangeConfigurationParams) error {
+	settingsMap, ok := params.Settings.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("%w: unsupported settings payload. expected json object, got: %T", jsonrpc2.ErrInvalidParams, params.Settings)
+	}
+
+	for sk, sv := range settingsMap {
+		switch sk {
+		case "ext_vars":
+			newVars, err := s.parseExtVars(sv)
+			if err != nil {
+				return fmt.Errorf("%w: ext_vars parsing failed: %v", jsonrpc2.ErrInvalidParams, err)
+			}
+			s.extVars = newVars
+
+		default:
+			return fmt.Errorf("%w: unsupported settings key: %q", jsonrpc2.ErrInvalidParams, sk)
+		}
+	}
+	return nil
+}
+
+func (s *server) parseExtVars(unparsed interface{}) (map[string]string, error) {
+	newVars, ok := unparsed.(map[string]interface{})
+	if !ok {
+		return nil, fmt.Errorf("unsupported settings value for ext_vars. expected json object. got: %T", unparsed)
+	}
+
+	extVars := make(map[string]string, len(newVars))
+	for varKey, varValue := range newVars {
+		vv, ok := varValue.(string)
+		if !ok {
+			return nil, fmt.Errorf("unsupported settings value for ext_vars.%s. expected string. got: %T", varKey, varValue)
+		}
+		extVars[varKey] = vv
+	}
+	return extVars, nil
+}
+
+func resetExtVars(vm *jsonnet.VM, vars map[string]string) {
+	vm.ExtReset()
+	for vk, vv := range vars {
+		vm.ExtVar(vk, vv)
+	}
+}

pkg/server/configuration_test.go

@@ -0,0 +1,119 @@
+package server
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/jdbaldry/go-language-server-protocol/lsp/protocol"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConfiguration(t *testing.T) {
+	type kase struct {
+		name        string
+		settings    interface{}
+		fileContent string
+
+		expectedErr        error
+		expectedFileOutput string
+	}
+
+	testCases := []kase{
+		{
+			name:        "settings is not an object",
+			settings:    []string{""},
+			fileContent: `[]`,
+			expectedErr: errors.New("JSON RPC invalid params: unsupported settings payload. expected json object, got: []string"),
+		},
+		{
+			name: "settings has unsupported key",
+			settings: map[string]interface{}{
+				"foo_bar": map[string]interface{}{},
+			},
+			fileContent: `[]`,
+			expectedErr: errors.New("JSON RPC invalid params: unsupported settings key: \"foo_bar\""),
+		},
+		{
+			name: "ext_var config is empty",
+			settings: map[string]interface{}{
+				"ext_vars": map[string]interface{}{},
+			},
+			fileContent:        `[]`,
+			expectedFileOutput: `[]`,
+		},
+		{
+			name:               "ext_var config is missing",
+			settings:           map[string]interface{}{},
+			fileContent:        `[]`,
+			expectedFileOutput: `[]`,
+		},
+		{
+			name: "ext_var config is not an object",
+			settings: map[string]interface{}{
+				"ext_vars": []string{},
+			},
+			fileContent: `[]`,
+			expectedErr: errors.New("JSON RPC invalid params: ext_vars parsing failed: unsupported settings value for ext_vars. expected json object. got: []string"),
+		},
+		{
+			name: "ext_var config value is not a string",
+			settings: map[string]interface{}{
+				"ext_vars": map[string]interface{}{
+					"foo": true,
+				},
+			},
+			fileContent: `[]`,
+			expectedErr: errors.New("JSON RPC invalid params: ext_vars parsing failed: unsupported settings value for ext_vars.foo. expected string. got: bool"),
+		},
+		{
+			name: "ext_var config is valid",
+			settings: map[string]interface{}{
+				"ext_vars": map[string]interface{}{
+					"hello": "world",
+				},
+			},
+			fileContent: `
+{
+	hello: std.extVar("hello"),
+}
+			`,
+			expectedFileOutput: `
+{
+	"hello": "world"
+}
+			`,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			s, fileURI := testServerWithFile(t, nil, tc.fileContent)
+
+			err := s.DidChangeConfiguration(
+				context.TODO(),
+				&protocol.DidChangeConfigurationParams{
+					Settings: tc.settings,
+				},
+			)
+			if tc.expectedErr == nil && err != nil {
+				t.Fatalf("DidChangeConfiguration produced unexpected error: %v", err)
+			} else if tc.expectedErr != nil && err == nil {
+				t.Fatalf("expected DidChangeConfiguration to produce error but it did not")
+			} else if tc.expectedErr != nil && err != nil {
+				assert.EqualError(t, err, tc.expectedErr.Error())
+				return
+			}
+
+			vm, err := s.getVM("any")
+			assert.NoError(t, err)
+
+			doc, err := s.cache.get(fileURI)
+			assert.NoError(t, err)
+
+			json, err := vm.Evaluate(doc.ast)
+			assert.NoError(t, err)
+			assert.JSONEq(t, tc.expectedFileOutput, json)
+		})
+	}
+}

pkg/server/server.go

@@ -49,10 +49,11 @@ func NewServer(name, version string, client protocol.ClientCloser) *server {
 type server struct {
 	name, version string
 
-	stdlib []stdlib.Function
-	cache  *cache
-	client protocol.ClientCloser
-	getVM  func(path string) (*jsonnet.VM, error)
+	stdlib  []stdlib.Function
+	cache   *cache
+	client  protocol.ClientCloser
+	getVM   func(path string) (*jsonnet.VM, error)
+	extVars map[string]string
 
 	// Feature flags
 	EvalDiags bool
@@ -64,6 +65,7 @@ func (s *server) WithStaticVM(jpaths []string) *server {
 	s.getVM = func(path string) (*jsonnet.VM, error) {
 		jpaths = append(jpaths, filepath.Dir(path))
 		vm := jsonnet.MakeVM()
+		resetExtVars(vm, s.extVars)
 		importer := &jsonnet.FileImporter{JPaths: jpaths}
 		vm.Importer(importer)
 		return vm, nil
@@ -82,7 +84,9 @@ func (s *server) WithTankaVM(fallbackJPath []string) *server {
 		opts := tankaJsonnet.Opts{
 			ImportPaths: jpath,
 		}
-		return tankaJsonnet.MakeVM(opts), nil
+		vm := tankaJsonnet.MakeVM(opts)
+		resetExtVars(vm, s.extVars)
+		return vm, nil
 	}
 	return s
 }

pkg/server/unused.go

@@ -216,10 +216,6 @@ func (s *server) DiagnosticWorkspace(context.Context, *protocol.WorkspaceDiagnos
 	return nil, notImplemented("DiagnosticWorkspace")
 }
 
-func (s *server) DidChangeConfiguration(context.Context, *protocol.DidChangeConfigurationParams) error {
-	return notImplemented("DidChangeConfiguration")
-}
-
 func (s *server) DidChangeWatchedFiles(context.Context, *protocol.DidChangeWatchedFilesParams) error {
 	return notImplemented("DidChangeWatchedFiles")
 }