Inherit variables

This adds the feature of inheriting values from variables in the
current OS environment.
If not existent in the current environment, it produces an error.

Also removed the test with an empty key, since it's never present
in the environment.

Signed-off-by: Ulysses Souza <[email protected]>

Author: ulyssessouza

fixtures/inherited-not-found.env

@@ -0,0 +1 @@
+VARIABLE_NOT_FOUND

fixtures/inherited.env

@@ -0,0 +1 @@
+PATH

godotenv.go

@@ -97,31 +97,33 @@ func Read(filenames ...string) (envMap map[string]string, err error) {
 }
 
 // Parse reads an env file from io.Reader, returning a map of keys and values.
-func Parse(r io.Reader) (envMap map[string]string, err error) {
-	envMap = make(map[string]string)
+func Parse(r io.Reader) (map[string]string, error) {
+	envMap := make(map[string]string)
 
 	var lines []string
 	scanner := bufio.NewScanner(r)
 	for scanner.Scan() {
 		lines = append(lines, scanner.Text())
 	}
 
-	if err = scanner.Err(); err != nil {
-		return
+	if err := scanner.Err(); err != nil {
+		return envMap, err
 	}
 
 	for _, fullLine := range lines {
 		if !isIgnoredLine(fullLine) {
 			var key, value string
-			key, value, err = parseLine(fullLine, envMap)
-
+			key, value, err := parseLine(fullLine, envMap)
 			if err != nil {
-				return
+				return envMap, err
+			}
+			if key == "" {
+				continue
 			}
 			envMap[key] = value
 		}
 	}
-	return
+	return envMap, nil
 }
 
 //Unmarshal reads an env file from a string, returning a map of keys and values.
@@ -258,6 +260,16 @@ func parseLine(line string, envMap map[string]string) (key string, value string,
 		splitString = strings.SplitN(line, ":", 2)
 	}
 
+	// Environment inherited variable
+	if firstEquals < 0 && firstColon < 0 {
+		v, ok := os.LookupEnv(strings.TrimSpace(splitString[0]))
+		if !ok {
+			err = fmt.Errorf("could not find variable %q in the environment", line)
+			return
+		}
+		return line , v, nil
+	}
+
 	if len(splitString) != 2 {
 		err = errors.New("Can't separate key from value")
 		return
@@ -272,16 +284,30 @@ func parseLine(line string, envMap map[string]string) (key string, value string,
 
 	key = exportRegex.ReplaceAllString(splitString[0], "$1")
 
+	err = validateVariableName(key)
+	if err != nil {
+		return
+	}
+
 	// Parse the value
 	value = parseValue(splitString[1], envMap)
 	return
 }
 
+func validateVariableName(line string) error {
+	line = strings.TrimSpace(strings.TrimPrefix(line, "export "))
+	if !variableNameRegex.MatchString(line) {
+		return fmt.Errorf("invalid variable name %q", line)
+	}
+	return nil
+}
+
 var (
 	singleQuotesRegex  = regexp.MustCompile(`\A'(.*)'\z`)
 	doubleQuotesRegex  = regexp.MustCompile(`\A"(.*)"\z`)
 	escapeRegex        = regexp.MustCompile(`\\.`)
 	unescapeCharsRegex = regexp.MustCompile(`\\([^$])`)
+	variableNameRegex  = regexp.MustCompile(`^[_\\.a-zA-Z0-9]+$`)
 )
 
 func parseValue(value string, envMap map[string]string) string {

godotenv_test.go

@@ -82,6 +82,33 @@ func TestReadPlainEnv(t *testing.T) {
 		"OPTION_G": "",
 	}
 
+	envMap, err := Read(envFileName)
+	if err != nil {
+		t.Errorf("Error reading file: %q", err)
+	}
+
+	if len(envMap) != len(expectedValues) {
+		t.Error("Didn't get the right size map back")
+	}
+
+	for key, value := range expectedValues {
+		if envMap[key] != value {
+			t.Error("Read got one of the keys wrong")
+		}
+	}
+}
+
+func TestInheritedEnvVariable(t *testing.T) {
+	pathVariable, ok := os.LookupEnv("PATH")
+	if !ok {
+		t.Error("Error getting path variable")
+	}
+
+	envFileName := "fixtures/inherited.env"
+	expectedValues := map[string]string{
+		"PATH": pathVariable,
+	}
+
 	envMap, err := Read(envFileName)
 	if err != nil {
 		t.Error("Error reading file")
@@ -98,6 +125,14 @@ func TestReadPlainEnv(t *testing.T) {
 	}
 }
 
+func TestInheritedEnvVariableNotFound(t *testing.T) {
+	envFileName := "fixtures/inherited-not-found.env"
+	_, err := Read(envFileName)
+	if err == nil {
+		t.Errorf("Expected an error on 'Read' variable 'VARIABLE_NOT_FOUND' should not be found in environment")
+	}
+}
+
 func TestParse(t *testing.T) {
 	envMap, err := Parse(bytes.NewReader([]byte("ONE=1\nTWO='2'\nTHREE = \"3\"")))
 	expectedValues := map[string]string{
@@ -358,7 +393,6 @@ func TestParsing(t *testing.T) {
 	parseAndCompare(t, `FOO="bar\\\n\ b\az"`, "FOO", "bar\\\n baz")
 	parseAndCompare(t, `FOO="bar\\r\ b\az"`, "FOO", "bar\\r baz")
 
-	parseAndCompare(t, `="value"`, "", "value")
 	parseAndCompare(t, `KEY="`, "KEY", "\"")
 	parseAndCompare(t, `KEY="value`, "KEY", "\"value")
 
@@ -370,8 +404,8 @@ func TestParsing(t *testing.T) {
 	// it 'throws an error if line format is incorrect' do
 	// expect{env('lol$wut')}.to raise_error(Dotenv::FormatError)
 	badlyFormattedLine := "lol$wut"
-	_, _, err := parseLine(badlyFormattedLine, noopPresets)
-	if err == nil {
+	k, _, _ := parseLine(badlyFormattedLine, noopPresets)
+	if k != "" {
 		t.Errorf("Expected \"%v\" to return error, but it didn't", badlyFormattedLine)
 	}
 }