Fix typo in hasQuotePrefix return variable (#251)

Corrected the spelling of the return variable from 'isQuored' to 'isQuoted' in the hasQuotePrefix function.

.github/workflows/ci.yml

@@ -8,13 +8,13 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [ '1.19', '1.18', '1.17', '1.16', '1.15' ]
+        go: [ '1.20', '1.19', '1.18', '1.17', '1.16' ]
         os: [ ubuntu-latest, macOS-latest, windows-latest ]
     name: ${{ matrix.os }} Go ${{ matrix.go }} Tests
     steps:
       - uses: actions/checkout@v3
       - name: Setup go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
           go-version: ${{ matrix.go }}
       - run: go test

README.md

@@ -75,8 +75,8 @@ import _ "github.com/joho/godotenv/autoload"
 While `.env` in the project root is the default, you don't have to be constrained, both examples below are 100% legit
 
 ```go
-_ = godotenv.Load("somerandomfile")
-_ = godotenv.Load("filenumberone.env", "filenumbertwo.env")
+godotenv.Load("somerandomfile")
+godotenv.Load("filenumberone.env", "filenumbertwo.env")
 ```
 
 If you want to be really fancy with your env file you can do comments and exports (below is a valid env file)
@@ -153,6 +153,8 @@ 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

cmd/godotenv/cmd.go

@@ -4,7 +4,6 @@ import (
 	"flag"
 	"fmt"
 	"log"
-
 	"strings"
 
 	"github.com/joho/godotenv"
@@ -15,13 +14,15 @@ 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 [-f ENV_FILE_PATHS] COMMAND_ARGS
+godotenv [-o] [-f ENV_FILE_PATHS] COMMAND_ARGS
 
 ENV_FILE_PATHS: comma separated paths to .env files
 COMMAND_ARGS: command and args you want to run
@@ -47,7 +48,7 @@ example
 	cmd := args[0]
 	cmdArgs := args[1:]
 
-	err := godotenv.Exec(envFilenames, cmd, cmdArgs)
+	err := godotenv.Exec(envFilenames, cmd, cmdArgs, overload)
 	if err != nil {
 		log.Fatal(err)
 	}

fixtures/comments.env

@@ -1,4 +1,7 @@
 # Full line comment
+qux=thud # fred # other
+thud=fred#qux # other
+fred=qux#baz # other # more
 foo=bar # baz
 bar=foo#baz
 baz="foo"#bar

fixtures/equals.env

@@ -1,2 +1 @@
 export OPTION_A='postgres://localhost:5432/database?sslmode=disable'
-

fixtures/plain.env

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

fixtures/substitutions.env

@@ -3,3 +3,4 @@ OPTION_B=${OPTION_A}
 OPTION_C=$OPTION_B
 OPTION_D=${OPTION_A}${OPTION_B}
 OPTION_E=${OPTION_NOT_DEFINED}
+OPTION_F=${GLOBAL_OPTION}

godotenv.go

@@ -14,13 +14,11 @@
 package godotenv
 
 import (
-	"errors"
+	"bytes"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"os/exec"
-	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -30,12 +28,13 @@ 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, error) {
-	data, err := ioutil.ReadAll(r)
+	var buf bytes.Buffer
+	_, err := io.Copy(&buf, r)
 	if err != nil {
 		return nil, err
 	}
 
-	return UnmarshalBytes(data)
+	return UnmarshalBytes(buf.Bytes())
 }
 
 // Load will read your env file(s) and load them into ENV for this process.
@@ -125,9 +124,13 @@ func UnmarshalBytes(src []byte) (map[string]string, error) {
 // 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()` or `Read()` and the `os/exec` package yourself.
-func Exec(filenames []string, cmd string, cmdArgs []string) error {
-	if err := Load(filenames...); err != nil {
+// that you use `Load()`, `Overload()` or `Read()` and the `os/exec` package yourself.
+func Exec(filenames []string, cmd string, cmdArgs []string, overload bool) error {
+	op := Load
+	if overload {
+		op = Overload
+	}
+	if err := op(filenames...); err != nil {
 		return err
 	}
 
@@ -210,130 +213,6 @@ func readFile(filename string) (envMap map[string]string, err error) {
 	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,9 +12,14 @@ import (
 var noopPresets = make(map[string]string)
 
 func parseAndCompare(t *testing.T, rawEnvLine string, expectedKey string, expectedValue string) {
-	key, value, _ := parseLine(rawEnvLine, noopPresets)
-	if key != expectedKey || value != expectedValue {
-		t.Errorf("Expected '%v' to parse as '%v' => '%v', got '%v' => '%v' instead", rawEnvLine, expectedKey, expectedValue, key, value)
+	result, err := Unmarshal(rawEnvLine)
+
+	if err != nil {
+		t.Errorf("Expected %q to parse as %q: %q, errored %q", rawEnvLine, expectedKey, expectedValue, err)
+		return
+	}
+	if result[expectedKey] != expectedValue {
+		t.Errorf("Expected '%v' to parse as '%v' => '%v', got %q instead", rawEnvLine, expectedKey, expectedValue, result)
 	}
 }
 
@@ -80,6 +85,7 @@ func TestReadPlainEnv(t *testing.T) {
 		"OPTION_E": "5",
 		"OPTION_F": "",
 		"OPTION_G": "",
+		"OPTION_H": "1 2",
 	}
 
 	envMap, err := Read(envFileName)
@@ -153,6 +159,7 @@ func TestLoadPlainEnv(t *testing.T) {
 		"OPTION_C": "3",
 		"OPTION_D": "4",
 		"OPTION_E": "5",
+		"OPTION_H": "1 2",
 	}
 
 	loadEnvAndCompareValues(t, Load, envFileName, expectedValues, noopPresets)
@@ -200,15 +207,21 @@ func TestLoadQuotedEnv(t *testing.T) {
 
 func TestSubstitutions(t *testing.T) {
 	envFileName := "fixtures/substitutions.env"
+
+	presets := map[string]string{
+		"GLOBAL_OPTION": "global",
+	}
+
 	expectedValues := map[string]string{
 		"OPTION_A": "1",
 		"OPTION_B": "1",
 		"OPTION_C": "1",
 		"OPTION_D": "11",
 		"OPTION_E": "",
+		"OPTION_F": "global",
 	}
 
-	loadEnvAndCompareValues(t, Load, envFileName, expectedValues, noopPresets)
+	loadEnvAndCompareValues(t, Load, envFileName, expectedValues, presets)
 }
 
 func TestExpanding(t *testing.T) {
@@ -272,7 +285,6 @@ func TestExpanding(t *testing.T) {
 			}
 		})
 	}
-
 }
 
 func TestVariableStringValueSeparator(t *testing.T) {
@@ -369,6 +381,9 @@ 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")
@@ -391,10 +406,8 @@ 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")
 
-	// leading whitespace should be ignored
+	// unquoted whitespace around keys should be ignored
 	parseAndCompare(t, " KEY =value", "KEY", "value")
 	parseAndCompare(t, "   KEY=value", "KEY", "value")
 	parseAndCompare(t, "\tKEY=value", "KEY", "value")
@@ -402,7 +415,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 := parseLine(badlyFormattedLine, noopPresets)
+	_, err := Unmarshal(badlyFormattedLine)
 	if err == nil {
 		t.Errorf("Expected \"%v\" to return error, but it didn't", badlyFormattedLine)
 	}
@@ -464,6 +477,9 @@ func TestErrorParsing(t *testing.T) {
 func TestComments(t *testing.T) {
 	envFileName := "fixtures/comments.env"
 	expectedValues := map[string]string{
+		"qux":  "thud",
+		"thud": "fred#qux",
+		"fred": "qux#baz",
 		"foo":  "bar",
 		"bar":  "foo#baz",
 		"baz":  "foo",
@@ -520,3 +536,110 @@ 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)
+			}
+		})
+	}
+}

parser.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"os"
+	"regexp"
 	"strings"
 	"unicode"
 )
@@ -69,7 +71,13 @@ 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(bytes.TrimPrefix(src, []byte(exportPrefix)), isSpace)
+	src = bytes.TrimLeftFunc(src, 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
@@ -88,8 +96,8 @@ loop:
 			break loop
 		case '_':
 		default:
-			// variable name should match [A-Za-z0-9_]
-			if unicode.IsLetter(rchar) || unicode.IsNumber(rchar) {
+			// variable name should match [A-Za-z0-9_.]
+			if unicode.IsLetter(rchar) || unicode.IsNumber(rchar) || rchar == '.' {
 				continue
 			}
 
@@ -113,13 +121,41 @@ loop:
 func extractVarValue(src []byte, vars map[string]string) (value string, rest []byte, err error) {
 	quote, hasPrefix := hasQuotePrefix(src)
 	if !hasPrefix {
-		// unquoted value - read until whitespace
-		end := bytes.IndexFunc(src, unicode.IsSpace)
-		if end == -1 {
-			return expandVariables(string(src), vars), nil, nil
+		// 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
+			}
 		}
 
-		return expandVariables(string(src[0:end]), vars), src[end:], nil
+		// Convert line to rune away to do accurate countback of runes
+		line := []rune(string(src[0:endOfLine]))
+
+		// Assume end of line is end of var
+		endOfVar := len(line)
+		if endOfVar == 0 {
+			return "", src[endOfLine:], nil
+		}
+
+		// Work backwards to check if the line ends in whitespace then
+		// a comment, ie: foo=bar # baz # other
+		for i := 0; i < endOfVar; i++ {
+			if line[i] == charComment && i < endOfVar {
+				if isSpace(line[i-1]) {
+					endOfVar = i
+					break
+				}
+			}
+		}
+
+		trimmed := strings.TrimFunc(string(line[0:endOfVar]), isSpace)
+
+		return expandVariables(trimmed, vars), src[endOfLine:], nil
 	}
 
 	// lookup quoted string terminator
@@ -176,7 +212,7 @@ func indexOfNonSpaceChar(src []byte) int {
 }
 
 // hasQuotePrefix reports whether charset starts with single or double quote and returns quote character
-func hasQuotePrefix(src []byte) (prefix byte, isQuored bool) {
+func hasQuotePrefix(src []byte) (prefix byte, isQuoted bool) {
 	if len(src) == 0 {
 		return 0, false
 	}
@@ -205,3 +241,38 @@ 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] != "" {
+			if val, ok := m[submatch[4]]; ok {
+				return val
+			}
+			if val, ok := os.LookupEnv(submatch[4]); ok {
+				return val
+			}
+			return m[submatch[4]]
+		}
+		return s
+	})
+}