Modify rootAnalyzer & gopathScanner for network mode

Make rootAnalyzer and gopathScanner -gopath flag aware and skip usual
operations when in network mode.

Author: darkowlzz

cmd/dep/gopath_scanner.go

@@ -25,17 +25,19 @@ 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) *gopathScanner {
+func newGopathScanner(ctx *dep.Ctx, directDeps map[string]bool, sm gps.SourceManager, gopath bool) *gopathScanner {
 	return &gopathScanner{
 		ctx:        ctx,
 		directDeps: directDeps,
 		sm:         sm,
+		gopath:     gopath,
 	}
 }
 
@@ -44,6 +46,11 @@ 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...")
@@ -130,6 +137,11 @@ 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

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/golang/dep"
-	fb "github.com/golang/dep/internal/feedback"
 	"github.com/golang/dep/internal/fs"
 	"github.com/golang/dep/internal/gps"
 	"github.com/golang/dep/internal/gps/paths"
@@ -121,52 +120,27 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 	sm.UseDefaultSignalHandling()
 	defer sm.Release()
 
-	// Create empty manifest and lock
-	m := &dep.Manifest{
-		Constraints: make(gps.ProjectConstraints),
-		Ovr:         make(gps.ProjectConstraints),
+	// Initialize with imported data, then fill in the gaps using the GOPATH
+	rootAnalyzer := newRootAnalyzer(cmd.skipTools, cmd.gopath, ctx, directDeps, sm)
+	m, l, err := rootAnalyzer.InitializeRootManifestAndLock(root, gps.ProjectRoot(cpr))
+	if err != nil {
+		return err
 	}
-	l := &dep.Lock{}
-
-	// Initialize rootAnalyzer and gopathScanner
-	rootAnalyzer := newRootAnalyzer(cmd.skipTools, ctx, directDeps, sm)
-	gs := newGopathScanner(ctx, directDeps, sm)
-
-	params := gps.SolveParameters{}
-
-	if cmd.gopath {
-		// Initialize with imported data, then fill in the gaps using the GOPATH
-		im, il, err := rootAnalyzer.InitializeRootManifestAndLock(root, gps.ProjectRoot(cpr))
-		if err != nil {
-			return err
-		}
-
-		if im != nil {
-			m = im
-		}
-		if il != nil {
-			l = il
-		}
-
-		err = gs.InitializeRootManifestAndLock(m, l)
-		if err != nil {
-			return err
-		}
 
-		rootAnalyzer.skipTools = true // Don't import external config during solve for now
+	gs := newGopathScanner(ctx, directDeps, sm, cmd.gopath)
+	err = gs.InitializeRootManifestAndLock(m, l)
+	if err != nil {
+		return err
 	}
 
-	params = gps.SolveParameters{
+	rootAnalyzer.skipTools = true // Don't import external config during solve for now
+
+	params := gps.SolveParameters{
 		RootDir:         root,
 		RootPackageTree: pkgT,
 		Manifest:        m,
 		Lock:            l,
-	}
-
-	if cmd.gopath {
-		params.ProjectAnalyzer = rootAnalyzer
-	} else {
-		params.ProjectAnalyzer = dep.Analyzer{}
+		ProjectAnalyzer: rootAnalyzer,
 	}
 
 	if ctx.Verbose {
@@ -185,21 +159,8 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 	}
 	l = dep.LockFromSolution(soln)
 
-	if cmd.gopath {
-		rootAnalyzer.FinalizeRootManifestAndLock(m, l)
-		gs.FinalizeRootManifestAndLock(m, l)
-	} else {
-		// Pick the direct dependencies from the above solution and add to manifest
-		for _, x := range l.Projects() {
-			pr := x.Ident().ProjectRoot
-			if _, ok := directDeps[string(pr)]; ok {
-				m.Constraints[pr] = getProjectPropertiesFromVersion(x.Version())
-				feedback(x.Version(), pr, fb.DepTypeDirect, ctx.Err)
-			} else {
-				feedback(x.Version(), pr, fb.DepTypeTransitive, ctx.Err)
-			}
-		}
-	}
+	rootAnalyzer.FinalizeRootManifestAndLock(m, l)
+	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

@@ -30,28 +30,41 @@ 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, ctx *dep.Ctx, directDeps map[string]bool, sm gps.SourceManager) *rootAnalyzer {
+func newRootAnalyzer(skipTools bool, gopath 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) {
-	if !a.skipTools {
+	// Use importer tools only in gopath mode
+	if a.gopath && !a.skipTools {
 		rootM, rootL, err = a.importManifestAndLock(dir, pr, false)
 		if err != nil {
 			return
 		}
 	}
 
+	if rootM == nil {
+		rootM = &dep.Manifest{
+			Constraints: make(gps.ProjectConstraints),
+			Ovr:         make(gps.ProjectConstraints),
+		}
+	}
+	if rootL == nil {
+		rootL = &dep.Lock{}
+	}
+
 	return
 }
 
@@ -114,17 +127,32 @@ func (a *rootAnalyzer) DeriveManifestAndLock(dir string, pr gps.ProjectRoot) (gp
 }
 
 func (a *rootAnalyzer) FinalizeRootManifestAndLock(m *dep.Manifest, l *dep.Lock) {
-	// 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 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)
 			}
 		}
-		if !used {
-			delete(m.Constraints, pr)
+	} 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)
+			} else {
+				feedback(y.Version(), pr, fb.DepTypeTransitive, a.ctx.Err)
+			}
 		}
 	}
 }