Add dotenv support

Author: flythenimbus

README.md

@@ -9,6 +9,7 @@ Goke is a build automation tool, similar to Make, but without the Makefile clutt
 * File watching with OS-level filesystem events
 * Support for global hooks
 * Intuitive environment variable declaration at any position in the configuration
+* Automatic `.env` file loading
 
 ## Installation
 
@@ -168,6 +169,25 @@ my-task:
 
 Use `${VAR}` to reference environment variables in commands, and `$(command)` to capture command output.
 
+### `.env` file support
+
+Goke automatically loads `.env` files if they exist in your project directory:
+
+1. `.env` — shared defaults
+2. `.env.local` — personal overrides (should be gitignored)
+
+Later files override earlier ones. You can also specify additional files explicitly:
+
+```yaml
+global:
+  env_file:
+    - .env.production
+  environment:
+    APP_URL: "${BASE_URL}/api"
+```
+
+Explicit files listed in `env_file` are loaded after the defaults, and must exist or Goke will return an error. Variables from `.env` files are available for use in `environment`, `run`, and `files` sections.
+
 ## Events
 
 Global hooks that run before/after tasks and individual commands:

go.mod

@@ -5,6 +5,7 @@ go 1.25.0
 require (
 	github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815
 	github.com/fsnotify/fsnotify v1.9.0
+	github.com/joho/godotenv v1.5.1
 	github.com/stretchr/testify v1.11.1
 	github.com/theckman/yacspin v0.13.12
 	gopkg.in/yaml.v3 v3.0.1

go.sum

@@ -10,6 +10,8 @@ github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S
 github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
 github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
 github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

internal/dotenv.go

@@ -0,0 +1,36 @@
+package internal
+
+import (
+	"fmt"
+
+	"github.com/joho/godotenv"
+)
+
+// Default .env files loaded automatically in order (later overrides earlier).
+var defaultEnvFiles = []string{".env", ".env.local"}
+
+// LoadDotenvFiles loads environment variables from .env files.
+// It first loads the default files (.env, .env.local) if they exist,
+// then loads any explicitly specified files from the config.
+// Explicit files must exist or an error is returned.
+// Later files override earlier ones.
+func LoadDotenvFiles(explicit []string, fs FileSystem) error {
+	for _, f := range defaultEnvFiles {
+		if fs.FileExists(f) {
+			if err := godotenv.Overload(f); err != nil {
+				return fmt.Errorf("failed to load %s: %w", f, err)
+			}
+		}
+	}
+
+	for _, f := range explicit {
+		if !fs.FileExists(f) {
+			return fmt.Errorf("env_file %q not found", f)
+		}
+		if err := godotenv.Overload(f); err != nil {
+			return fmt.Errorf("failed to load %s: %w", f, err)
+		}
+	}
+
+	return nil
+}

internal/dotenv_test.go

@@ -0,0 +1,103 @@
+package internal
+
+import (
+	"os"
+	"testing"
+
+	"github.com/parabrola/goke/internal/tests"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func dotenvMockNoDefaults(t *testing.T) *tests.FileSystem {
+	fsMock := tests.NewFileSystem(t)
+	fsMock.On("FileExists", ".env").Return(false)
+	fsMock.On("FileExists", ".env.local").Return(false)
+	return fsMock
+}
+
+func TestLoadDotenvFilesSkipsMissingDefaults(t *testing.T) {
+	fsMock := dotenvMockNoDefaults(t)
+
+	err := LoadDotenvFiles(nil, fsMock)
+	require.NoError(t, err)
+}
+
+func TestLoadDotenvFilesExplicitFileMustExist(t *testing.T) {
+	fsMock := dotenvMockNoDefaults(t)
+	fsMock.On("FileExists", ".env.production").Return(false)
+
+	err := LoadDotenvFiles([]string{".env.production"}, fsMock)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), ".env.production")
+	assert.Contains(t, err.Error(), "not found")
+}
+
+func TestLoadDotenvFilesLoadsExplicitFiles(t *testing.T) {
+	os.Unsetenv("DOTENV_TEST_A")
+	os.Unsetenv("DOTENV_TEST_B")
+
+	dir := t.TempDir()
+	envPath := dir + "/base.env"
+	localPath := dir + "/local.env"
+
+	os.WriteFile(envPath, []byte("DOTENV_TEST_A=base\nDOTENV_TEST_B=original\n"), 0644)
+	os.WriteFile(localPath, []byte("DOTENV_TEST_B=overridden\n"), 0644)
+
+	fsMock := dotenvMockNoDefaults(t)
+	fsMock.On("FileExists", envPath).Return(true)
+	fsMock.On("FileExists", localPath).Return(true)
+
+	err := LoadDotenvFiles([]string{envPath, localPath}, fsMock)
+	require.NoError(t, err)
+
+	assert.Equal(t, "base", os.Getenv("DOTENV_TEST_A"))
+	assert.Equal(t, "overridden", os.Getenv("DOTENV_TEST_B"))
+}
+
+func TestLoadDotenvFilesLaterOverridesEarlier(t *testing.T) {
+	os.Unsetenv("DOTENV_OVERRIDE")
+
+	dir := t.TempDir()
+	first := dir + "/first.env"
+	second := dir + "/second.env"
+
+	os.WriteFile(first, []byte("DOTENV_OVERRIDE=first\n"), 0644)
+	os.WriteFile(second, []byte("DOTENV_OVERRIDE=second\n"), 0644)
+
+	fsMock := dotenvMockNoDefaults(t)
+	fsMock.On("FileExists", first).Return(true)
+	fsMock.On("FileExists", second).Return(true)
+
+	err := LoadDotenvFiles([]string{first, second}, fsMock)
+	require.NoError(t, err)
+
+	assert.Equal(t, "second", os.Getenv("DOTENV_OVERRIDE"))
+}
+
+func TestParseGlobalWithEnvFile(t *testing.T) {
+	os.Unsetenv("FROM_DOTENV")
+
+	dir := t.TempDir()
+	envPath := dir + "/.env.custom"
+	os.WriteFile(envPath, []byte("FROM_DOTENV=it_works\n"), 0644)
+
+	config := `
+global:
+  env_file:
+    - ` + envPath + `
+  environment:
+    COMBINED: "${FROM_DOTENV}_and_more"
+`
+	fsMock := mockCacheDoesNotExist(t)
+	fsMock.On("FileExists", ".env").Return(false)
+	fsMock.On("FileExists", ".env.local").Return(false)
+	fsMock.On("FileExists", envPath).Return(true)
+
+	parser := NewParser(config, &clearCacheOpts, fsMock)
+
+	err := parser.parseGlobal()
+	require.NoError(t, err)
+
+	assert.Equal(t, "it_works", os.Getenv("FROM_DOTENV"))
+}

internal/parser.go

@@ -33,8 +33,9 @@ type Task struct {
 
 type Global struct {
 	Shared struct {
-		Env    map[string]string `yaml:"environment,omitempty"`
-		Events struct {
+		EnvFile []string          `yaml:"env_file,omitempty"`
+		Env     map[string]string `yaml:"environment,omitempty"`
+		Events  struct {
 			BeforeEachRun  []string `yaml:"before_each_run,omitempty"`
 			AfterEachRun   []string `yaml:"after_each_run,omitempty"`
 			BeforeEachTask []string `yaml:"before_each_task,omitempty"`
@@ -203,6 +204,10 @@ func (p *parser) parseGlobal() error {
 		return err
 	}
 
+	if err := LoadDotenvFiles(g.Shared.EnvFile, p.fs); err != nil {
+		return err
+	}
+
 	vars, err := cli.SetEnvVariables(g.Shared.Env)
 	if err != nil {
 		return err

internal/parser_test.go

@@ -97,6 +97,8 @@ func TestTaskParsing(t *testing.T) {
 
 func TestGlobalsParsing(t *testing.T) {
 	fsMock := mockCacheDoesNotExist(t)
+	fsMock.On("FileExists", ".env").Return(false)
+	fsMock.On("FileExists", ".env.local").Return(false)
 	parser := NewParser(tests.YamlConfigStub, &clearCacheOpts, fsMock)
 
 	parser.parseGlobal()