Restore warning logging

analyzer.go

@@ -27,7 +27,7 @@ func (a Analyzer) DeriveManifestAndLock(path string, n gps.ProjectRoot) (gps.Man
 	}
 	defer f.Close()
 
-	m, err := readManifest(f)
+	m, err := readManifest(f, &Loggers{})
 	if err != nil {
 		return nil, nil, err
 	}

cmd/dep/ensure.go

@@ -101,9 +101,9 @@ type ensureCommand struct {
 	overrides stringSlice
 }
 
-func (cmd *ensureCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
+func (cmd *ensureCommand) Run(ctx *dep.Ctx, args []string) error {
 	if cmd.examples {
-		loggers.Err.Println(strings.TrimSpace(ensureExamples))
+		ctx.Loggers.Err.Println(strings.TrimSpace(ensureExamples))
 		return nil
 	}
 
@@ -120,8 +120,8 @@ func (cmd *ensureCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) err
 	defer sm.Release()
 
 	params := p.MakeParams()
-	if loggers.Verbose {
-		params.TraceLogger = loggers.Err
+	if ctx.Loggers.Verbose {
+		params.TraceLogger = ctx.Loggers.Err
 	}
 	params.RootPackageTree, err = pkgtree.ListPackages(p.AbsRoot, string(p.ImportRoot))
 	if err != nil {
@@ -135,7 +135,7 @@ func (cmd *ensureCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) err
 	if cmd.update {
 		applyUpdateArgs(args, &params)
 	} else {
-		err := applyEnsureArgs(loggers.Err, args, cmd.overrides, p, sm, &params)
+		err := applyEnsureArgs(ctx.Loggers.Err, args, cmd.overrides, p, sm, &params)
 		if err != nil {
 			return err
 		}
@@ -168,7 +168,7 @@ func (cmd *ensureCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) err
 		return err
 	}
 	if cmd.dryRun {
-		return sw.PrintPreparedActions(loggers.Out)
+		return sw.PrintPreparedActions(ctx.Loggers.Out)
 	}
 
 	return errors.Wrap(sw.Write(p.AbsRoot, sm, true), "grouped write of manifest, lock and vendor")

cmd/dep/hash_in.go

@@ -23,7 +23,7 @@ func (cmd *hashinCommand) Register(fs *flag.FlagSet) {}
 
 type hashinCommand struct{}
 
-func (hashinCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
+func (hashinCommand) Run(ctx *dep.Ctx, args []string) error {
 	p, err := ctx.LoadProject("")
 	if err != nil {
 		return err
@@ -51,6 +51,6 @@ func (hashinCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
 	if err != nil {
 		return errors.Wrap(err, "prepare solver")
 	}
-	loggers.Out.Println(gps.HashingInputsAsString(s))
+	ctx.Loggers.Out.Println(gps.HashingInputsAsString(s))
 	return nil
 }

cmd/dep/init.go

@@ -58,7 +58,7 @@ func trimPathPrefix(p1, p2 string) string {
 	return p1
 }
 
-func (cmd *initCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
+func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 	if len(args) > 1 {
 		return errors.Errorf("too many args (%d)", len(args))
 	}
@@ -94,15 +94,15 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error
 	if err != nil {
 		return errors.Wrap(err, "determineProjectRoot")
 	}
-	if loggers.Verbose {
-		loggers.Err.Printf("dep: Finding dependencies for %q...\n", cpr)
+	if ctx.Loggers.Verbose {
+		ctx.Loggers.Err.Printf("dep: Finding dependencies for %q...\n", cpr)
 	}
 	pkgT, err := pkgtree.ListPackages(root, cpr)
 	if err != nil {
 		return errors.Wrap(err, "gps.ListPackages")
 	}
-	if loggers.Verbose {
-		loggers.Err.Printf("dep: Found %d dependencies.\n", len(pkgT.Packages))
+	if ctx.Loggers.Verbose {
+		ctx.Loggers.Err.Printf("dep: Found %d dependencies.\n", len(pkgT.Packages))
 	}
 	sm, err := ctx.SourceManager()
 	if err != nil {
@@ -111,7 +111,7 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error
 	sm.UseDefaultSignalHandling()
 	defer sm.Release()
 
-	pd, err := getProjectData(ctx, loggers, pkgT, cpr, sm)
+	pd, err := getProjectData(ctx, pkgT, cpr, sm)
 	if err != nil {
 		return err
 	}
@@ -144,8 +144,8 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error
 	}
 
 	// Run solver with project versions found on disk
-	if loggers.Verbose {
-		loggers.Err.Println("dep: Solving...")
+	if ctx.Loggers.Verbose {
+		ctx.Loggers.Err.Println("dep: Solving...")
 	}
 	params := gps.SolveParameters{
 		RootDir:         root,
@@ -155,8 +155,8 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error
 		ProjectAnalyzer: dep.Analyzer{},
 	}
 
-	if loggers.Verbose {
-		params.TraceLogger = loggers.Err
+	if ctx.Loggers.Verbose {
+		params.TraceLogger = ctx.Loggers.Err
 	}
 
 	s, err := gps.Prepare(params, sm)
@@ -190,8 +190,8 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error
 
 	l.Memo = s.HashInputs()
 
-	if loggers.Verbose {
-		loggers.Err.Println("dep: Writing manifest and lock files.")
+	if ctx.Loggers.Verbose {
+		ctx.Loggers.Err.Println("dep: Writing manifest and lock files.")
 	}
 
 	sw, err := dep.NewSafeWriter(m, nil, l, dep.VendorAlways)
@@ -277,7 +277,7 @@ type projectData struct {
 	ondisk       map[gps.ProjectRoot]gps.Version // projects that were found on disk
 }
 
-func getProjectData(ctx *dep.Ctx, loggers *Loggers, pkgT pkgtree.PackageTree, cpr string, sm gps.SourceManager) (projectData, error) {
+func getProjectData(ctx *dep.Ctx, pkgT pkgtree.PackageTree, cpr string, sm gps.SourceManager) (projectData, error) {
 	constraints := make(gps.ProjectConstraints)
 	dependencies := make(map[gps.ProjectRoot][]string)
 	packages := make(map[string]bool)
@@ -290,7 +290,7 @@ func getProjectData(ctx *dep.Ctx, loggers *Loggers, pkgT pkgtree.PackageTree, cp
 		if err := sm.SyncSourceFor(gps.ProjectIdentifier{ProjectRoot: pr}); err != nil {
 			message = "Unable to cache"
 		}
-		loggers.Err.Printf("%s %s\n", message, pr)
+		ctx.Loggers.Err.Printf("%s %s\n", message, pr)
 		syncDepGroup.Done()
 	}
 
@@ -299,8 +299,8 @@ func getProjectData(ctx *dep.Ctx, loggers *Loggers, pkgT pkgtree.PackageTree, cp
 		return projectData{}, nil
 	}
 
-	if loggers.Verbose {
-		loggers.Err.Println("dep: Building dependency graph...")
+	if ctx.Loggers.Verbose {
+		ctx.Loggers.Err.Println("dep: Building dependency graph...")
 	}
 	// Exclude stdlib imports from the list returned from Flatten().
 	const omitStdlib = false
@@ -318,16 +318,16 @@ func getProjectData(ctx *dep.Ctx, loggers *Loggers, pkgT pkgtree.PackageTree, cp
 		syncDepGroup.Add(1)
 		go syncDep(pr, sm)
 
-		if loggers.Verbose {
-			loggers.Err.Printf("dep: Found import of %q, analyzing...\n", ip)
+		if ctx.Loggers.Verbose {
+			ctx.Loggers.Err.Printf("dep: Found import of %q, analyzing...\n", ip)
 		}
 
 		dependencies[pr] = []string{ip}
 		v, err := ctx.VersionInWorkspace(pr)
 		if err != nil {
 			notondisk[pr] = true
-			if loggers.Verbose {
-				loggers.Err.Printf("dep: Could not determine version for %q, omitting from generated manifest\n", pr)
+			if ctx.Loggers.Verbose {
+				ctx.Loggers.Err.Printf("dep: Could not determine version for %q, omitting from generated manifest\n", pr)
 			}
 			continue
 		}
@@ -336,8 +336,8 @@ func getProjectData(ctx *dep.Ctx, loggers *Loggers, pkgT pkgtree.PackageTree, cp
 		constraints[pr] = getProjectPropertiesFromVersion(v)
 	}
 
-	if loggers.Verbose {
-		loggers.Err.Printf("dep: Analyzing transitive imports...\n")
+	if ctx.Loggers.Verbose {
+		ctx.Loggers.Err.Printf("dep: Analyzing transitive imports...\n")
 	}
 	// Explore the packages we've found for transitive deps, either
 	// completing the lock or identifying (more) missing projects that we'll
@@ -357,8 +357,8 @@ func getProjectData(ctx *dep.Ctx, loggers *Loggers, pkgT pkgtree.PackageTree, cp
 	dft = func(pkg string) error {
 		switch colors[pkg] {
 		case white:
-			if loggers.Verbose {
-				loggers.Err.Printf("dep: Analyzing %q...\n", pkg)
+			if ctx.Loggers.Verbose {
+				ctx.Loggers.Err.Printf("dep: Analyzing %q...\n", pkg)
 			}
 			colors[pkg] = grey
 

cmd/dep/main.go

@@ -25,7 +25,7 @@ type command interface {
 	LongHelp() string       // "Foo the first bar meeting the following conditions..."
 	Register(*flag.FlagSet) // command-specific flags
 	Hidden() bool           // indicates whether the command should be hidden from help output
-	Run(*dep.Ctx, *Loggers, []string) error
+	Run(*dep.Ctx, []string) error
 }
 
 func main() {
@@ -141,22 +141,22 @@ func (c *Config) Run() (exitCode int) {
 				return
 			}
 
-			loggers := &Loggers{
+			loggers := &dep.Loggers{
 				Out:     log.New(c.Stdout, "", 0),
 				Err:     errLogger,
 				Verbose: *verbose,
 			}
 
 			// Set up the dep context.
-			ctx, err := dep.NewContext(c.WorkingDir, c.Env)
+			ctx, err := dep.NewContext(c.WorkingDir, c.Env, loggers)
 			if err != nil {
 				loggers.Err.Println(err)
 				exitCode = 1
 				return
 			}
 
 			// Run the command with the post-flag-processing args.
-			if err := cmd.Run(ctx, loggers, fs.Args()); err != nil {
+			if err := cmd.Run(ctx, fs.Args()); err != nil {
 				errLogger.Printf("%v\n", err)
 				exitCode = 1
 				return

cmd/dep/prune.go

@@ -36,7 +36,7 @@ func (cmd *pruneCommand) Hidden() bool      { return false }
 func (cmd *pruneCommand) Register(fs *flag.FlagSet) {
 }
 
-func (cmd *pruneCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
+func (cmd *pruneCommand) Run(ctx *dep.Ctx, args []string) error {
 	p, err := ctx.LoadProject("")
 	if err != nil {
 		return err
@@ -60,8 +60,8 @@ func (cmd *pruneCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) erro
 	params := p.MakeParams()
 	params.RootPackageTree = ptree
 
-	if loggers.Verbose {
-		params.TraceLogger = loggers.Err
+	if ctx.Loggers.Verbose {
+		params.TraceLogger = ctx.Loggers.Err
 	}
 
 	s, err := gps.Prepare(params, sm)

cmd/dep/remove.go

@@ -41,7 +41,7 @@ type removeCommand struct {
 	keepSource bool
 }
 
-func (cmd *removeCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
+func (cmd *removeCommand) Run(ctx *dep.Ctx, args []string) error {
 	p, err := ctx.LoadProject("")
 	if err != nil {
 		return err
@@ -89,7 +89,7 @@ func (cmd *removeCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) err
 				// not being able to detect the root for an import path that's
 				// actually in the import list is a deeper problem. However,
 				// it's not our direct concern here, so we just warn.
-				loggers.Err.Printf("dep: could not infer root for %q\n", pr)
+				ctx.Loggers.Err.Printf("dep: could not infer root for %q\n", pr)
 				continue
 			}
 			otherroots[pr] = true
@@ -104,7 +104,7 @@ func (cmd *removeCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) err
 		}
 
 		if len(rm) == 0 {
-			loggers.Err.Println("dep: nothing to do")
+			ctx.Loggers.Err.Println("dep: nothing to do")
 			return nil
 		}
 	} else {
@@ -162,8 +162,8 @@ func (cmd *removeCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) err
 	params := p.MakeParams()
 	params.RootPackageTree = pkgT
 
-	if loggers.Verbose {
-		params.TraceLogger = loggers.Err
+	if ctx.Loggers.Verbose {
+		params.TraceLogger = ctx.Loggers.Err
 	}
 	s, err := gps.Prepare(params, sm)
 	if err != nil {

cmd/dep/status.go

@@ -181,7 +181,7 @@ func (out *dotOutput) MissingHeader()                {}
 func (out *dotOutput) MissingLine(ms *MissingStatus) {}
 func (out *dotOutput) MissingFooter()                {}
 
-func (cmd *statusCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) error {
+func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error {
 	p, err := ctx.LoadProject("")
 	if err != nil {
 		return err
@@ -200,20 +200,20 @@ func (cmd *statusCommand) Run(ctx *dep.Ctx, loggers *Loggers, args []string) err
 		return errors.Errorf("not implemented")
 	case cmd.json:
 		out = &jsonOutput{
-			w: &logWriter{Logger: loggers.Out},
+			w: &logWriter{Logger: ctx.Loggers.Out},
 		}
 	case cmd.dot:
 		out = &dotOutput{
 			p: p,
 			o: cmd.output,
-			w: &logWriter{Logger: loggers.Out},
+			w: &logWriter{Logger: ctx.Loggers.Out},
 		}
 	default:
 		out = &tableOutput{
-			w: tabwriter.NewWriter(&logWriter{Logger: loggers.Out}, 0, 4, 2, ' ', 0),
+			w: tabwriter.NewWriter(&logWriter{Logger: ctx.Loggers.Out}, 0, 4, 2, ' ', 0),
 		}
 	}
-	return runStatusAll(loggers, out, p, sm)
+	return runStatusAll(ctx.Loggers, out, p, sm)
 }
 
 // A logWriter adapts a log.Logger to the io.Writer interface.
@@ -248,7 +248,7 @@ type MissingStatus struct {
 	MissingPackages []string
 }
 
-func runStatusAll(loggers *Loggers, out outputter, p *dep.Project, sm gps.SourceManager) error {
+func runStatusAll(loggers *dep.Loggers, out outputter, p *dep.Project, sm gps.SourceManager) error {
 	if p.Lock == nil {
 		// TODO if we have no lock file, do...other stuff
 		return nil

context.go

@@ -21,12 +21,13 @@ type Ctx struct {
 	GOPATH     string   // Selected Go path
 	GOPATHS    []string // Other Go paths
 	WorkingDir string
+	Loggers    *Loggers
 }
 
 // NewContext creates a struct with the project's GOPATH. It assumes
 // that of your "GOPATH"'s we want the one we are currently in.
-func NewContext(wd string, env []string) (*Ctx, error) {
-	ctx := &Ctx{WorkingDir: wd}
+func NewContext(wd string, env []string, loggers *Loggers) (*Ctx, error) {
+	ctx := &Ctx{WorkingDir: wd, Loggers: loggers}
 
 	GOPATH := getEnv(env, "GOPATH")
 	if GOPATH == "" {
@@ -144,7 +145,7 @@ func (c *Ctx) LoadProject(path string) (*Project, error) {
 	}
 	defer mf.Close()
 
-	p.Manifest, err = readManifest(mf)
+	p.Manifest, err = readManifest(mf, c.Loggers)
 	if err != nil {
 		return nil, errors.Errorf("error while parsing %s: %s", mp, err)
 	}

context_test.go

@@ -28,7 +28,7 @@ func TestNewContextNoGOPATH(t *testing.T) {
 		t.Fatal("failed to get work directory:", err)
 	}
 
-	c, err := NewContext(wd, os.Environ())
+	c, err := NewContext(wd, os.Environ(), &Loggers{})
 	if err == nil {
 		t.Fatal("error should not have been nil")
 	}

cmd/dep/loggers.go → loggers.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package main
+package dep
 
 import "log"