Dep status tree visualisation dot output

cmd/dep/graphviz.go

@@ -0,0 +1,114 @@
+// Copyright 2016 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 (
+	"bytes"
+	"fmt"
+	"hash/fnv"
+	"strings"
+)
+
+type graphviz struct {
+	ps []*gvnode
+	b  bytes.Buffer
+	h  map[string]uint32
+}
+
+type gvnode struct {
+	project  string
+	version  string
+	children []string
+}
+
+func (g graphviz) New() *graphviz {
+	ga := &graphviz{
+		ps: []*gvnode{},
+		h:  make(map[string]uint32),
+	}
+	return ga
+}
+
+func (g graphviz) output() bytes.Buffer {
+	g.b.WriteString("digraph { node [shape=box]; ")
+
+	for _, gvp := range g.ps {
+		g.h[gvp.project] = gvp.hash()
+
+		// Create node string
+		g.b.WriteString(fmt.Sprintf("%d [label=\"%s\"];", gvp.hash(), gvp.label()))
+	}
+
+	// Store relations to avoid duplication
+	rels := make(map[string]bool)
+
+	// Create relations
+	for _, dp := range g.ps {
+		for _, bsc := range dp.children {
+			for pr, hsh := range g.h {
+				if strings.HasPrefix(bsc, pr) && isPathPrefixOrEqual(pr, bsc) {
+					r := fmt.Sprintf("%d -> %d", g.h[dp.project], hsh)
+
+					if _, ex := rels[r]; !ex {
+						g.b.WriteString(r + "; ")
+						rels[r] = true
+					}
+
+				}
+			}
+		}
+	}
+
+	g.b.WriteString("}")
+
+	return g.b
+}
+
+func (g *graphviz) createNode(p, v string, c []string) {
+	pr := &gvnode{
+		project:  p,
+		version:  v,
+		children: c,
+	}
+
+	g.ps = append(g.ps, pr)
+}
+
+func (dp gvnode) hash() uint32 {
+	h := fnv.New32a()
+	h.Write([]byte(dp.project))
+	return h.Sum32()
+}
+
+func (dp gvnode) label() string {
+	label := []string{dp.project}
+
+	if dp.version != "" {
+		label = append(label, dp.version)
+	}
+
+	return strings.Join(label, "\n")
+}
+
+// Ensure that the literal string prefix is a path tree match and
+// guard against possibilities like this:
+//
+// github.com/sdboyer/foo
+// github.com/sdboyer/foobar/baz
+//
+// Verify that either the input is the same length as the match (in which
+// case we know they're equal), or that the next character is a "/". (Import
+// paths are defined to always use "/", not the OS-specific path separator.)
+func isPathPrefixOrEqual(pre, path string) bool {
+	prflen, pathlen := len(pre), len(path)
+	if pathlen == prflen+1 {
+		// this can never be the case
+		return false
+	}
+
+	// we assume something else (a trie) has done equality check up to the point
+	// of the prefix, so we just check len
+	return prflen == pathlen || strings.Index(path[prflen:], "/") == 0
+}

cmd/dep/status.go

@@ -60,6 +60,7 @@ type statusCommand struct {
 	detailed bool
 	json     bool
 	template string
+	output   string
 	dot      bool
 	old      bool
 	missing  bool
@@ -150,6 +151,35 @@ func (out *jsonOutput) MissingFooter() {
 	json.NewEncoder(out.w).Encode(out.missing)
 }
 
+type dotOutput struct {
+	w io.Writer
+	o string
+	g *graphviz
+	p *dep.Project
+}
+
+func (out *dotOutput) BasicHeader() {
+	out.g = new(graphviz).New()
+
+	ptree, _ := gps.ListPackages(out.p.AbsRoot, string(out.p.ImportRoot))
+	prm, _ := ptree.ToReachMap(true, false, false, nil)
+
+	out.g.createNode(string(out.p.ImportRoot), "", prm.Flatten(false))
+}
+
+func (out *dotOutput) BasicFooter() {
+	gvo := out.g.output()
+	fmt.Fprintf(out.w, gvo.String())
+}
+
+func (out *dotOutput) BasicLine(bs *BasicStatus) {
+	out.g.createNode(bs.ProjectRoot, bs.Version.String(), bs.Children)
+}
+
+func (out *dotOutput) MissingHeader()                {}
+func (out *dotOutput) MissingLine(ms *MissingStatus) {}
+func (out *dotOutput) MissingFooter()                {}
+
 func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error {
 	p, err := ctx.LoadProject("")
 	if err != nil {
@@ -171,6 +201,12 @@ func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error {
 		out = &jsonOutput{
 			w: os.Stdout,
 		}
+	case cmd.dot:
+		out = &dotOutput{
+			p: p,
+			o: cmd.output,
+			w: os.Stdout,
+		}
 	default:
 		out = &tableOutput{
 			w: tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', 0),
@@ -183,6 +219,7 @@ func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error {
 // in the summary/list status output mode.
 type BasicStatus struct {
 	ProjectRoot  string
+	Children     []string
 	Constraint   gps.Constraint
 	Version      gps.UnpairedVersion
 	Revision     gps.Revision
@@ -246,6 +283,20 @@ func runStatusAll(out outputter, p *dep.Project, sm *gps.SourceMgr) error {
 				PackageCount: len(proj.Packages()),
 			}
 
+			// Get children only for specific outputers
+			// in order to avoid slower status process
+			switch out.(type) {
+			case *dotOutput:
+				ptr, err := sm.ListPackages(proj.Ident(), proj.Version())
+
+				if err != nil {
+					return fmt.Errorf("analysis of %s package failed: %v", proj.Ident().ProjectRoot, err)
+				}
+
+				prm, _ := ptr.ToReachMap(true, false, false, nil)
+				bs.Children = prm.Flatten(false)
+			}
+
 			// Split apart the version from the lock into its constituent parts
 			switch tv := proj.Version().(type) {
 			case gps.UnpairedVersion: