parse.go

package envconfig

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

// Parse reads a .env-style file at path and returns its contents as a map of
// key/value pairs.
//
// The file format supports:
//
//   - Full-line comments: any line whose first non-whitespace character is
//     '#' is skipped entirely.
//   - Blank lines: lines containing only whitespace are skipped.
//   - "KEY=value" assignments. The key is trimmed of surrounding
//     whitespace. Everything after the first '=' is treated as the value.
//   - Double-quoted values ("like this"): surrounding quotes are stripped
//     and a small set of backslash escapes are processed inside the value:
//     \n (newline), \t (tab), \r (carriage return), \" (literal double
//     quote), \\ (literal backslash). Any other backslash sequence is left
//     as-is (the backslash and following character are both kept).
//   - Single-quoted values ('like this'): surrounding quotes are stripped.
//     No escape processing is performed inside single quotes -- the
//     content between the quotes is used verbatim, matching common shell
//     and dotenv conventions.
//   - Unquoted values: the value is trimmed of surrounding whitespace.
//
// Lines that do not contain an '=' are ignored. Parse does not mutate the
// process environment; it only returns the parsed key/value pairs. Callers
// that want the values to fall back to OS environment variables should use
// Load, which implements that precedence explicitly.
func Parse(path string) (map[string]string, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, fmt.Errorf("envconfig: failed to open %q: %w", path, err)
	}
	defer f.Close()

	result := make(map[string]string)

	scanner := bufio.NewScanner(f)
	lineNo := 0
	for scanner.Scan() {
		lineNo++
		line := scanner.Text()

		trimmed := strings.TrimSpace(line)
		if trimmed == "" {
			continue
		}
		if strings.HasPrefix(trimmed, "#") {
			continue
		}

		eq := strings.Index(trimmed, "=")
		if eq < 0 {
			// Not a KEY=value line; ignore it rather than failing, so
			// stray lines don't break otherwise-valid files.
			continue
		}

		key := strings.TrimSpace(trimmed[:eq])
		if key == "" {
			continue
		}
		rawValue := strings.TrimSpace(trimmed[eq+1:])

		value, err := parseValue(rawValue)
		if err != nil {
			return nil, fmt.Errorf("envconfig: %q line %d: %w", path, lineNo, err)
		}

		result[key] = value
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("envconfig: failed to read %q: %w", path, err)
	}

	return result, nil
}

// parseValue interprets the raw right-hand side of a KEY=value assignment,
// handling quoted and unquoted forms.
func parseValue(raw string) (string, error) {
	if len(raw) >= 2 {
		first := raw[0]
		last := raw[len(raw)-1]

		switch {
		case first == '"' && last == '"':
			return unescapeDouble(raw[1 : len(raw)-1]), nil
		case first == '\'' && last == '\'':
			return raw[1 : len(raw)-1], nil
		}
	}

	return raw, nil
}

// unescapeDouble processes a small set of backslash escapes inside a
// double-quoted value: \n, \t, \r, \", \\. Any other backslash sequence is
// left untouched (both the backslash and the following rune are kept).
func unescapeDouble(s string) string {
	var b strings.Builder
	b.Grow(len(s))

	runes := []rune(s)
	for i := 0; i < len(runes); i++ {
		c := runes[i]
		if c != '\\' || i == len(runes)-1 {
			b.WriteRune(c)
			continue
		}

		next := runes[i+1]
		switch next {
		case 'n':
			b.WriteRune('\n')
			i++
		case 't':
			b.WriteRune('\t')
			i++
		case 'r':
			b.WriteRune('\r')
			i++
		case '"':
			b.WriteRune('"')
			i++
		case '\\':
			b.WriteRune('\\')
			i++
		default:
			b.WriteRune(c)
		}
	}

	return b.String()
}