Implement missing flag for dep status

cmd/dep/status.go

@@ -155,6 +155,9 @@ type outputter interface {
 	MissingHeader() error
 	MissingLine(*MissingStatus) error
 	MissingFooter() error
+	StatusMissingHeader() error
+	StatusMissingLine(gps.ProjectRoot) error
+	StatusMissingFooter() error
 }
 
 // Only a subset of the outputters should be able to output old statuses.
@@ -229,6 +232,20 @@ func (out *tableOutput) MissingFooter() error {
 	return out.w.Flush()
 }
 
+func (out *tableOutput) StatusMissingHeader() error {
+	_, err := fmt.Fprintln(out.w, "Missing dependencies (not present in lock):")
+	return err
+}
+
+func (out *tableOutput) StatusMissingLine(missingDep gps.ProjectRoot) error {
+	_, err := fmt.Fprintf(out.w, "  %v\n", missingDep)
+	return err
+}
+
+func (out *tableOutput) StatusMissingFooter() error {
+	return out.w.Flush()
+}
+
 func (out *tableOutput) OldHeader() error {
 	_, err := fmt.Fprintf(out.w, "PROJECT\tCONSTRAINT\tREVISION\tLATEST\n")
 	return err
@@ -250,11 +267,12 @@ func (out *tableOutput) OldFooter() error {
 }
 
 type jsonOutput struct {
-	w       io.Writer
-	basic   []*rawStatus
-	detail  []rawDetailProject
-	missing []*MissingStatus
-	old     []*rawOldStatus
+	w             io.Writer
+	basic         []*rawStatus
+	detail        []rawDetailProject
+	missing       []*MissingStatus
+	statusMissing []*StatusMissing
+	old           []*rawOldStatus
 }
 
 func (out *jsonOutput) BasicHeader() error {
@@ -304,6 +322,20 @@ func (out *jsonOutput) MissingFooter() error {
 	return json.NewEncoder(out.w).Encode(out.missing)
 }
 
+func (out *jsonOutput) StatusMissingHeader() error {
+	out.statusMissing = []*StatusMissing{}
+	return nil
+}
+
+func (out *jsonOutput) StatusMissingLine(missingDep gps.ProjectRoot) error {
+	out.statusMissing = append(out.statusMissing, &StatusMissing{missingDep})
+	return nil
+}
+
+func (out *jsonOutput) StatusMissingFooter() error {
+	return json.NewEncoder(out.w).Encode(out.statusMissing)
+}
+
 func (out *jsonOutput) OldHeader() error {
 	out.old = []*rawOldStatus{}
 	return nil
@@ -360,9 +392,12 @@ func (out *dotOutput) DetailLine(ds *DetailStatus) error {
 	return out.BasicLine(&ds.BasicStatus)
 }
 
-func (out *dotOutput) MissingHeader() error                { return nil }
-func (out *dotOutput) MissingLine(ms *MissingStatus) error { return nil }
-func (out *dotOutput) MissingFooter() error                { return nil }
+func (out *dotOutput) MissingHeader() error                               { return nil }
+func (out *dotOutput) MissingLine(ms *MissingStatus) error                { return nil }
+func (out *dotOutput) MissingFooter() error                               { return nil }
+func (out *dotOutput) StatusMissingHeader() error                         { return nil }
+func (out *dotOutput) StatusMissingLine(missingDep gps.ProjectRoot) error { return nil }
+func (out *dotOutput) StatusMissingFooter() error                         { return nil }
 
 type templateOutput struct {
 	w      io.Writer
@@ -426,6 +461,12 @@ func (out *templateOutput) MissingFooter() error { return nil }
 func (out *templateOutput) MissingLine(ms *MissingStatus) error {
 	return out.tmpl.Execute(out.w, ms)
 }
+func (out *templateOutput) StatusMissingHeader() error { return nil }
+func (out *templateOutput) StatusMissingLine(missingDep gps.ProjectRoot) error {
+	t := StatusMissing{missingDep}
+	return out.tmpl.Execute(out.w, t)
+}
+func (out *templateOutput) StatusMissingFooter() error { return nil }
 
 func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error {
 	if cmd.examples {
@@ -456,8 +497,6 @@ func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error {
 	var buf bytes.Buffer
 	var out outputter
 	switch {
-	case cmd.missing:
-		return errors.Errorf("not implemented")
 	case cmd.json:
 		out = &jsonOutput{
 			w: &buf,
@@ -506,6 +545,14 @@ func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error {
 		return err
 	}
 
+	if cmd.missing {
+		err := cmd.runStatusMissing(ctx, out, p)
+		if len(buf.String()) > 0 {
+			ctx.Out.Print(buf.String())
+		}
+		return err
+	}
+
 	hasMissingPkgs, errCount, err := cmd.runStatusAll(ctx, out, p, sm)
 	if err != nil {
 		switch err {
@@ -645,6 +692,48 @@ func (os OldStatus) marshalJSON() *rawOldStatus {
 	}
 }
 
+// runStatusMissing analyses the project for missing dependencies in lock file.
+func (cmd *statusCommand) runStatusMissing(ctx *dep.Ctx, out outputter, p *dep.Project) error {
+
+	ptree, err := p.ParseRootPackageTree()
+	if err != nil {
+		return err
+	}
+	rm, _ := ptree.ToReachMap(true, true, false, p.Manifest.IgnoredPackages())
+	external := rm.FlattenFn(paths.IsStandardImportPath)
+
+	var missingDeps []gps.ProjectRoot
+
+missingOuter:
+	for _, d := range external {
+		for _, lp := range p.Lock.Projects() {
+			if string(lp.Ident().ProjectRoot) == d {
+				continue missingOuter
+			}
+		}
+
+		missingDeps = append(missingDeps, gps.ProjectRoot(d))
+	}
+
+	if missingDeps != nil {
+		if err = out.StatusMissingHeader(); err != nil {
+			return err
+		}
+		for _, d := range missingDeps {
+			if err = out.StatusMissingLine(d); err != nil {
+				return err
+			}
+		}
+		if err = out.StatusMissingFooter(); err != nil {
+			return err
+		}
+	} else {
+		ctx.Err.Printf("No missing dependencies found.")
+	}
+
+	return nil
+}
+
 func (cmd *statusCommand) runOld(ctx *dep.Ctx, out oldOutputter, p *dep.Project, sm gps.SourceManager) error {
 	// While the network churns on ListVersions() requests, statically analyze
 	// code from the current project.
@@ -879,11 +968,18 @@ func (ds *DetailStatus) marshalJSON() *rawDetailProject {
 }
 
 // MissingStatus contains information about all the missing packages in a project.
+// Deprecated: Use StatusMissing instead, to-be-removed together with refactoring
+//             of runStatusAll
 type MissingStatus struct {
 	ProjectRoot     string
 	MissingPackages []string
 }
 
+// StatusMissing contains the root of missing packages in a project.
+type StatusMissing struct {
+	ProjectRoot gps.ProjectRoot
+}
+
 func (cmd *statusCommand) runStatusAll(ctx *dep.Ctx, out outputter, p *dep.Project, sm gps.SourceManager) (hasMissingPkgs bool, errCount int, err error) {
 	// While the network churns on ListVersions() requests, statically analyze
 	// code from the current project.

cmd/dep/status_test.go

@@ -5,6 +5,7 @@
 package main
 
 import (
+	"bufio"
 	"bytes"
 	"fmt"
 	"io/ioutil"
@@ -857,6 +858,144 @@ func TestValidateFlags(t *testing.T) {
 	}
 }
 
+func TestStatusMissing(t *testing.T) {
+
+	cases := []struct {
+		name               string
+		lock               dep.Lock
+		cmds               []statusCommand
+		wantTableStatus    string
+		wantJSONStatus     string
+		wantTemplateStatus string
+		wantErr            bool
+	}{
+		{
+			name: "no missing dependencies",
+			lock: dep.Lock{
+				P: []gps.LockedProject{
+					gps.NewLockedProject(
+						gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/boltdb/bolt")},
+						gps.NewVersion("v1.0.0"),
+						[]string{"."},
+					),
+					gps.NewLockedProject(
+						gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/sdboyer/dep-test")},
+						gps.NewVersion("v1.0.0"),
+						[]string{"."},
+					),
+					gps.NewLockedProject(
+						gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/sdboyer/deptestdos")},
+						gps.NewVersion("v1.0.0"),
+						[]string{"."},
+					),
+				},
+			},
+			cmds: []statusCommand{
+				statusCommand{missing: true}, //default for table output
+			},
+			wantTableStatus: "No missing dependencies found.\n",
+		},
+		{
+			name: "two missing dependencies",
+			lock: dep.Lock{
+				P: []gps.LockedProject{
+					gps.NewLockedProject(
+						gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot("github.com/sdboyer/deptestdos")},
+						gps.NewVersion("v1.0.0"),
+						[]string{"."},
+					),
+				},
+			},
+			cmds: []statusCommand{
+				statusCommand{missing: true}, //default for table output
+				statusCommand{missing: true, json: true},
+				statusCommand{missing: true, template: "Missing:{{.ProjectRoot}} "},
+			},
+			wantTableStatus: "Missing dependencies (not present in lock):\n" +
+				"  github.com/boltdb/bolt\n" +
+				"  github.com/sdboyer/dep-test\n",
+			wantJSONStatus:     `[{"ProjectRoot":"github.com/boltdb/bolt"},{"ProjectRoot":"github.com/sdboyer/dep-test"}]` + "\n",
+			wantTemplateStatus: "Missing:github.com/boltdb/bolt Missing:github.com/sdboyer/dep-test \n",
+		},
+	}
+
+	h := test.NewHelper(t)
+	defer h.Cleanup()
+
+	testdir := filepath.Join("src", "status_missing_test")
+	h.TempDir(testdir)
+	h.TempCopy(filepath.Join(testdir, "main.go"), filepath.Join("status", "missing", "main.go"))
+	testProjPath := h.Path(testdir)
+
+	var bufW bytes.Buffer
+	bufferWriter := bufio.NewWriter(&bufW)
+	bufferLogger := log.New(bufferWriter, "", 0)
+
+	ctx := &dep.Ctx{
+		GOPATH: testProjPath,
+		Out:    bufferLogger,
+		Err:    bufferLogger,
+	}
+
+	sm, err := ctx.SourceManager()
+	h.Must(err)
+	defer sm.Release()
+
+	p := new(dep.Project)
+	p.SetRoot(testProjPath)
+
+	var bufO bytes.Buffer
+	var out outputter
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+
+			for _, statusCmd := range c.cmds {
+				bufO.Reset()
+				bufW.Reset()
+
+				var wantStatus string
+				switch {
+				case statusCmd.json:
+					out = &jsonOutput{
+						w: &bufO,
+					}
+					wantStatus = c.wantJSONStatus
+				case statusCmd.template != "":
+					tmpl, _ := template.New("status").Parse(statusCmd.template)
+					out = &templateOutput{
+						w:    &bufO,
+						tmpl: tmpl,
+					}
+					wantStatus = c.wantTemplateStatus
+				default:
+					out = &tableOutput{
+						w: tabwriter.NewWriter(&bufO, 0, 4, 2, ' ', 0),
+					}
+					wantStatus = c.wantTableStatus
+				}
+
+				p.Manifest = &dep.Manifest{} // needed for empty Ignored packages string
+				p.Lock = &c.lock
+
+				err = statusCmd.runStatusMissing(ctx, out, p)
+				if len(bufO.String()) > 0 {
+					ctx.Out.Print(bufO.String())
+				}
+				bufferWriter.Flush()
+				actualStatus := bufW.String()
+
+				if err != nil && !c.wantErr {
+					t.Fatalf("unexpected errors while collecting constraints: %v", err)
+				}
+				if actualStatus != wantStatus {
+					t.Fatalf("unexpected missing status: \n\t(GOT): %v\n\t(WNT): %v", actualStatus, wantStatus)
+				}
+			}
+		})
+	}
+}
+
 func execStatusTemplate(w io.Writer, format string, data interface{}) error {
 	tpl, err := parseStatusTemplate(format)
 	if err != nil {

cmd/dep/testdata/status/missing/main.go

@@ -0,0 +1,14 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	_ "github.com/boltdb/bolt"
+	_ "github.com/sdboyer/dep-test"
+	_ "github.com/sdboyer/deptestdos"
+)
+
+// FooBar is a dummy type
+type FooBar int