air-verse · caleb-fringer · Feb 19, 2025 · Mar 14, 2025 · Mar 17, 2025 · Mar 17, 2025
diff --git a/runner/config.go b/runner/config.go
@@ -289,12 +289,18 @@ func (c *Config) preprocess(args map[string]TomlInfo) error {
 		if err = os.Chdir(cwd); err != nil {
 			return err
 		}
-		c.Root = cwd
+		c.Root = "."
 	}
 	c.Root, err = expandPath(c.Root)
 	if err != nil {
 		return err
 	}
+	// Dereference the root node if it is a symbolic link
+	c.Root, err = derefLink(c.Root)
+	if err != nil {
+		return err
+	}
+
 	if c.TmpDir == "" {
 		c.TmpDir = "tmp"
 	}

diff --git a/runner/util.go b/runner/util.go
@@ -207,23 +207,57 @@ func (e *Engine) logWithLock(f func()) {
 	e.ll.Unlock()
 }
 
+// Checks if a directory is a symbolic link
+func isSymlink(path string) (bool, error) {
+	pathInfo, err := os.Lstat(path)
+	if err != nil {
+		return false, err
+	}
+	if (pathInfo.Mode() & os.ModeSymlink) != 0 {
+		return true, nil
+	}
+	return false, nil
+}
+
+// Dereferences a symbolic link to its relative path.
+// If the path is not a symlink, simply returns the path.
+// If the file does not exist, return the path and no err.
+func derefLink(path string) (string, error) {
+	ok, err := isSymlink(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return path, nil
+		}
+		return "", err
+	}
+	if !ok {
+		return path, nil
+	}
+
+	targetPath, err := filepath.EvalSymlinks(path)
+	if err != nil {
+		return "", err
+	}
+	absTargetPath, err := filepath.Abs(targetPath)
+	if err != nil {
+		return "", err
+	}
+	return absTargetPath, nil
+}
+
+// expandPath takes a path string (which may be absolute, relative, or tilde
+// expanded) and returns an absolute path to that file.
 func expandPath(path string) (string, error) {
 	if strings.HasPrefix(path, "~/") {
 		home := os.Getenv("HOME")
-		return home + path[1:], nil
+		path = filepath.Join(home, path[1:])
 	}
-	var err error
-	wd, err := os.Getwd()
+
+	absPath, err := filepath.Abs(path)
 	if err != nil {
 		return "", err
 	}
-	if path == "." {
-		return wd, nil
-	}
-	if strings.HasPrefix(path, "./") {
-		return wd + path[1:], nil
-	}
-	return path, nil
+	return absPath, nil
 }
 
 func isDir(path string) bool {

diff --git a/runner/util_test.go b/runner/util_test.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"path"
 	"path/filepath"
 	"reflect"
 	"runtime"
@@ -39,6 +40,21 @@ func TestIsDirFileNot(t *testing.T) {
 	}
 }
 
+func TestExpandPathWithRelPath(t *testing.T) {
+	relPath := path.Join("_testdata", "toml", ".air.toml")
+
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Error getting cwd: %v", err)
+	}
+
+	expandedPath, _ := expandPath(relPath)
+	expected := path.Join(wd, relPath)
+	if expandedPath != expected {
+		t.Errorf("expected %s got %s", expected, expandedPath)
+	}
+}
+
 func TestExpandPathWithDot(t *testing.T) {
 	path, _ := expandPath(".")
 	wd, _ := os.Getwd()
@@ -402,3 +418,52 @@ func TestFormatPath(t *testing.T) {
 		runTests(t, tests)
 	})
 }
+
+func TestIsSymlink(t *testing.T) {
+	type testCase struct {
+		name     string
+		path     string
+		expected bool
+	}
+
+	tmp := path.Join("_testdata/tmp")
+	_, err := os.Create(tmp)
+	defer os.Remove(tmp)
+
+	if err != nil {
+		t.Fatalf("Error creating temporary file for testing: %v", err)
+	}
+
+	tmpTarget := path.Join("_testdata/tmp.link")
+	err = os.Symlink(tmp, tmpTarget)
+	defer os.Remove(tmpTarget)
+	if err != nil {
+		t.Fatalf("Error creating symlink to cwd for testing: %v", err)
+	}
+
+	testCases := []testCase{
+		{
+			name:     "Symlink to current directory",
+			path:     tmpTarget,
+			expected: true,
+		},
+		{
+			name:     "Absolute path to current directory",
+			path:     tmp,
+			expected: false,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(*testing.T) {
+			ok, err := isSymlink(testCase.path)
+			if err != nil {
+				t.Errorf("isSymlink(%s): isSymlink returned an error: %v", testCase.path, err)
+			}
+
+			if ok != testCase.expected {
+				t.Errorf("isSymlink(%s): Expected %t, got %t", testCase.path, testCase.expected, ok)
+			}
+		})
+	}
+}