adds dependency analysis

Author: juanvallejo

tools/depcheck/pkg/cmd/trace/trace.go

@@ -14,6 +14,8 @@ import (
 
 	"github.com/gonum/graph"
 	"github.com/gonum/graph/encoding/dot"
+
+	depgraph "github.com/openshift/origin/tools/depcheck/pkg/graph"
 )
 
 var traceImportsExample = `# create a dependency graph
@@ -30,6 +32,7 @@ type TraceImportsOpts struct {
 	excludes []string
 	filters  []string
 
+	Analyze          string
 	ExcludeFileName  string
 	CollapseFileName string
 
@@ -44,13 +47,15 @@ type TraceImportsFlags struct {
 	OutputFormat string
 	Exclude      string
 	Collapse     string
+	Analyze      string
 }
 
 func (o *TraceImportsFlags) ToOptions(out, errout io.Writer) (*TraceImportsOpts, error) {
 	return &TraceImportsOpts{
 		Roots:            o.Roots,
 		ExcludeFileName:  o.Exclude,
 		CollapseFileName: o.Collapse,
+		Analyze:          o.Analyze,
 
 		OutputFormat: o.OutputFormat,
 
@@ -91,6 +96,7 @@ func NewCmdTraceImports(parent string, out, errout io.Writer) *cobra.Command {
 	cmd.Flags().StringVarP(&flags.Exclude, "exclude", "e", "", "json file containing a list of import-paths of packages to recursively exclude when traversing the set of given entrypoints specified through --root.")
 	cmd.Flags().StringVarP(&flags.OutputFormat, "output", "o", "", "output generated dependency graph in specified format. One of: dot.")
 	cmd.Flags().StringVarP(&flags.Collapse, "collapse", "c", "", "json file containing a list of import-paths of packages to collapse sub-packages into.")
+	cmd.Flags().StringVarP(&flags.Analyze, "analyze", "a", "", "output a summary report on the dependency set of a given repository. Mutually exclusive with --output")
 	return cmd
 }
 
@@ -151,7 +157,10 @@ func (o *TraceImportsOpts) Validate() error {
 	if len(o.Roots) == 0 {
 		return errors.New("at least one root package must be provided")
 	}
-	if len(o.OutputFormat) != 0 && o.OutputFormat != "dot" {
+	if len(o.OutputFormat) > 0 && len(o.Analyze) > 0 {
+		return fmt.Errorf("--output and --analyze are mutually exclusive")
+	}
+	if len(o.OutputFormat) > 0 && o.OutputFormat != "dot" {
 		return fmt.Errorf("invalid output format provided: %s", o.OutputFormat)
 	}
 
@@ -209,6 +218,10 @@ func (o *TraceImportsOpts) Run() error {
 		return o.outputGraph(g)
 	}
 
+	if len(o.Analyze) > 0 {
+		return o.analyzeGraph(g)
+	}
+
 	return nil
 }
 
@@ -225,3 +238,118 @@ func (o *TraceImportsOpts) outputGraph(g graph.Directed) error {
 	fmt.Fprintf(o.Out, "%v\n", string(data))
 	return nil
 }
+
+// analyzeGraph receives a MutableDirectedGraph and outputs
+// - "Yours": a list of every node in the set unique to the dependency tree of a given target node.
+// - "Mine": a list of every node in the set unique to the dependency tree of the root nodes (set non-overlapping with given target node)
+// - "Ours": a list of every node in the overlapping set between the dependency tree of the root nodes and a given target node
+func (o *TraceImportsOpts) analyzeGraph(g *depgraph.MutableDirectedGraph) error {
+	remove, exists := g.NodeByName(o.Analyze)
+	if !exists {
+		return fmt.Errorf("unable to find package with import path %q", o.Analyze)
+	}
+
+	// determine existing orphans and roots
+	keep := []graph.Node{}
+	roots := []graph.Node{}
+	for _, n := range g.Nodes() {
+		node, ok := n.(*depgraph.Node)
+		if !ok {
+			continue
+		}
+
+		to := g.To(n)
+		from := g.From(n)
+
+		// found an existing orphaned node to exclude
+		if len(to) == 0 && len(from) == 0 {
+			continue
+		}
+
+		// found a root
+		if len(from) > 0 && len(to) == 0 {
+			roots = append(roots, n)
+			continue
+		}
+
+		// skip package we are analyzing
+		if node.UniqueName == o.Analyze {
+			continue
+		}
+
+		keep = append(keep, n)
+	}
+
+	// remove package we are analyzing from the graph
+	g.RemoveNode(remove)
+
+	// find nodes not reachable from our given roots
+	yours := findOrphans(g, roots, keep)
+
+	fmt.Printf("\"Yours\" packages exclusive to %q\n", o.Analyze)
+	for _, n := range yours {
+		pkg, ok := n.(*depgraph.Node)
+		if !ok {
+			continue
+		}
+
+		fmt.Printf("    - %s\n", pkg.UniqueName)
+	}
+
+	return nil
+}
+
+// findOrphans receives a set of root nodes and a set of child nodes and
+// returns the set of child nodes not reachable from any root node.
+func findOrphans(g *depgraph.MutableDirectedGraph, roots []graph.Node, nodes []graph.Node) []graph.Node {
+	orphans := []graph.Node{}
+
+	for _, n := range nodes {
+		isOrphan := true
+		for _, root := range roots {
+			if hasPathFromTo(g, root, n) {
+				isOrphan = false
+				break
+			}
+		}
+
+		if !isOrphan {
+			continue
+		}
+
+		orphans = append(orphans, n)
+	}
+
+	return orphans
+}
+
+// hasPathFromTo receives a node A and determines
+// if a node B can be reached from it.
+// Returns false if the source and destination are the same.
+func hasPathFromTo(g graph.Directed, A graph.Node, B graph.Node) bool {
+	if A.ID() == B.ID() {
+		return false
+	}
+	if !g.Has(A) || !g.Has(B) {
+		return false
+	}
+
+	seen := map[int]bool{}
+	unseen := []graph.Node{B}
+	for len(unseen) > 0 {
+		n := unseen[0]
+		unseen = unseen[1:]
+
+		if _, isSeen := seen[n.ID()]; isSeen {
+			continue
+		}
+		if n.ID() == A.ID() {
+			return true
+		}
+
+		seen[n.ID()] = true
+		unseen = append(unseen, g.To(n)...)
+	}
+
+	return false
+}