Use evaluated project root path

cmd/dep/init.go

@@ -116,9 +116,9 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 		return errors.Errorf("invalid state: manifest %q does not exist, but lock %q does", mf, lf)
 	}
 
-	ip, err := ctx.ImportForAbs(root)
+	ip, err := ctx.ImportPathForProject(p)
 	if err != nil {
-		return errors.Wrap(err, "root project import")
+		return errors.Wrap(err, "failed to determine import path for project")
 	}
 	p.ImportRoot = gps.ProjectRoot(ip)
 

context.go

@@ -111,7 +111,7 @@ func (c *Ctx) LoadProject() (*Project, error) {
 		return nil, err
 	}
 
-	ip, err := c.ImportForAbs(p.AbsRoot)
+	ip, err := c.ImportPathForProject(p)
 	if err != nil {
 		return nil, errors.Wrap(err, "root project import")
 	}
@@ -217,9 +217,14 @@ func (c *Ctx) detectGOPATH(path string) (string, error) {
 	return "", errors.Errorf("%s is not within a known GOPATH", path)
 }
 
-// ImportForAbs returns the import path for an absolute project path by trimming the
-// `$GOPATH/src/` prefix.  Returns an error for paths equal to, or without this prefix.
-func (c *Ctx) ImportForAbs(path string) (string, error) {
+// ImportPathForProject returns the import path for an absolute project path by trimming the
+// `GOPATH/src/` prefix.  Returns an error for paths equal to, or without this prefix.
+func (c *Ctx) ImportPathForProject(p *Project) (string, error) {
+	path := p.AbsRoot
+	if p.AbsRoot != p.ResolvedAbsRoot {
+		path = p.ResolvedAbsRoot
+	}
+
 	srcprefix := filepath.Join(c.GOPATH, "src") + string(filepath.Separator)
 	if fs.HasFilepathPrefix(path, srcprefix) {
 		if len(path) <= len(srcprefix) {

context_test.go

@@ -38,7 +38,13 @@ func TestCtx_ProjectImport(t *testing.T) {
 	for _, want := range importPaths {
 		fullpath := filepath.Join(depCtx.GOPATH, "src", want)
 		h.TempDir(filepath.Join("src", want))
-		got, err := depCtx.ImportForAbs(fullpath)
+
+		p := &Project{}
+		if err := p.SetRoot(fullpath); err != nil {
+			t.Fatal(err)
+		}
+		got, err := depCtx.ImportPathForProject(p)
+
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -48,15 +54,14 @@ func TestCtx_ProjectImport(t *testing.T) {
 	}
 
 	// test where it should return an error when directly within $GOPATH/src
-	got, err := depCtx.ImportForAbs(filepath.Join(depCtx.GOPATH, "src"))
-	if err == nil || !strings.Contains(err.Error(), "GOPATH/src") {
-		t.Fatalf("should have gotten an error for use directly in GOPATH/src, but got %s", got)
+	p := &Project{}
+	if err := p.SetRoot(filepath.Join(depCtx.GOPATH, "src")); err != nil {
+		t.Fatal(err)
 	}
+	got, err := depCtx.ImportPathForProject(p)
 
-	// test where it should return an error
-	got, err = depCtx.ImportForAbs("tra/la/la/la")
-	if err == nil {
-		t.Fatalf("should have gotten an error but did not for tra/la/la/la: %s", got)
+	if err == nil || !strings.Contains(err.Error(), "GOPATH/src") {
+		t.Fatalf("should have gotten an error for use directly in GOPATH/src, but got %s", got)
 	}
 }
 
@@ -301,7 +306,13 @@ func TestCaseInsentitiveGOPATH(t *testing.T) {
 	ip := "github.com/pkg/errors"
 	fullpath := filepath.Join(depCtx.GOPATH, "src", ip)
 	h.TempDir(filepath.Join("src", ip))
-	pr, err := depCtx.ImportForAbs(fullpath)
+
+	p := &Project{}
+	if err := p.SetRoot(fullpath); err != nil {
+		t.Fatal(err)
+	}
+	pr, err := depCtx.ImportPathForProject(p)
+
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -445,3 +456,36 @@ func TestDetectGOPATH(t *testing.T) {
 		}
 	}
 }
+
+func TestDetectProjectSymlinkedOutsideGOPATH(t *testing.T) {
+	h := test.NewHelper(t)
+	defer h.Cleanup()
+
+	h.TempDir("src")
+
+	h.Setenv("GOPATH", h.Path("."))
+	depCtx := &Ctx{GOPATH: h.Path(".")}
+
+	importPath := "ti/ga/fato/la/večera"
+	h.TempDir(filepath.Join("src", importPath))
+	h.TempDir("symlink/to/project")
+
+	symlinkSrc := h.OriginalPath(filepath.Join("src", importPath))
+	symlinkTarget := h.OriginalPath("symlink/to/project/sym")
+	if err := os.Symlink(symlinkSrc, symlinkTarget); err != nil {
+		t.Errorf("Error creating symlink from %s to %s: %s", symlinkSrc, symlinkTarget, err.Error())
+	}
+
+	p := Project{}
+	if err := p.SetRoot(symlinkSrc); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := depCtx.ImportPathForProject(&p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != importPath {
+		t.Fatalf("expected %s, got %s", importPath, got)
+	}
+}

internal/test/test.go

@@ -498,8 +498,21 @@ func (h *Helper) TempDir(path string) {
 }
 
 // Path returns the absolute pathname to file with the temporary
-// directory.
+// directory. Symlinks are evaluated.
 func (h *Helper) Path(name string) string {
+	path := h.OriginalPath(name)
+
+	// Ensure it's the absolute, symlink-less path we're returning
+	abs, err := filepath.EvalSymlinks(path)
+	if err != nil {
+		h.t.Fatalf("%+v", errors.Wrapf(err, "internal testsuite error: could not get absolute path for dir(%q)", path))
+	}
+	return abs
+}
+
+// OriginalPath returns the absolute pathname to file with the temporary
+// directory. Symlinks are NOT evaluated.
+func (h *Helper) OriginalPath(name string) string {
 	if h.tempdir == "" {
 		h.t.Fatalf("%+v", errors.Errorf("internal testsuite error: path(%q) with no tempdir", name))
 	}
@@ -511,12 +524,7 @@ func (h *Helper) Path(name string) string {
 		joined = filepath.Join(h.tempdir, name)
 	}
 
-	// Ensure it's the absolute, symlink-less path we're returning
-	abs, err := filepath.EvalSymlinks(joined)
-	if err != nil {
-		h.t.Fatalf("%+v", errors.Wrapf(err, "internal testsuite error: could not get absolute path for dir(%q)", joined))
-	}
-	return abs
+	return joined
 }
 
 // MustExist fails if path does not exist.