fix: if a line contains multiple # characters, there will be issues w… (#238)

* fix: if a line contains multiple # characters, there will be issues when traversing from back to front

* fix: typo

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "gomod"
+    directory: /
+    schedule:
+      interval: "daily"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/ci.yml

@@ -8,55 +8,13 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [ '1.15', '1.14' ]
+        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@v2
+      - uses: actions/checkout@v3
       - name: Setup go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v4
         with:
           go-version: ${{ matrix.go }}
       - run: go test
-
-  test-non-amd64:
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          # For some reasons this is segfaulting on go env
-          # - name: IBM Z and LinuxONE
-          #   architecture: "s390x"
-          - name: POWER8
-            architecture: "ppc64le"
-    
-    runs-on: ubuntu-latest
-    name: Test on ${{ matrix.arch.name }} 
-    steps:
-      - uses: actions/checkout@v2
-      - uses: uraimo/run-on-arch-action@master
-        with:
-          arch: ${{ matrix.arch.architecture }}
-          distro: ubuntu20.04
-          env: | # YAML pipe
-            GOARCH: ${{ matrix.arch.architecture }}
-            CGO_ENABLED: 0
-          run: |
-            apt-get update
-            apt-get install -q -y curl wget git
-            latestGo=$(curl "https://golang.org/VERSION?m=text")
-            wget "https://dl.google.com/go/${latestGo}.linux-${GOARCH}.tar.gz"
-            rm -f $(which go)
-            rm -rf /usr/local/go
-            tar -C /usr/local -xzf "${latestGo}.linux-${GOARCH}.tar.gz"
-            export PATH=/usr/local/go/bin:$PATH
-            printf "Using go at: $(which go)\n"
-            printf "Go version: $(go version)\n"
-            printf "\n\nGo environment:\n\n"
-            go env
-            printf "\n\nSystem environment:\n\n"
-            env
-            go get -insecure -v -t -d ./...
-            go test ./...
-            cd ./cmd/godotenv
-            go build -trimpath -ldflags="-w -s" -v

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,72 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "main" ]
+  schedule:
+    - cron: '31 4 * * 2'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/release.yml

@@ -11,11 +11,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Generate build files
-        uses: thatisuday/go-cross-build@v1
+        uses: thatisuday/go-cross-build@v1.0.2
         with:
-            platforms: 'linux/amd64, linux/ppc64le, darwin/amd64, windows/amd64'
+            platforms: 'linux/amd64, linux/ppc64le, darwin/amd64, darwin/arm64, windows/amd64'
             package: 'cmd/godotenv'
             name: 'godotenv'
             compress: 'true'
@@ -29,4 +29,3 @@ jobs:
           file: dist/*
           file_glob: true
           overwrite: true
-          

README.md

@@ -1,6 +1,6 @@
 # GoDotEnv ![CI](https://github.com/joho/godotenv/workflows/CI/badge.svg) [![Go Report Card](https://goreportcard.com/badge/github.com/joho/godotenv)](https://goreportcard.com/report/github.com/joho/godotenv)
 
-A Go (golang) port of the Ruby dotenv project (which loads env vars from a .env file)
+A Go (golang) port of the Ruby [dotenv](https://github.com/bkeepers/dotenv) project (which loads env vars from a .env file).
 
 From the original Library:
 
@@ -8,9 +8,9 @@ From the original Library:
 >
 > But it is not always practical to set environment variables on development machines or continuous integration servers where multiple projects are run. Dotenv load variables from a .env file into ENV when the environment is bootstrapped.
 
-It can be used as a library (for loading in env for your own daemons etc) or as a bin command.
+It can be used as a library (for loading in env for your own daemons etc.) or as a bin command.
 
-There is test coverage and CI for both linuxish and windows environments, but I make no guarantees about the bin version working on windows.
+There is test coverage and CI for both linuxish and Windows environments, but I make no guarantees about the bin version working on Windows.
 
 ## Installation
 
@@ -21,6 +21,13 @@ go get github.com/joho/godotenv
 ```
 
 or if you want to use it as a bin command
+
+go >= 1.17
+```shell
+go install github.com/joho/godotenv/cmd/godotenv@latest
+```
+
+go < 1.17
 ```shell
 go get github.com/joho/godotenv/cmd/godotenv
 ```
@@ -40,9 +47,10 @@ Then in your Go app you can do something like
 package main
 
 import (
-    "github.com/joho/godotenv"
     "log"
     "os"
+
+    "github.com/joho/godotenv"
 )
 
 func main() {
@@ -67,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("somerandomfile")
-_ = godotenv.Load("filenumberone.env", "filenumbertwo.env")
+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)
@@ -145,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
@@ -163,9 +173,17 @@ content, err := godotenv.Marshal(env)
 
 ## Contributing
 
-Contributions are most welcome! The parser itself is pretty stupidly naive and I wouldn't be surprised if it breaks with edge cases.
+Contributions are welcome, but with some caveats.
 
-*code changes without tests will not be accepted*
+This library has been declared feature complete (see [#182](https://github.com/joho/godotenv/issues/182) for background) and will not be accepting issues or pull requests adding new functionality or breaking the library API.
+
+Contributions would be gladly accepted that:
+
+* bring this library's parsing into closer compatibility with the mainline dotenv implementations, in particular [Ruby's dotenv](https://github.com/bkeepers/dotenv) and [Node.js' dotenv](https://github.com/motdotla/dotenv)
+* keep the library up to date with the go ecosystem (ie CI bumps, documentation changes, changes in the core libraries)
+* bug fixes for use cases that pertain to the library's purpose of easing development of codebases deployed into twelve factor environments
+
+*code changes without tests and references to peer dotenv implementations will not be accepted*
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
@@ -179,10 +197,6 @@ Releases should follow [Semver](http://semver.org/) though the first couple of r
 
 Use [annotated tags for all releases](https://github.com/joho/godotenv/issues/30). Example `git tag -a v1.2.1`
 
-## CI
-
-Linux: [![Build Status](https://travis-ci.org/joho/godotenv.svg?branch=master)](https://travis-ci.org/joho/godotenv) Windows: [![Build status](https://ci.appveyor.com/api/projects/status/9v40vnfvvgde64u4)](https://ci.appveyor.com/project/joho/godotenv)
-
 ## Who?
 
 The original library [dotenv](https://github.com/bkeepers/dotenv) was written by [Brandon Keepers](http://opensoul.org/), and this port was done by [John Barton](https://johnbarton.co/) based off the tests/fixtures in the original library.

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

@@ -0,0 +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/quoted.env

@@ -7,3 +7,13 @@ OPTION_F="2"
 OPTION_G=""
 OPTION_H="\n"
 OPTION_I = "echo 'asd'"
+OPTION_J='line 1
+line 2'
+OPTION_K='line one
+this is \'quoted\'
+one more line'
+OPTION_L="line 1
+line 2"
+OPTION_M="line one
+this is \"quoted\"
+one more line"

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

@@ -1,6 +1,6 @@
 // Package godotenv is a go port of the ruby dotenv library (https://github.com/bkeepers/dotenv)
 //
-// Examples/readme can be found on the github page at https://github.com/joho/godotenv
+// Examples/readme can be found on the GitHub page at https://github.com/joho/godotenv
 //
 // The TL;DR is that you make a .env file that looks something like
 //
@@ -14,13 +14,11 @@
 package godotenv
 
 import (
-	"bufio"
+	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
-	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -28,17 +26,28 @@ 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, error) {
+	var buf bytes.Buffer
+	_, err := io.Copy(&buf, r)
+	if err != nil {
+		return nil, err
+	}
+
+	return UnmarshalBytes(buf.Bytes())
+}
+
 // Load will read your env file(s) and load them into ENV for this process.
 //
-// Call this function as close as possible to the start of your program (ideally in main)
+// Call this function as close as possible to the start of your program (ideally in main).
 //
-// If you call Load without any args it will default to loading .env in the current path
+// If you call Load without any args it will default to loading .env in the current path.
 //
-// You can otherwise tell it which files to load (there can be more than one) like
+// You can otherwise tell it which files to load (there can be more than one) like:
 //
 //	godotenv.Load("fileone", "filetwo")
 //
-// It's important to note that it WILL NOT OVERRIDE an env variable that already exists - consider the .env file to set dev vars or sensible defaults
+// It's important to note that it WILL NOT OVERRIDE an env variable that already exists - consider the .env file to set dev vars or sensible defaults.
 func Load(filenames ...string) (err error) {
 	filenames = filenamesOrDefault(filenames)
 
@@ -53,15 +62,15 @@ func Load(filenames ...string) (err error) {
 
 // Overload will read your env file(s) and load them into ENV for this process.
 //
-// Call this function as close as possible to the start of your program (ideally in main)
+// Call this function as close as possible to the start of your program (ideally in main).
 //
-// If you call Overload without any args it will default to loading .env in the current path
+// If you call Overload without any args it will default to loading .env in the current path.
 //
-// You can otherwise tell it which files to load (there can be more than one) like
+// You can otherwise tell it which files to load (there can be more than one) like:
 //
 //	godotenv.Overload("fileone", "filetwo")
 //
-// It's important to note this WILL OVERRIDE an env variable that already exists - consider the .env file to forcefilly set all vars.
+// It's important to note this WILL OVERRIDE an env variable that already exists - consider the .env file to forcefully set all vars.
 func Overload(filenames ...string) (err error) {
 	filenames = filenamesOrDefault(filenames)
 
@@ -96,48 +105,34 @@ func Read(filenames ...string) (envMap map[string]string, err error) {
 	return
 }
 
-// Parse reads an env file from io.Reader, returning a map of keys and values.
+// Unmarshal reads an env file from a string, returning a map of keys and values.
-func Parse(r io.Reader) (envMap map[string]string, err error) {
+func Unmarshal(str string) (envMap map[string]string, err error) {
-	envMap = make(map[string]string)
+	return UnmarshalBytes([]byte(str))
-
-	var lines []string
-	scanner := bufio.NewScanner(r)
-	for scanner.Scan() {
-		lines = append(lines, scanner.Text())
-	}
-
-	if err = scanner.Err(); err != nil {
-		return
-	}
-
-	for _, fullLine := range lines {
-		if !isIgnoredLine(fullLine) {
-			var key, value string
-			key, value, err = parseLine(fullLine, envMap)
-
-			if err != nil {
-				return
-			}
-			envMap[key] = value
-		}
-	}
-	return
 }
 
-//Unmarshal reads an env file from a string, returning a map of keys and values.
+// UnmarshalBytes parses env file from byte slice of chars, returning a map of keys and values.
-func Unmarshal(str string) (envMap map[string]string, err error) {
+func UnmarshalBytes(src []byte) (map[string]string, error) {
-	return Parse(strings.NewReader(str))
+	out := make(map[string]string)
+	err := parseBytes(src, out)
+
+	return out, err
 }
 
 // Exec loads env vars from the specified filenames (empty map falls back to default)
 // then executes the cmd specified.
 //
-// Simply hooks up os.Stdin/err/out to the command and calls Run()
+// 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.
+// that you use `Load()`, `Overload()` or `Read()` and the `os/exec` package yourself.
-func Exec(filenames []string, cmd string, cmdArgs []string) error {
+func Exec(filenames []string, cmd string, cmdArgs []string, overload bool) error {
-	Load(filenames...)
+	op := Load
+	if overload {
+		op = Overload
+	}
+	if err := op(filenames...); err != nil {
+		return err
+	}
 
 	command := exec.Command(cmd, cmdArgs...)
 	command.Stdin = os.Stdin
@@ -146,7 +141,7 @@ func Exec(filenames []string, cmd string, cmdArgs []string) error {
 	return command.Run()
 }
 
-// Write serializes the given environment and writes it to a file
+// Write serializes the given environment and writes it to a file.
 func Write(envMap map[string]string, filename string) error {
 	content, err := Marshal(envMap)
 	if err != nil {
@@ -161,8 +156,7 @@ func Write(envMap map[string]string, filename string) error {
 	if err != nil {
 		return err
 	}
-	file.Sync()
+	return file.Sync()
-	return err
 }
 
 // Marshal outputs the given environment as a dotenv-formatted environment file.
@@ -202,7 +196,7 @@ func loadFile(filename string, overload bool) error {
 
 	for key, value := range envMap {
 		if !currentEnv[key] || overload {
-			os.Setenv(key, value)
+			_ = os.Setenv(key, value)
 		}
 	}
 
@@ -219,135 +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]
-	if strings.HasPrefix(key, "export") {
-		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 isIgnoredLine(line string) bool {
-	trimmedLine := strings.TrimSpace(line)
-	return len(trimmedLine) == 0 || strings.HasPrefix(trimmedLine, "#")
-}
-
 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)
+	result, err := Unmarshal(rawEnvLine)
-	if key != expectedKey || value != expectedValue {
+
-		t.Errorf("Expected '%v' to parse as '%v' => '%v', got '%v' => '%v' instead", rawEnvLine, expectedKey, expectedValue, key, value)
+	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)
 	}
 }
 
@@ -35,7 +40,7 @@ func loadEnvAndCompareValues(t *testing.T, loader func(files ...string) error, e
 		envValue := os.Getenv(k)
 		v := expectedValues[k]
 		if envValue != v {
-			t.Errorf("Mismatch for key '%v': expected '%v' got '%v'", k, v, envValue)
+			t.Errorf("Mismatch for key '%v': expected '%#v' got '%#v'", k, v, envValue)
 		}
 	}
 }
@@ -80,6 +85,7 @@ func TestReadPlainEnv(t *testing.T) {
 		"OPTION_E": "5",
 		"OPTION_F": "",
 		"OPTION_G": "",
+		"OPTION_H": "1 2",
 	}
 
 	envMap, err := Read(envFileName)
@@ -131,7 +137,7 @@ func TestLoadDoesNotOverride(t *testing.T) {
 	loadEnvAndCompareValues(t, Load, envFileName, expectedValues, presets)
 }
 
-func TestOveroadDoesOverride(t *testing.T) {
+func TestOverloadDoesOverride(t *testing.T) {
 	envFileName := "fixtures/plain.env"
 
 	// ensure NO overload
@@ -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)
@@ -189,6 +196,10 @@ func TestLoadQuotedEnv(t *testing.T) {
 		"OPTION_G": "",
 		"OPTION_H": "\n",
 		"OPTION_I": "echo 'asd'",
+		"OPTION_J": "line 1\nline 2",
+		"OPTION_K": "line one\nthis is \\'quoted\\'\none more line",
+		"OPTION_L": "line 1\nline 2",
+		"OPTION_M": "line one\nthis is \"quoted\"\none more line",
 	}
 
 	loadEnvAndCompareValues(t, Load, envFileName, expectedValues, noopPresets)
@@ -196,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) {
@@ -268,7 +285,34 @@ func TestExpanding(t *testing.T) {
 			}
 		})
 	}
+}
 
+func TestVariableStringValueSeparator(t *testing.T) {
+	input := "TEST_URLS=\"stratum+tcp://stratum.antpool.com:3333\nstratum+tcp://stratum.antpool.com:443\""
+	want := map[string]string{
+		"TEST_URLS": "stratum+tcp://stratum.antpool.com:3333\nstratum+tcp://stratum.antpool.com:443",
+	}
+	got, err := Parse(strings.NewReader(input))
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(got) != len(want) {
+		t.Fatalf(
+			"unexpected value:\nwant:\n\t%#v\n\ngot:\n\t%#v", want, got)
+	}
+
+	for k, wantVal := range want {
+		gotVal, ok := got[k]
+		if !ok {
+			t.Fatalf("key %q doesn't present in result", k)
+		}
+		if wantVal != gotVal {
+			t.Fatalf(
+				"mismatch in %q value:\nwant:\n\t%s\n\ngot:\n\t%s", k,
+				wantVal, gotVal)
+		}
+	}
 }
 
 func TestActualEnvVarsAreLeftAlone(t *testing.T) {
@@ -325,11 +369,11 @@ func TestParsing(t *testing.T) {
 	// expect(env('FOO="bar\nbaz"')).to eql('FOO' => "bar\nbaz")
 	parseAndCompare(t, `FOO="bar\nbaz"`, "FOO", "bar\nbaz")
 
-	// it 'parses varibales with "." in the name' do
+	// it 'parses variables with "." in the name' do
 	// expect(env('FOO.BAR=foobar')).to eql('FOO.BAR' => 'foobar')
 	parseAndCompare(t, "FOO.BAR=foobar", "FOO.BAR", "foobar")
 
-	// it 'parses varibales with several "=" in the value' do
+	// it 'parses variables with several "=" in the value' do
 	// expect(env('FOO=foobar=')).to eql('FOO' => 'foobar=')
 	parseAndCompare(t, "FOO=foobar=", "FOO", "foobar=")
 
@@ -337,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")
@@ -359,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")
@@ -370,40 +415,45 @@ 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)
 	}
 }
 
 func TestLinesToIgnore(t *testing.T) {
-	// it 'ignores empty lines' do
+	cases := map[string]struct {
-	// expect(env("\n \t  \nfoo=bar\n \nfizz=buzz")).to eql('foo' => 'bar', 'fizz' => 'buzz')
+		input string
-	if !isIgnoredLine("\n") {
+		want  string
-		t.Error("Line with nothing but line break wasn't ignored")
+	}{
+		"Line with nothing but line break": {
+			input: "\n",
+		},
+		"Line with nothing but windows-style line break": {
+			input: "\r\n",
+		},
+		"Line full of whitespace": {
+			input: "\t\t ",
+		},
+		"Comment": {
+			input: "# Comment",
+		},
+		"Indented comment": {
+			input: "\t # comment",
+		},
+		"non-ignored value": {
+			input: `export OPTION_B='\n'`,
+			want:  `export OPTION_B='\n'`,
+		},
 	}
 
-	if !isIgnoredLine("\r\n") {
+	for n, c := range cases {
-		t.Error("Line with nothing but windows-style line break wasn't ignored")
+		t.Run(n, func(t *testing.T) {
+			got := string(getStatementStart([]byte(c.input)))
+			if got != c.want {
+				t.Errorf("Expected:\t %q\nGot:\t %q", c.want, got)
 			}
-
+		})
-	if !isIgnoredLine("\t\t ") {
-		t.Error("Line full of whitespace wasn't ignored")
-	}
-
-	// it 'ignores comment lines' do
-	// expect(env("\n\n\n # HERE GOES FOO \nfoo=bar")).to eql('foo' => 'bar')
-	if !isIgnoredLine("# comment") {
-		t.Error("Comment wasn't ignored")
-	}
-
-	if !isIgnoredLine("\t#comment") {
-		t.Error("Indented comment wasn't ignored")
-	}
-
-	// make sure we're not getting false positives
-	if isIgnoredLine(`export OPTION_B='\n'`) {
-		t.Error("ignoring a perfectly valid line to parse")
 	}
 }
 
@@ -424,6 +474,20 @@ 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",
+	}
+
+	loadEnvAndCompareValues(t, Load, envFileName, expectedValues, noopPresets)
+}
+
 func TestWrite(t *testing.T) {
 	writeAndCompare := func(env string, expected string) {
 		envMap, _ := Unmarshal(env)
@@ -472,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

@@ -0,0 +1,278 @@
+package godotenv
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+const (
+	charComment       = '#'
+	prefixSingleQuote = '\''
+	prefixDoubleQuote = '"'
+
+	exportPrefix = "export"
+)
+
+func parseBytes(src []byte, out map[string]string) error {
+	src = bytes.Replace(src, []byte("\r\n"), []byte("\n"), -1)
+	cutset := src
+	for {
+		cutset = getStatementStart(cutset)
+		if cutset == nil {
+			// reached end of file
+			break
+		}
+
+		key, left, err := locateKeyName(cutset)
+		if err != nil {
+			return err
+		}
+
+		value, left, err := extractVarValue(left, out)
+		if err != nil {
+			return err
+		}
+
+		out[key] = value
+		cutset = left
+	}
+
+	return nil
+}
+
+// getStatementPosition returns position of statement begin.
+//
+// It skips any comment line or non-whitespace character.
+func getStatementStart(src []byte) []byte {
+	pos := indexOfNonSpaceChar(src)
+	if pos == -1 {
+		return nil
+	}
+
+	src = src[pos:]
+	if src[0] != charComment {
+		return src
+	}
+
+	// skip comment section
+	pos = bytes.IndexFunc(src, isCharFunc('\n'))
+	if pos == -1 {
+		return nil
+	}
+
+	return getStatementStart(src[pos:])
+}
+
+// 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)
+	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
+loop:
+	for i, char := range src {
+		rchar := rune(char)
+		if isSpace(rchar) {
+			continue
+		}
+
+		switch char {
+		case '=', ':':
+			// library also supports yaml-style value declaration
+			key = string(src[0:i])
+			offset = i + 1
+			break loop
+		case '_':
+		default:
+			// variable name should match [A-Za-z0-9_.]
+			if unicode.IsLetter(rchar) || unicode.IsNumber(rchar) || rchar == '.' {
+				continue
+			}
+
+			return "", nil, fmt.Errorf(
+				`unexpected character %q in variable name near %q`,
+				string(char), string(src))
+		}
+	}
+
+	if len(src) == 0 {
+		return "", nil, errors.New("zero length string")
+	}
+
+	// trim whitespace
+	key = strings.TrimRightFunc(key, unicode.IsSpace)
+	cutset = bytes.TrimLeftFunc(src[offset:], isSpace)
+	return key, cutset, nil
+}
+
+// extractVarValue extracts variable value and returns rest of slice
+func extractVarValue(src []byte, vars map[string]string) (value string, rest []byte, err error) {
+	quote, hasPrefix := hasQuotePrefix(src)
+	if !hasPrefix {
+		// 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
+			}
+		}
+
+		// 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
+	for i := 1; i < len(src); i++ {
+		if char := src[i]; char != quote {
+			continue
+		}
+
+		// skip escaped quote symbol (\" or \', depends on quote)
+		if prevChar := src[i-1]; prevChar == '\\' {
+			continue
+		}
+
+		// trim quotes
+		trimFunc := isCharFunc(rune(quote))
+		value = string(bytes.TrimLeftFunc(bytes.TrimRightFunc(src[0:i], trimFunc), trimFunc))
+		if quote == prefixDoubleQuote {
+			// unescape newlines for double quote (this is compat feature)
+			// and expand environment variables
+			value = expandVariables(expandEscapes(value), vars)
+		}
+
+		return value, src[i+1:], nil
+	}
+
+	// return formatted error if quoted string is not terminated
+	valEndIndex := bytes.IndexFunc(src, isCharFunc('\n'))
+	if valEndIndex == -1 {
+		valEndIndex = len(src)
+	}
+
+	return "", nil, fmt.Errorf("unterminated quoted value %s", src[:valEndIndex])
+}
+
+func expandEscapes(str string) string {
+	out := escapeRegex.ReplaceAllStringFunc(str, func(match string) string {
+		c := strings.TrimPrefix(match, `\`)
+		switch c {
+		case "n":
+			return "\n"
+		case "r":
+			return "\r"
+		default:
+			return match
+		}
+	})
+	return unescapeCharsRegex.ReplaceAllString(out, "$1")
+}
+
+func indexOfNonSpaceChar(src []byte) int {
+	return bytes.IndexFunc(src, func(r rune) bool {
+		return !unicode.IsSpace(r)
+	})
+}
+
+// hasQuotePrefix reports whether charset starts with single or double quote and returns quote character
+func hasQuotePrefix(src []byte) (prefix byte, isQuored bool) {
+	if len(src) == 0 {
+		return 0, false
+	}
+
+	switch prefix := src[0]; prefix {
+	case prefixDoubleQuote, prefixSingleQuote:
+		return prefix, true
+	default:
+		return 0, false
+	}
+}
+
+func isCharFunc(char rune) func(rune) bool {
+	return func(v rune) bool {
+		return v == char
+	}
+}
+
+// isSpace reports whether the rune is a space character but not line break character
+//
+// this differs from unicode.IsSpace, which also applies line break as space
+func isSpace(r rune) bool {
+	switch r {
+	case '\t', '\v', '\f', '\r', ' ', 0x85, 0xA0:
+		return true
+	}
+	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
+	})
+}

renovate.json

@@ -1,5 +0,0 @@
-{
-  "extends": [
-    "config:base"
-  ]
-}