Remove gopath from analyzers & adapt new feedback

Author: darkowlzz

cmd/dep/gopath_scanner.go

@@ -25,19 +25,17 @@ type gopathScanner struct {
 	ctx        *dep.Ctx
 	directDeps map[string]bool
 	sm         gps.SourceManager
-	gopath     bool
 
 	pd    projectData
 	origM *dep.Manifest
 	origL *dep.Lock
 }
 
-func newGopathScanner(ctx *dep.Ctx, directDeps map[string]bool, sm gps.SourceManager, gopath bool) *gopathScanner {
+func newGopathScanner(ctx *dep.Ctx, directDeps map[string]bool, sm gps.SourceManager) *gopathScanner {
 	return &gopathScanner{
 		ctx:        ctx,
 		directDeps: directDeps,
 		sm:         sm,
-		gopath:     gopath,
 	}
 }
 
@@ -46,11 +44,6 @@ func newGopathScanner(ctx *dep.Ctx, directDeps map[string]bool, sm gps.SourceMan
 // constraints. Respect any initial constraints defined in the root manifest and
 // lock.
 func (g *gopathScanner) InitializeRootManifestAndLock(rootM *dep.Manifest, rootL *dep.Lock) error {
-	// No operation in network mode
-	if !g.gopath {
-		return nil
-	}
-
 	var err error
 
 	g.ctx.Err.Println("Searching GOPATH for projects...")
@@ -142,11 +135,6 @@ func (g *gopathScanner) overlay(rootM *dep.Manifest, rootL *dep.Lock) {
 }
 
 func (g *gopathScanner) FinalizeRootManifestAndLock(m *dep.Manifest, l *dep.Lock) {
-	// No operation in network mode
-	if !g.gopath {
-		return
-	}
-
 	// Iterate through the new projects in solved lock and add them to manifest
 	// if direct deps and log feedback for all the new projects.
 	for _, x := range l.Projects() {

cmd/dep/init.go

@@ -121,16 +121,18 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 	defer sm.Release()
 
 	// Initialize with imported data, then fill in the gaps using the GOPATH
-	rootAnalyzer := newRootAnalyzer(cmd.skipTools, cmd.gopath, ctx, directDeps, sm)
+	rootAnalyzer := newRootAnalyzer(cmd.skipTools, ctx, directDeps, sm)
 	m, l, err := rootAnalyzer.InitializeRootManifestAndLock(root, gps.ProjectRoot(cpr))
 	if err != nil {
 		return err
 	}
 
-	gs := newGopathScanner(ctx, directDeps, sm, cmd.gopath)
-	err = gs.InitializeRootManifestAndLock(m, l)
-	if err != nil {
-		return err
+	gs := newGopathScanner(ctx, directDeps, sm)
+	if cmd.gopath {
+		err = gs.InitializeRootManifestAndLock(m, l)
+		if err != nil {
+			return err
+		}
 	}
 
 	rootAnalyzer.skipTools = true // Don't import external config during solve for now
@@ -160,7 +162,9 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 	l = dep.LockFromSolution(soln)
 
 	rootAnalyzer.FinalizeRootManifestAndLock(m, l)
-	gs.FinalizeRootManifestAndLock(m, l)
+	if cmd.gopath {
+		gs.FinalizeRootManifestAndLock(m, l)
+	}
 
 	// Run gps.Prepare with appropriate constraint solutions from solve run
 	// to generate the final lock memo.

cmd/dep/root_analyzer.go

@@ -9,6 +9,7 @@ import (
 	"log"
 
 	"github.com/golang/dep"
+	fb "github.com/golang/dep/internal/feedback"
 	"github.com/golang/dep/internal/gps"
 	"github.com/pkg/errors"
 )
@@ -28,25 +29,22 @@ type importer interface {
 //   then external tools.
 type rootAnalyzer struct {
 	skipTools  bool
-	gopath     bool
 	ctx        *dep.Ctx
 	sm         gps.SourceManager
 	directDeps map[string]bool
 }
 
-func newRootAnalyzer(skipTools bool, gopath bool, ctx *dep.Ctx, directDeps map[string]bool, sm gps.SourceManager) *rootAnalyzer {
+func newRootAnalyzer(skipTools bool, ctx *dep.Ctx, directDeps map[string]bool, sm gps.SourceManager) *rootAnalyzer {
 	return &rootAnalyzer{
 		skipTools:  skipTools,
-		gopath:     gopath,
 		ctx:        ctx,
 		sm:         sm,
 		directDeps: directDeps,
 	}
 }
 
 func (a *rootAnalyzer) InitializeRootManifestAndLock(dir string, pr gps.ProjectRoot) (rootM *dep.Manifest, rootL *dep.Lock, err error) {
-	// Use importer tools only in gopath mode
-	if a.gopath && !a.skipTools {
+	if !a.skipTools {
 		rootM, rootL, err = a.importManifestAndLock(dir, pr, false)
 		if err != nil {
 			return
@@ -129,33 +127,38 @@ func (a *rootAnalyzer) DeriveManifestAndLock(dir string, pr gps.ProjectRoot) (gp
 }
 
 func (a *rootAnalyzer) FinalizeRootManifestAndLock(m *dep.Manifest, l *dep.Lock) {
-	if a.gopath {
-		// Remove dependencies from the manifest that aren't used
-		for pr := range m.Constraints {
-			var used bool
-			for _, y := range l.Projects() {
-				if pr == y.Ident().ProjectRoot {
-					used = true
-					break
-				}
-			}
-			if !used {
-				delete(m.Constraints, pr)
+	// Remove dependencies from the manifest that aren't used
+	for pr := range m.Constraints {
+		var used bool
+		for _, y := range l.Projects() {
+			if pr == y.Ident().ProjectRoot {
+				used = true
+				break
 			}
 		}
-	} else {
-		// Pick the direct dependencies from the solution lock and add to manifest.
-		// This is done in network mode to fill up the manifest constraints with
-		// the dependencies solved over the network.
-		for _, y := range l.Projects() {
-			pr := y.Ident().ProjectRoot
-			if _, ok := a.directDeps[string(pr)]; ok {
-				m.Constraints[pr] = getProjectPropertiesFromVersion(y.Version())
-				feedback(y.Version(), pr, fb.DepTypeDirect, a.ctx.Err)
+		if !used {
+			delete(m.Constraints, pr)
+		}
+	}
+	// Pick the direct dependencies from the solution lock and add to manifest.
+	// This is done to fill up the manifest constraints with the dependencies
+	// solved over the network.
+	for _, y := range l.Projects() {
+		var f *fb.ConstraintFeedback
+		pr := y.Ident().ProjectRoot
+		if _, ok := a.directDeps[string(pr)]; ok {
+			pp := getProjectPropertiesFromVersion(y.Version())
+			if pp.Constraint != nil {
+				m.Constraints[pr] = pp
+				pc := gps.ProjectConstraint{Ident: y.Ident(), Constraint: pp.Constraint}
+				f = fb.NewConstraintFeedback(pc, fb.DepTypeDirect)
 			} else {
-				feedback(y.Version(), pr, fb.DepTypeTransitive, a.ctx.Err)
+				f = fb.NewLockedProjectFeedback(y, fb.DepTypeDirect)
 			}
+		} else {
+			f = fb.NewLockedProjectFeedback(y, fb.DepTypeTransitive)
 		}
+		f.LogFeedback(a.ctx.Err)
 	}
 }