Merge pull request #492 from vito-c/parser

adding ability to parse default bash variables such as ${foo:-bar}

Author: Vincent Demeester

config/interpolation.go

@@ -8,10 +8,16 @@ import (
 	"github.com/Sirupsen/logrus"
 )
 
+var defaultValues = make(map[string]string)
+
 func isNum(c uint8) bool {
 	return c >= '0' && c <= '9'
 }
 
+func validVariableDefault(c uint8, line string, pos int) bool {
+	return (c == ':' && line[pos+1] == '-') || (c == '-')
+}
+
 func validVariableNameChar(c uint8) bool {
 	return c == '_' ||
 		c >= 'A' && c <= 'Z' ||
@@ -36,6 +42,30 @@ func parseVariable(line string, pos int, mapping func(string) string) (string, i
 	return mapping(buffer.String()), pos, true
 }
 
+func parseDefaultValue(line string, pos int) (string, int, bool) {
+	var buffer bytes.Buffer
+
+	// only skip :, :- and - at the beginning
+	for ; pos < len(line); pos++ {
+		c := line[pos]
+		if c == ':' || c == '-' {
+			continue
+		}
+		break
+	}
+	for ; pos < len(line); pos++ {
+		c := line[pos]
+		if c == '}' {
+			return buffer.String(), pos - 1, true
+		}
+		err := buffer.WriteByte(c)
+		if err != nil {
+			return "", pos, false
+		}
+	}
+	return "", 0, false
+}
+
 func parseVariableWithBraces(line string, pos int, mapping func(string) string) (string, int, bool) {
 	var buffer bytes.Buffer
 
@@ -49,10 +79,13 @@ func parseVariableWithBraces(line string, pos int, mapping func(string) string)
 			if bufferString == "" {
 				return "", 0, false
 			}
-
 			return mapping(buffer.String()), pos, true
 		case validVariableNameChar(c):
 			buffer.WriteByte(c)
+		case validVariableDefault(c, line, pos):
+			defaultValue := ""
+			defaultValue, pos, _ = parseDefaultValue(line, pos)
+			defaultValues[buffer.String()] = defaultValue
 		default:
 			return "", 0, false
 		}
@@ -143,10 +176,19 @@ func Interpolate(key string, data *interface{}, environmentLookup EnvironmentLoo
 		values := environmentLookup.Lookup(s, nil)
 
 		if len(values) == 0 {
+			if val, ok := defaultValues[s]; ok {
+				return val
+			}
 			logrus.Warnf("The %s variable is not set. Substituting a blank string.", s)
 			return ""
 		}
 
+		if strings.SplitN(values[0], "=", 2)[1] == "" {
+			if val, ok := defaultValues[s]; ok {
+				return val
+			}
+		}
+
 		// Use first result if many are given
 		value := values[0]
 

config/interpolation_test.go

@@ -3,6 +3,7 @@ package config
 import (
 	"fmt"
 	"os"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -25,6 +26,14 @@ func testInvalidInterpolatedLine(t *testing.T, line string) {
 	assert.Equal(t, false, success)
 }
 
+func testInterpolatedDefault(t *testing.T, line string, delim string, expectedVar string, expectedVal string) {
+	envVar, _ := parseLine(line, func(env string) string { return env })
+	pos := strings.Index(line, delim)
+	envDefault, _, _ := parseDefaultValue(line, pos)
+	assert.Equal(t, expectedVal, envDefault)
+	assert.Equal(t, expectedVar, envVar)
+}
+
 func TestParseLine(t *testing.T) {
 	variables := map[string]string{
 		"A":           "ABC",
@@ -35,11 +44,20 @@ func TestParseLine(t *testing.T) {
 		"split_VaLue": "WORKED",
 		"9aNumber":    "WORKED",
 		"a9Number":    "WORKED",
+		"defTest":     "WORKED",
 	}
 
+	testInterpolatedDefault(t, "${defVar:-defVal}", ":-", "defVar", "defVal")
+	testInterpolatedDefault(t, "${defVar2-defVal2}", "-", "defVar2", "defVal2")
+	testInterpolatedDefault(t, "${defVar:-def:Val}", ":-", "defVar", "def:Val")
+	testInterpolatedDefault(t, "${defVar:-def-Val}", ":-", "defVar", "def-Val")
+
 	testInterpolatedLine(t, "WORKED", "$lower", variables)
 	testInterpolatedLine(t, "WORKED", "${MiXeD}", variables)
 	testInterpolatedLine(t, "WORKED", "${split_VaLue}", variables)
+	// make sure variable name is parsed correctly with default value
+	testInterpolatedLine(t, "WORKED", "${defTest:-sometest}", variables)
+	testInterpolatedLine(t, "WORKED", "${defTest-sometest}", variables)
 	// Starting with a number isn't valid
 	testInterpolatedLine(t, "", "$9aNumber", variables)
 	testInterpolatedLine(t, "WORKED", "$a9Number", variables)
@@ -67,6 +85,7 @@ func TestParseLine(t *testing.T) {
 	testInterpolatedLine(t, "", "$E", variables)
 	testInterpolatedLine(t, "", "${E}", variables)
 
+	testInvalidInterpolatedLine(t, "${df:val}")
 	testInvalidInterpolatedLine(t, "${")
 	testInvalidInterpolatedLine(t, "$}")
 	testInvalidInterpolatedLine(t, "${}")
@@ -198,6 +217,43 @@ func TestInterpolate(t *testing.T) {
 			"HOST_PORT":   "=",
 			"LABEL_VALUE": "myvalue==",
 		})
+	// same as above but with default values
+	testInterpolatedConfig(t,
+		`web:
+  # unbracketed name
+  image: busybox
+
+  # array element
+  ports:
+    - "80:8000"
+
+  # dictionary item value
+  labels:
+    mylabel: "my-val:ue"
+
+  # unset value
+  hostname: "host-"
+
+  # escaped interpolation
+  command: "${ESCAPED}"`,
+
+		`web:
+  # unbracketed name
+  image: ${IMAGE:-busybox}
+
+  # array element
+  ports:
+    - "${HOST_PORT:-80}:8000"
+
+  # dictionary item value
+  labels:
+    mylabel: "${LABEL_VALUE-my-val:ue}"
+
+  # unset value
+  hostname: "host-${UNSET_VALUE}"
+
+  # escaped interpolation
+  command: "$${ESCAPED}"`, map[string]string{})
 
 	testInvalidInterpolatedConfig(t,
 		`web: