Use braces syntax instead of Makefile syntax

Author: joeriddles

conf/lex.go

@@ -900,6 +900,18 @@ func (lx *lexer) isVariable() bool {
 	return false
 }
 
+// Check if the unquoted string is a variable reference with braces
+func (lx *lexer) isVariableWithBraces() bool {
+	if lx.start >= len(lx.input) {
+		return false
+	}
+	if len(lx.input) > 3 && lx.input[lx.start:lx.start+2] == "${" {
+		lx.start += 2
+		return true
+	}
+	return false
+}
+
 // lexQuotedString consumes the inner contents of a string. It assumes that the
 // beginning '"' has already been consumed and ignored. It will not interpret any
 // internal contents.
@@ -964,6 +976,14 @@ func lexString(lx *lexer) stateFn {
 			lx.emitString()
 		} else if lx.isBool() {
 			lx.emit(itemBool)
+		} else if lx.isVariableWithBraces() {
+			lx.emit(itemVariable)
+
+			// consume the trailing '}'
+			if lx.pos < len(lx.input) && lx.input[lx.pos] == '}' {
+				lx.next()
+				lx.ignore()
+			}
 		} else if lx.isVariable() {
 			lx.emit(itemVariable)
 		} else {

conf/lex_test.go

@@ -531,6 +531,14 @@ func TestVariableValues(t *testing.T) {
 	}
 	lx = lex("foo $bar")
 	expect(t, lx, expectedItems)
+
+	expectedItems = []item{
+		{itemKey, "foo", 1, 0},
+		{itemVariable, "bar", 1, 8},
+		{itemEOF, "", 1, 0},
+	}
+	lx = lex("foo = ${bar}")
+	expect(t, lx, expectedItems)
 }
 
 func TestArrays(t *testing.T) {
@@ -711,6 +719,22 @@ func TestNestedMaps(t *testing.T) {
 	expect(t, lx, expectedItems)
 }
 
+func TestSimpleMapWithVariable(t *testing.T) {
+	expectedItems := []item{
+		{itemKey, "foo", 1, 0},
+		{itemMapStart, "", 1, 7},
+		{itemKey, "ip", 1, 7},
+		{itemVariable, "IP", 1, 12},
+		{itemKey, "port", 1, 17},
+		{itemVariable, "PORT", 1, 26},
+		{itemMapEnd, "", 1, 32},
+		{itemEOF, "", 1, 0},
+	}
+
+	lx := lex("foo = {ip=${IP}, port = ${PORT}}")
+	expect(t, lx, expectedItems)
+}
+
 func TestQuotedKeys(t *testing.T) {
 	expectedItems := []item{
 		{itemKey, "foo", 1, 0},

conf/parse.go

@@ -288,7 +288,10 @@ func (p *parser) processItem(it item, fp string) error {
 		setValue(it, p.popContext())
 	case itemString:
 		// FIXME(dlc) sanitize string?
-		p.checkForEmbeddedVariables(&it)
+		err := p.checkForEmbeddedVariables(&it)
+		if err != nil {
+			return err
+		}
 		setValue(it, it.val)
 	case itemInteger:
 		lastDigit := 0
@@ -433,17 +436,18 @@ const pkey = "pk"
 const bcryptPrefix = "2a$"
 
 // To match embedded variables.
-var varPat = regexp.MustCompile(`\$\$[^@\s]+`)
+var varPat = regexp.MustCompile(`\$\{[^@\s]+\}`)
 
 // checkForEmbeddedVariable will check for embedded variables in an itemString.
 // If they are found and we can look them up we will replace them in item, otherwise will error.
 func (p *parser) checkForEmbeddedVariables(it *item) error {
-	if !strings.ContainsAny(it.val, "$$") {
+	if !strings.ContainsAny(it.val, "${") {
 		return nil
 	}
 	// We have some embedded variables.
 	for _, m := range varPat.FindAllString(it.val, -1) {
-		value, found, err := p.lookupVariable(m[2:]) // Strip leading $$ for lookup.
+		ref := m[2 : len(m)-1] // Strip leading ${ and trailing }
+		value, found, err := p.lookupVariable(ref)
 		if err != nil {
 			return fmt.Errorf("variable reference for '%s' on line %d could not be parsed: %s",
 				m, it.line, err)

conf/parse_test.go

@@ -84,6 +84,19 @@ func TestSimpleVariable(t *testing.T) {
 	test(t, varSample, ex)
 }
 
+var varSampleWithBraces = `
+  index = 22
+  foo = ${index}
+`
+
+func TestSimpleVariableWithBraces(t *testing.T) {
+	ex := map[string]any{
+		"index": int64(22),
+		"foo":   int64(22),
+	}
+	test(t, varSampleWithBraces, ex)
+}
+
 var varNestedSample = `
   index = 22
   nest {
@@ -113,6 +126,14 @@ func TestMissingVariable(t *testing.T) {
 	if !strings.HasPrefix(err.Error(), "variable reference") {
 		t.Fatalf("Wanted a variable reference err, got %q\n", err)
 	}
+
+	_, err = Parse("foo=${index}")
+	if err == nil {
+		t.Fatalf("Expected an error for a missing variable, got none")
+	}
+	if !strings.HasPrefix(err.Error(), "variable reference") {
+		t.Fatalf("Wanted a variable reference err, got %q\n", err)
+	}
 }
 
 func TestEnvVariable(t *testing.T) {
@@ -173,11 +194,9 @@ func TestEnvVariableEmbedded(t *testing.T) {
 			TOKEN: abc
 			authorization {
 				user: user
-				# normal variable syntax
-				password: $TOKEN
+				password: "${TOKEN}"
 			}
-			# embedded variable syntax
-			routes = [ nats://user:[email protected]:6222 ]
+			routes = [ "nats://user:${TOKEN}@server.example.com:6222" ]
 		}`
 	ex := map[string]any{
 		"cluster": map[string]any{
@@ -211,11 +230,8 @@ func TestEnvVariableEmbeddedMissing(t *testing.T) {
 		cluster {
 			authorization {
 				user: user
-				# normal variable syntax
-				password: $TOKEN
+				password: ${TOKEN}
 			}
-			# embedded variable syntax
-			routes = [ nats://user:[email protected]:6222 ]
 		}`
 
 	_, err := Parse(cluster)
@@ -227,13 +243,15 @@ func TestEnvVariableEmbeddedMissing(t *testing.T) {
 func TestEnvVariableEmbeddedOutsideOfQuotes(t *testing.T) {
 	cluster := `
 		cluster {
+			# set the variable token
+			TOKEN: abc
 			authorization {
 				user: user
-				# invalid embedded variable syntax
-				password: $$TOKEN
+				# ok
+				password: ${TOKEN}
 			}
-			# embedded variable syntax
-			routes = [ nats://user:$$[email protected]:6222 ]
+			# not ok
+			routes = [ nats://user:${TOKEN}@server.example.com:6222 ]
 		}`
 
 	_, err := Parse(cluster)