Update CI to test go 1.20

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Setup go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v3
         with:
           go-version: ${{ matrix.go }}
       - run: go test

README.md

@@ -153,8 +153,6 @@ godotenv -f /some/path/to/.env some_command with some args
 
 If you don't specify `-f` it will fall back on the default of loading `.env` in `PWD`
 
-By default, it won't override existing environment variables; you can do that with the `-o` flag.
-
 ### Writing Env Files
 
 Godotenv can also write a map representing the environment to a correctly-formatted and escaped file

autoload/autoload.go

@@ -8,7 +8,7 @@ package autoload
 	And bob's your mother's brother
 */
 
-import "git.coopcloud.tech/toolshed/godotenv"
+import "github.com/joho/godotenv"
 
 func init() {
 	godotenv.Load()

cmd/godotenv/cmd.go

@@ -7,7 +7,7 @@ import (
 
 	"strings"
 
-	"git.coopcloud.tech/toolshed/godotenv"
+	"github.com/joho/godotenv"
 )
 
 func main() {
@@ -15,15 +15,13 @@ func main() {
 	flag.BoolVar(&showHelp, "h", false, "show help")
 	var rawEnvFilenames string
 	flag.StringVar(&rawEnvFilenames, "f", "", "comma separated paths to .env files")
-	var overload bool
-	flag.BoolVar(&overload, "o", false, "override existing .env variables")
 
 	flag.Parse()
 
 	usage := `
 Run a process with an env setup from a .env file
 
-godotenv [-o] [-f ENV_FILE_PATHS] COMMAND_ARGS
+godotenv [-f ENV_FILE_PATHS] COMMAND_ARGS
 
 ENV_FILE_PATHS: comma separated paths to .env files
 COMMAND_ARGS: command and args you want to run
@@ -49,7 +47,7 @@ example
 	cmd := args[0]
 	cmdArgs := args[1:]
 
-	err := godotenv.Exec(envFilenames, cmd, cmdArgs, overload)
+	err := godotenv.Exec(envFilenames, cmd, cmdArgs)
 	if err != nil {
 		log.Fatal(err)
 	}

fixtures/plain.env

@@ -5,4 +5,3 @@ OPTION_D =4
 OPTION_E = 5
 OPTION_F = 
 OPTION_G=
-OPTION_H=1 2

go.mod

@@ -1,3 +1,3 @@
-module git.coopcloud.tech/toolshed/godotenv
+module github.com/joho/godotenv
 
 go 1.12

godotenv.go

@@ -14,11 +14,13 @@
 package godotenv
 
 import (
-	"bytes"
+	"errors"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"os"
 	"os/exec"
+	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -27,14 +29,13 @@ import (
 const doubleQuoteSpecialChars = "\\\n\r\"!$`"
 
 // Parse reads an env file from io.Reader, returning a map of keys and values.
-func Parse(r io.Reader) (map[string]string, map[string]map[string]string, error) {
+func Parse(r io.Reader) (map[string]string, error) {
-	var buf bytes.Buffer
+	data, err := ioutil.ReadAll(r)
-	_, err := io.Copy(&buf, r)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	return UnmarshalBytes(buf.Bytes())
+	return UnmarshalBytes(data)
 }
 
 // Load will read your env file(s) and load them into ENV for this process.
@@ -85,13 +86,12 @@ func Overload(filenames ...string) (err error) {
 
 // Read all env (with same file loading semantics as Load) but return values as
 // a map rather than automatically writing values into env
-func Read(filenames ...string) (envMap map[string]string, modMap map[string]map[string]string, err error) {
+func Read(filenames ...string) (envMap map[string]string, err error) {
 	filenames = filenamesOrDefault(filenames)
 	envMap = make(map[string]string)
-	modMap = make(map[string]map[string]string)
 
 	for _, filename := range filenames {
-		individualEnvMap, individualModMap, individualErr := readFile(filename)
+		individualEnvMap, individualErr := readFile(filename)
 
 		if individualErr != nil {
 			err = individualErr
@@ -101,27 +101,22 @@ func Read(filenames ...string) (envMap map[string]string, modMap map[string]map[
 		for key, value := range individualEnvMap {
 			envMap[key] = value
 		}
-
-		for key, value := range individualModMap {
-			modMap[key] = value
-		}
 	}
 
 	return
 }
 
 // Unmarshal reads an env file from a string, returning a map of keys and values.
-func Unmarshal(str string) (envMap map[string]string, modifierMap map[string]map[string]string, err error) {
+func Unmarshal(str string) (envMap map[string]string, err error) {
 	return UnmarshalBytes([]byte(str))
 }
 
 // UnmarshalBytes parses env file from byte slice of chars, returning a map of keys and values.
-func UnmarshalBytes(src []byte) (map[string]string, map[string]map[string]string, error) {
+func UnmarshalBytes(src []byte) (map[string]string, error) {
-	vars := make(map[string]string)
+	out := make(map[string]string)
-	modifiers := make(map[string]map[string]string)
+	err := parseBytes(src, out)
-	err := parseBytes(src, vars, modifiers)
 
-	return vars, modifiers, err
+	return out, err
 }
 
 // Exec loads env vars from the specified filenames (empty map falls back to default)
@@ -130,13 +125,9 @@ func UnmarshalBytes(src []byte) (map[string]string, map[string]map[string]string
 // Simply hooks up os.Stdin/err/out to the command and calls Run().
 //
 // If you want more fine grained control over your command it's recommended
-// that you use `Load()`, `Overload()` or `Read()` and the `os/exec` package yourself.
+// that you use `Load()` or `Read()` and the `os/exec` package yourself.
-func Exec(filenames []string, cmd string, cmdArgs []string, overload bool) error {
+func Exec(filenames []string, cmd string, cmdArgs []string) error {
-	op := Load
+	if err := Load(filenames...); err != nil {
-	if overload {
-		op = Overload
-	}
-	if err := op(filenames...); err != nil {
 		return err
 	}
 
@@ -188,7 +179,7 @@ func filenamesOrDefault(filenames []string) []string {
 }
 
 func loadFile(filename string, overload bool) error {
-	envMap, _, err := readFile(filename)
+	envMap, err := readFile(filename)
 	if err != nil {
 		return err
 	}
@@ -209,7 +200,7 @@ func loadFile(filename string, overload bool) error {
 	return nil
 }
 
-func readFile(filename string) (envMap map[string]string, modMap map[string]map[string]string, err error) {
+func readFile(filename string) (envMap map[string]string, err error) {
 	file, err := os.Open(filename)
 	if err != nil {
 		return
@@ -219,6 +210,130 @@ func readFile(filename string) (envMap map[string]string, modMap map[string]map[
 	return Parse(file)
 }
 
+var exportRegex = regexp.MustCompile(`^\s*(?:export\s+)?(.*?)\s*$`)
+
+func parseLine(line string, envMap map[string]string) (key string, value string, err error) {
+	if len(line) == 0 {
+		err = errors.New("zero length string")
+		return
+	}
+
+	// ditch the comments (but keep quoted hashes)
+	if strings.Contains(line, "#") {
+		segmentsBetweenHashes := strings.Split(line, "#")
+		quotesAreOpen := false
+		var segmentsToKeep []string
+		for _, segment := range segmentsBetweenHashes {
+			if strings.Count(segment, "\"") == 1 || strings.Count(segment, "'") == 1 {
+				if quotesAreOpen {
+					quotesAreOpen = false
+					segmentsToKeep = append(segmentsToKeep, segment)
+				} else {
+					quotesAreOpen = true
+				}
+			}
+
+			if len(segmentsToKeep) == 0 || quotesAreOpen {
+				segmentsToKeep = append(segmentsToKeep, segment)
+			}
+		}
+
+		line = strings.Join(segmentsToKeep, "#")
+	}
+
+	firstEquals := strings.Index(line, "=")
+	firstColon := strings.Index(line, ":")
+	splitString := strings.SplitN(line, "=", 2)
+	if firstColon != -1 && (firstColon < firstEquals || firstEquals == -1) {
+		//this is a yaml-style line
+		splitString = strings.SplitN(line, ":", 2)
+	}
+
+	if len(splitString) != 2 {
+		err = errors.New("can't separate key from value")
+		return
+	}
+
+	// Parse the key
+	key = splitString[0]
+
+	key = strings.TrimPrefix(key, "export")
+
+	key = strings.TrimSpace(key)
+
+	key = exportRegex.ReplaceAllString(splitString[0], "$1")
+
+	// Parse the value
+	value = parseValue(splitString[1], envMap)
+	return
+}
+
+var (
+	singleQuotesRegex  = regexp.MustCompile(`\A'(.*)'\z`)
+	doubleQuotesRegex  = regexp.MustCompile(`\A"(.*)"\z`)
+	escapeRegex        = regexp.MustCompile(`\\.`)
+	unescapeCharsRegex = regexp.MustCompile(`\\([^$])`)
+)
+
+func parseValue(value string, envMap map[string]string) string {
+
+	// trim
+	value = strings.Trim(value, " ")
+
+	// check if we've got quoted values or possible escapes
+	if len(value) > 1 {
+		singleQuotes := singleQuotesRegex.FindStringSubmatch(value)
+
+		doubleQuotes := doubleQuotesRegex.FindStringSubmatch(value)
+
+		if singleQuotes != nil || doubleQuotes != nil {
+			// pull the quotes off the edges
+			value = value[1 : len(value)-1]
+		}
+
+		if doubleQuotes != nil {
+			// expand newlines
+			value = escapeRegex.ReplaceAllStringFunc(value, func(match string) string {
+				c := strings.TrimPrefix(match, `\`)
+				switch c {
+				case "n":
+					return "\n"
+				case "r":
+					return "\r"
+				default:
+					return match
+				}
+			})
+			// unescape characters
+			value = unescapeCharsRegex.ReplaceAllString(value, "$1")
+		}
+
+		if singleQuotes == nil {
+			value = expandVariables(value, envMap)
+		}
+	}
+
+	return value
+}
+
+var expandVarRegex = regexp.MustCompile(`(\\)?(\$)(\()?\{?([A-Z0-9_]+)?\}?`)
+
+func expandVariables(v string, m map[string]string) string {
+	return expandVarRegex.ReplaceAllStringFunc(v, func(s string) string {
+		submatch := expandVarRegex.FindStringSubmatch(s)
+
+		if submatch == nil {
+			return s
+		}
+		if submatch[1] == "\\" || submatch[2] == "(" {
+			return submatch[0][1:]
+		} else if submatch[4] != "" {
+			return m[submatch[4]]
+		}
+		return s
+	})
+}
+
 func doubleQuoteEscape(line string) string {
 	for _, c := range doubleQuoteSpecialChars {
 		toReplace := "\\" + string(c)

godotenv_test.go

@@ -12,13 +12,9 @@ import (
 var noopPresets = make(map[string]string)
 
 func parseAndCompare(t *testing.T, rawEnvLine string, expectedKey string, expectedValue string) {
-	result, _, err := Unmarshal(rawEnvLine)
+	key, value, _ := parseLine(rawEnvLine, noopPresets)
-	if err != nil {
+	if key != expectedKey || value != expectedValue {
-		t.Errorf("Expected %q to parse as %q: %q, errored %q", rawEnvLine, expectedKey, expectedValue, err)
+		t.Errorf("Expected '%v' to parse as '%v' => '%v', got '%v' => '%v' instead", rawEnvLine, expectedKey, expectedValue, key, value)
-		return
-	}
-	if result[expectedKey] != expectedValue {
-		t.Errorf("Expected '%v' to parse as '%v' => '%v', got %q instead", rawEnvLine, expectedKey, expectedValue, result)
 	}
 }
 
@@ -84,10 +80,9 @@ func TestReadPlainEnv(t *testing.T) {
 		"OPTION_E": "5",
 		"OPTION_F": "",
 		"OPTION_G": "",
-		"OPTION_H": "1 2",
 	}
 
-	envMap, _, err := Read(envFileName)
+	envMap, err := Read(envFileName)
 	if err != nil {
 		t.Error("Error reading file")
 	}
@@ -104,7 +99,7 @@ func TestReadPlainEnv(t *testing.T) {
 }
 
 func TestParse(t *testing.T) {
-	envMap, _, err := Parse(bytes.NewReader([]byte("ONE=1\nTWO='2'\nTHREE = \"3\"")))
+	envMap, err := Parse(bytes.NewReader([]byte("ONE=1\nTWO='2'\nTHREE = \"3\"")))
 	expectedValues := map[string]string{
 		"ONE":   "1",
 		"TWO":   "2",
@@ -158,7 +153,6 @@ func TestLoadPlainEnv(t *testing.T) {
 		"OPTION_C": "3",
 		"OPTION_D": "4",
 		"OPTION_E": "5",
-		"OPTION_H": "1 2",
 	}
 
 	loadEnvAndCompareValues(t, Load, envFileName, expectedValues, noopPresets)
@@ -267,7 +261,7 @@ func TestExpanding(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			env, _, err := Parse(strings.NewReader(tt.input))
+			env, err := Parse(strings.NewReader(tt.input))
 			if err != nil {
 				t.Errorf("Error: %s", err.Error())
 			}
@@ -278,6 +272,7 @@ func TestExpanding(t *testing.T) {
 			}
 		})
 	}
+
 }
 
 func TestVariableStringValueSeparator(t *testing.T) {
@@ -285,7 +280,7 @@ func TestVariableStringValueSeparator(t *testing.T) {
 	want := map[string]string{
 		"TEST_URLS": "stratum+tcp://stratum.antpool.com:3333\nstratum+tcp://stratum.antpool.com:443",
 	}
-	got, _, err := Parse(strings.NewReader(input))
+	got, err := Parse(strings.NewReader(input))
 	if err != nil {
 		t.Error(err)
 	}
@@ -374,9 +369,6 @@ func TestParsing(t *testing.T) {
 	// expect(env('foo=bar ')).to eql('foo' => 'bar') # not 'bar '
 	parseAndCompare(t, "FOO=bar ", "FOO", "bar")
 
-	// unquoted internal whitespace is preserved
-	parseAndCompare(t, `KEY=value value`, "KEY", "value value")
-
 	// it 'ignores inline comments' do
 	// expect(env("foo=bar # this is foo")).to eql('foo' => 'bar')
 	parseAndCompare(t, "FOO=bar # this is foo", "FOO", "bar")
@@ -399,8 +391,10 @@ func TestParsing(t *testing.T) {
 	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")
 
-	// unquoted whitespace around keys should be ignored
+	// leading whitespace should be ignored
 	parseAndCompare(t, " KEY =value", "KEY", "value")
 	parseAndCompare(t, "   KEY=value", "KEY", "value")
 	parseAndCompare(t, "\tKEY=value", "KEY", "value")
@@ -408,7 +402,7 @@ 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 := Unmarshal(badlyFormattedLine)
+	_, _, err := parseLine(badlyFormattedLine, noopPresets)
 	if err == nil {
 		t.Errorf("Expected \"%v\" to return error, but it didn't", badlyFormattedLine)
 	}
@@ -452,7 +446,7 @@ func TestLinesToIgnore(t *testing.T) {
 
 func TestErrorReadDirectory(t *testing.T) {
 	envFileName := "fixtures/"
-	envMap, _, err := Read(envFileName)
+	envMap, err := Read(envFileName)
 
 	if err == nil {
 		t.Errorf("Expected error, got %v", envMap)
@@ -461,7 +455,7 @@ func TestErrorReadDirectory(t *testing.T) {
 
 func TestErrorParsing(t *testing.T) {
 	envFileName := "fixtures/invalid1.env"
-	envMap, _, err := Read(envFileName)
+	envMap, err := Read(envFileName)
 	if err == nil {
 		t.Errorf("Expected error, got %v", envMap)
 	}
@@ -480,7 +474,7 @@ func TestComments(t *testing.T) {
 
 func TestWrite(t *testing.T) {
 	writeAndCompare := func(env string, expected string) {
-		envMap, _, _ := Unmarshal(env)
+		envMap, _ := Unmarshal(env)
 		actual, _ := Marshal(envMap)
 		if expected != actual {
 			t.Errorf("Expected '%v' (%v) to write as '%v', got '%v' instead.", env, envMap, expected, actual)
@@ -501,13 +495,14 @@ func TestWrite(t *testing.T) {
 	writeAndCompare("foo=bar\nbaz=buzz", "baz=\"buzz\"\nfoo=\"bar\"")
 	// integers should not be quoted
 	writeAndCompare(`key="10"`, `key=10`)
+
 }
 
 func TestRoundtrip(t *testing.T) {
 	fixtures := []string{"equals.env", "exported.env", "plain.env", "quoted.env"}
 	for _, fixture := range fixtures {
 		fixtureFilename := fmt.Sprintf("fixtures/%s", fixture)
-		env, _, err := readFile(fixtureFilename)
+		env, err := readFile(fixtureFilename)
 		if err != nil {
 			t.Errorf("Expected '%s' to read without error (%v)", fixtureFilename, err)
 		}
@@ -515,7 +510,7 @@ func TestRoundtrip(t *testing.T) {
 		if err != nil {
 			t.Errorf("Expected '%s' to Marshal (%v)", fixtureFilename, err)
 		}
-		roundtripped, _, err := Unmarshal(rep)
+		roundtripped, err := Unmarshal(rep)
 		if err != nil {
 			t.Errorf("Expected '%s' to Mashal and Unmarshal (%v)", fixtureFilename, err)
 		}
@@ -525,185 +520,3 @@ func TestRoundtrip(t *testing.T) {
 
 	}
 }
-
-func TestTrailingNewlines(t *testing.T) {
-	cases := map[string]struct {
-		input string
-		key   string
-		value string
-	}{
-		"Simple value without trailing newline": {
-			input: "KEY=value",
-			key:   "KEY",
-			value: "value",
-		},
-		"Value with internal whitespace without trailing newline": {
-			input: "KEY=value value",
-			key:   "KEY",
-			value: "value value",
-		},
-		"Value with internal whitespace with trailing newline": {
-			input: "KEY=value value\n",
-			key:   "KEY",
-			value: "value value",
-		},
-		"YAML style - value with internal whitespace without trailing newline": {
-			input: "KEY: value value",
-			key:   "KEY",
-			value: "value value",
-		},
-		"YAML style - value with internal whitespace with trailing newline": {
-			input: "KEY: value value\n",
-			key:   "KEY",
-			value: "value value",
-		},
-	}
-
-	for n, c := range cases {
-		t.Run(n, func(t *testing.T) {
-			result, _, err := Unmarshal(c.input)
-			if err != nil {
-				t.Errorf("Input: %q Unexpected error:\t%q", c.input, err)
-			}
-			if result[c.key] != c.value {
-				t.Errorf("Input %q Expected:\t %q/%q\nGot:\t %q", c.input, c.key, c.value, result)
-			}
-		})
-	}
-}
-
-func TestWhitespace(t *testing.T) {
-	cases := map[string]struct {
-		input string
-		key   string
-		value string
-	}{
-		"Leading whitespace": {
-			input: " A=a\n",
-			key:   "A",
-			value: "a",
-		},
-		"Leading tab": {
-			input: "\tA=a\n",
-			key:   "A",
-			value: "a",
-		},
-		"Leading mixed whitespace": {
-			input: " \t \t\n\t \t A=a\n",
-			key:   "A",
-			value: "a",
-		},
-		"Leading whitespace before export": {
-			input: " \t\t export    A=a\n",
-			key:   "A",
-			value: "a",
-		},
-		"Trailing whitespace": {
-			input: "A=a \t \t\n",
-			key:   "A",
-			value: "a",
-		},
-		"Trailing whitespace with export": {
-			input: "export A=a\t \t \n",
-			key:   "A",
-			value: "a",
-		},
-		"No EOL": {
-			input: "A=a",
-			key:   "A",
-			value: "a",
-		},
-		"Trailing whitespace with no EOL": {
-			input: "A=a ",
-			key:   "A",
-			value: "a",
-		},
-	}
-
-	for n, c := range cases {
-		t.Run(n, func(t *testing.T) {
-			result, _, err := Unmarshal(c.input)
-			if err != nil {
-				t.Errorf("Input: %q Unexpected error:\t%q", c.input, err)
-			}
-			if result[c.key] != c.value {
-				t.Errorf("Input %q Expected:\t %q/%q\nGot:\t %q", c.input, c.key, c.value, result)
-			}
-		})
-	}
-}
-
-func TestModfiers(t *testing.T) {
-	cases := map[string]struct {
-		input     string
-		key       string
-		value     string
-		modifiers map[string]string
-	}{
-		"No Modifier": {
-			input: "A=a",
-			key:   "A",
-			value: "a",
-		},
-		"With comment": {
-			input: "A=a # my comment",
-			key:   "A",
-			value: "a",
-		},
-		"With single modifier": {
-			input: "A=a # foo=bar",
-			key:   "A",
-			value: "a",
-			modifiers: map[string]string{
-				"foo": "bar",
-			},
-		},
-		"With multiple modifiers": {
-			input: "A=a # foo=bar length=10",
-			key:   "A",
-			value: "a",
-			modifiers: map[string]string{
-				"foo":    "bar",
-				"length": "10",
-			},
-		},
-		"With quoted var": {
-			input: "A='a' # foo=bar",
-			key:   "A",
-			value: "a",
-			modifiers: map[string]string{
-				"foo": "bar",
-			},
-		},
-		"With quoted var 2": {
-			input: "A='a' # foo=bar\nB=b",
-			key:   "A",
-			value: "a",
-			modifiers: map[string]string{
-				"foo": "bar",
-			},
-		},
-	}
-
-	for n, c := range cases {
-		t.Run(n, func(t *testing.T) {
-			values, modifiers, err := Unmarshal(c.input)
-			if err != nil {
-				t.Errorf("Input: %q Unexpected error:\t%q", c.input, err)
-			}
-			if values[c.key] != c.value {
-				t.Errorf("Input %q Expected:\t %q/%q\nGot:\t %q", c.input, c.key, c.value, values)
-			}
-
-			if modifiers[c.key] == nil && c.modifiers != nil {
-				t.Errorf("Input %q Expected modifiers\n Got: none", c.input)
-			} else {
-				for k, v := range c.modifiers {
-					if modifiers[c.key][k] != v {
-						t.Errorf("Input %q Expected modifier %s=%s\n Got: %s=%s", c.input, k, v, k, modifiers[c.key][k])
-					}
-				}
-			}
-		})
-	}
-}

parser.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"regexp"
 	"strings"
 	"unicode"
 )
@@ -17,7 +16,7 @@ const (
 	exportPrefix = "export"
 )
 
-func parseBytes(src []byte, vars map[string]string, modifiers map[string]map[string]string) error {
+func parseBytes(src []byte, out map[string]string) error {
 	src = bytes.Replace(src, []byte("\r\n"), []byte("\n"), -1)
 	cutset := src
 	for {
@@ -32,13 +31,12 @@ func parseBytes(src []byte, vars map[string]string, modifiers map[string]map[str
 			return err
 		}
 
-		value, mods, left, err := extractVarValue(left, vars)
+		value, left, err := extractVarValue(left, out)
 		if err != nil {
 			return err
 		}
 
-		vars[key] = value
+		out[key] = value
-		modifiers[key] = mods
 		cutset = left
 	}
 
@@ -71,13 +69,7 @@ func getStatementStart(src []byte) []byte {
 // locateKeyName locates and parses key name and returns rest of slice
 func locateKeyName(src []byte) (key string, cutset []byte, err error) {
 	// trim "export" and space at beginning
-	src = bytes.TrimLeftFunc(src, isSpace)
+	src = bytes.TrimLeftFunc(bytes.TrimPrefix(src, []byte(exportPrefix)), isSpace)
-	if bytes.HasPrefix(src, []byte(exportPrefix)) {
-		trimmed := bytes.TrimPrefix(src, []byte(exportPrefix))
-		if bytes.IndexFunc(trimmed, isSpace) == 0 {
-			src = bytes.TrimLeftFunc(trimmed, isSpace)
-		}
-	}
 
 	// locate key name end and validate it in single loop
 	offset := 0
@@ -96,8 +88,8 @@ loop:
 			break loop
 		case '_':
 		default:
-			// variable name should match [A-Za-z0-9_.]
+			// variable name should match [A-Za-z0-9_]
-			if unicode.IsLetter(rchar) || unicode.IsNumber(rchar) || rchar == '.' {
+			if unicode.IsLetter(rchar) || unicode.IsNumber(rchar) {
 				continue
 			}
 
@@ -118,44 +110,16 @@ loop:
 }
 
 // extractVarValue extracts variable value and returns rest of slice
-func extractVarValue(src []byte, vars map[string]string) (value string, modifiers map[string]string, rest []byte, err error) {
+func extractVarValue(src []byte, vars map[string]string) (value string, rest []byte, err error) {
 	quote, hasPrefix := hasQuotePrefix(src)
-	// unquoted value - read until end of line
-	endOfLine := bytes.IndexFunc(src, isLineEnd)
-	// Hit EOF without a trailing newline
-	if endOfLine == -1 {
-		endOfLine = len(src)
-
-		if endOfLine == 0 {
-			return "", nil, nil, nil
-		}
-	}
 	if !hasPrefix {
-		// Convert line to rune away to do accurate countback of runes
+		// unquoted value - read until whitespace
-		line := []rune(string(src[0:endOfLine]))
+		end := bytes.IndexFunc(src, unicode.IsSpace)
-
+		if end == -1 {
-		// Assume end of line is end of var
+			return expandVariables(string(src), vars), nil, nil
-		endOfVar := len(line)
-		if endOfVar == 0 {
-			return "", nil, src[endOfLine:], nil
 		}
 
-		comment := ""
+		return expandVariables(string(src[0:end]), vars), src[end:], nil
-		// Work backwards to check if the line ends in whitespace then
-		// a comment (ie asdasd # some comment)
-		for i := endOfVar - 1; i >= 0; i-- {
-			if line[i] == charComment && i > 0 {
-				comment = string(line[i+1:])
-				if isSpace(line[i-1]) {
-					endOfVar = i
-					break
-				}
-			}
-		}
-
-		trimmed := strings.TrimFunc(string(line[0:endOfVar]), isSpace)
-
-		return expandVariables(trimmed, vars), extractModifiers(comment), src[endOfLine:], nil
 	}
 
 	// lookup quoted string terminator
@@ -178,11 +142,7 @@ func extractVarValue(src []byte, vars map[string]string) (value string, modifier
 			value = expandVariables(expandEscapes(value), vars)
 		}
 
-		var mods map[string]string
+		return value, src[i+1:], nil
-		if endOfLine > i {
-			mods = extractModifiers(string(src[i+1 : endOfLine]))
-		}
-		return value, mods, src[i+1:], nil
 	}
 
 	// return formatted error if quoted string is not terminated
@@ -191,24 +151,7 @@ func extractVarValue(src []byte, vars map[string]string) (value string, modifier
 		valEndIndex = len(src)
 	}
 
-	return "", nil, nil, fmt.Errorf("unterminated quoted value %s", src[:valEndIndex])
+	return "", nil, fmt.Errorf("unterminated quoted value %s", src[:valEndIndex])
-}
-
-func extractModifiers(comment string) map[string]string {
-	if comment == "" {
-		return nil
-	}
-	comment = strings.TrimSpace(comment)
-	kvpairs := strings.Split(comment, " ")
-	mods := make(map[string]string)
-	for _, kv := range kvpairs {
-		kvsplit := strings.Split(kv, "=")
-		if len(kvsplit) != 2 {
-			continue
-		}
-		mods[kvsplit[0]] = kvsplit[1]
-	}
-	return mods
 }
 
 func expandEscapes(str string) string {
@@ -262,32 +205,3 @@ func isSpace(r rune) bool {
 	}
 	return false
 }
-
-func isLineEnd(r rune) bool {
-	if r == '\n' || r == '\r' {
-		return true
-	}
-	return false
-}
-
-var (
-	escapeRegex        = regexp.MustCompile(`\\.`)
-	expandVarRegex     = regexp.MustCompile(`(\\)?(\$)(\()?\{?([A-Z0-9_]+)?\}?`)
-	unescapeCharsRegex = regexp.MustCompile(`\\([^$])`)
-)
-
-func expandVariables(v string, m map[string]string) string {
-	return expandVarRegex.ReplaceAllStringFunc(v, func(s string) string {
-		submatch := expandVarRegex.FindStringSubmatch(s)
-
-		if submatch == nil {
-			return s
-		}
-		if submatch[1] == "\\" || submatch[2] == "(" {
-			return submatch[0][1:]
-		} else if submatch[4] != "" {
-			return m[submatch[4]]
-		}
-		return s
-	})
-}