[Issue#9] - internal/graph: partition algorithm

.gitignore

@@ -0,0 +1 @@
+testdata/pkg/*

go.mod

@@ -7,6 +7,7 @@ require (
 	github.com/google/go-cmp v0.3.1
 	github.com/pkg/errors v0.8.1
 	github.com/stretchr/testify v1.3.0
-	golang.org/x/tools v0.0.0-20190826060629-95c3470cfb70
+	golang.org/x/tools v0.0.0-20190918214516-5a1a30219888
+	golang.org/x/tools/gopls v0.1.7 // indirect
 	honnef.co/go/tools v0.0.1-2019.2.3
 )

go.sum

@@ -26,6 +26,7 @@ golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKG
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -34,6 +35,12 @@ golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBn
 golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
 golang.org/x/tools v0.0.0-20190826060629-95c3470cfb70 h1:Cde4MUY6o3RgxpWu8/7xCjEW7SE22me73ix+NIXtV7s=
 golang.org/x/tools v0.0.0-20190826060629-95c3470cfb70/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190918214516-5a1a30219888 h1:ER45Jz0UDQ3e6em1lwXVwuPf96lvyQogb7m+gEbsoPg=
+golang.org/x/tools v0.0.0-20190918214516-5a1a30219888/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191014205221-18e3458ac98b h1:EsQHTYgcM562dq02r6y2Yt9VpvvLNIyNECx96XQeolA=
+golang.org/x/tools/gopls v0.1.7 h1:YwKf8t9h69++qCtVmc2q6fVuetFXmmu9LKoPMYLZid4=
+golang.org/x/tools/gopls v0.1.7/go.mod h1:PE3vTwT0ejw3a2L2fFgSJkxlEbA8Slbk+Lsy9hTmbG8=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=

ider.go

@@ -2,20 +2,21 @@ package splitfile
 
 import (
 	"fmt"
-	"go/token"
 	"go/types"
 )
 
 type Ider interface {
 	Pkg() *types.Package
 	Name() string
-	Pos() token.Pos
+	Type() types.Type
 }
 
 func Id(ider Ider) string {
+	id := fmt.Sprintf("%s %s", ider.Name(), ider.Type().String())
+
 	if ider.Pkg() != nil {
-		return fmt.Sprintf("%s %s %d", ider.Pkg().String(), ider.Name(), ider.Pos())
+		id = fmt.Sprintf("%s %s", ider.Pkg().String(), id)
 	}
 
-	return fmt.Sprintf("%s %d", ider.Name(), ider.Pos())
+	return id
 }

ider_test.go

@@ -1,43 +1,59 @@
 package splitfile
 
 import (
-	"go/token"
 	"go/types"
 	"testing"
 )
 
+type mockType struct {
+	s string
+}
+
+func (mt mockType) Underlying() types.Type { return nil }
+func (mt mockType) String() string         { return mt.s }
+
 type mockObject struct {
 	pkgFn  func() *types.Package
 	nameFn func() string
-	posFn  func() token.Pos
+	typeFn func() types.Type
 }
 
 func (mo mockObject) Pkg() *types.Package { return mo.pkgFn() }
 func (mo mockObject) Name() string        { return mo.nameFn() }
-func (mo mockObject) Pos() token.Pos      { return mo.posFn() }
+func (mo mockObject) Type() types.Type    { return mo.typeFn() }
 
 func TestId(t *testing.T) {
 	var tests = []struct {
 		name   string
 		want   string
 		pkgFn  func() *types.Package
 		nameFn func() string
-		posFn  func() token.Pos
+		typeFn func() types.Type
 	}{
 		{
-			name:   "no package",
-			want:   "name 1",
+			name:   "no_package",
+			want:   "name type",
 			pkgFn:  func() *types.Package { return nil },
 			nameFn: func() string { return "name" },
-			posFn:  func() token.Pos { return token.Pos(1) },
+			typeFn: func() types.Type { return mockType{s: "type"} },
+		},
+
+		{
+			name: "package_exists",
+			want: "package pkg (\"github.com/mccurdyc/path\") name type",
+			pkgFn: func() *types.Package {
+				return types.NewPackage("github.com/mccurdyc/path", "pkg")
+			},
+			nameFn: func() string { return "name" },
+			typeFn: func() types.Type { return mockType{s: "type"} },
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			o := mockObject{
 				pkgFn:  tt.pkgFn,
 				nameFn: tt.nameFn,
-				posFn:  tt.posFn,
+				typeFn: tt.typeFn,
 			}
 
 			got := Id(o)

internal/graph/graph.go

@@ -29,27 +29,30 @@ func (g Graph) ContainsNode(id string) bool {
 	return ok
 }
 
-// Partition returns a slice of nodes that should be split from a given source graph.
-//
-// TODO (Issue#8): actually add logic to properly partition
-func (g Graph) Partition() []*Node {
-	res := make([]*Node, 0, len(g))
-
-	// TODO: for now, just return every node
-	for _, v := range g {
-		res = append(res, v)
+// Roots finds the many possible roots in the graph.
+// The order of the graph traversal matters because if a parent is added _after_
+// a child, then that child node won't have the identified parent node.
+func (g Graph) Roots() []*Node {
+	roots := make([]*Node, 0, len(g))
+
+	for _, node := range g {
+		if len(node.Parents) == 0 {
+			roots = append(roots, node)
+		}
 	}
 
-	return res
+	return roots
 }
 
-func (g Graph) shouldPartition() bool {
-	if len(g) <= 1 {
-		return false
-	}
+// Edges returns all of the edges in the graph.
+func (g Graph) Edges() []WeightedEdge {
+	edges := make([]WeightedEdge, 0)
 
-	// TODO: thought; maybe eventually we store meta data about the graph
-	// (e.g., types of edges such as method and if there are zero methods, maybe we consider not partitioning)
+	for _, node := range g {
+		for _, edge := range node.Edges {
+			edges = append(edges, edge)
+		}
+	}
 
-	return true
+	return edges
 }

internal/graph/graph_test.go

@@ -31,15 +31,25 @@ func TestNew(t *testing.T) {
 }
 
 var (
+	parentNode = Node{ID: "parent", Edges: make(map[string]WeightedEdge), Parents: make(map[string]WeightedEdge)}
+
+	parentEdge = map[string]WeightedEdge{
+		"parent": WeightedEdge{
+			Weight: 1.0,
+			Dest:   &parentNode,
+		},
+	}
+
 	edgeB = map[string]WeightedEdge{
 		"b": WeightedEdge{
 			Weight: 1.0,
-			Dest:   &Node{ID: "b", Edges: make(map[string]WeightedEdge)},
+			Dest:   &Node{ID: "b", Edges: make(map[string]WeightedEdge), Parents: make(map[string]WeightedEdge)},
 		},
 	}
 
-	nodeAWithSingleEdgeB = Node{ID: "a", Edges: edgeB}
-	nodeCWithSingleEdgeB = Node{ID: "c", Edges: edgeB}
+	nodeAWithSingleEdgeB    = Node{ID: "a", Edges: edgeB, Parents: make(map[string]WeightedEdge)}
+	nodeCWithSingleEdgeB    = Node{ID: "c", Edges: edgeB, Parents: make(map[string]WeightedEdge)}
+	nodeCWithEdgeBAndParent = Node{ID: "c", Edges: edgeB, Parents: parentEdge}
 )
 
 func TestAddNode(t *testing.T) {
@@ -153,3 +163,36 @@ func TestContainsNode(t *testing.T) {
 		})
 	}
 }
+
+func TestRoots(t *testing.T) {
+	tests := []struct {
+		name  string
+		graph Graph
+		want  []*Node
+	}{
+		{
+			name:  "empty-graph",
+			graph: Graph(make(map[string]*Node)),
+			want:  []*Node{},
+		},
+
+		{
+			name: "one-root-node",
+			graph: Graph(map[string]*Node{
+				"parent": &parentNode,
+				"c":      &nodeCWithEdgeBAndParent,
+			}),
+			want: []*Node{&parentNode},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got := test.graph.Roots()
+
+			if diff := cmp.Diff(test.want, got); diff != "" {
+				t.Errorf("(%+v) Roots() mismatch (-want +got): \n%s", test.graph, diff)
+			}
+		})
+	}
+}

internal/graph/node.go

@@ -4,31 +4,47 @@ import (
 	"errors"
 )
 
+const defaultWeight = -1
+
 // WeightedEdge contains pointers to source and destination Nodes as well as
 // the assigned weight of the relationship.
 type WeightedEdge struct {
-	Weight float64
-	Dest   *Node
+	Weight       float64
+	Source, Dest *Node
+
+	ConnectednessStrength float64
+	MinPathStrengths      []float64 // used across multiple graph traversals
+
+	Partition bool
+	Distance  float64
 }
 
 // Node has an ID and a map of WeightedEdges or weighted relationships to other
 // Nodes.
 type Node struct {
-	ID     string
-	Object interface{}
-	Edges  map[string]WeightedEdge
+	ID      string
+	Object  interface{}
+	Edges   map[string]WeightedEdge
+	Parents map[string]WeightedEdge // TODO: may be able to delete this now
+
+	MinPathStrength float64
+	ShortestPathLen float64 // used for a single graph traversals
 }
 
 // NewNode creates a pointer to a new Node with ID, id, and initializes a map of Edges.
 func NewNode(id string, v interface{}) *Node {
 	return &Node{
-		ID:     id,
-		Object: v,
-		Edges:  make(map[string]WeightedEdge),
+		ID:              id,
+		Object:          v,
+		Edges:           make(map[string]WeightedEdge),
+		Parents:         make(map[string]WeightedEdge),
+		MinPathStrength: defaultWeight,
+		ShortestPathLen: defaultWeight,
 	}
 }
 
 // AddEdges adds weighted edges to a source node that signify relationships with other nodes.
+// Also adds parents to the destination node.
 func (n *Node) AddEdge(dest *Node, w float64) {
 	// prevent edge between node and itself
 	if n.ID == dest.ID {
@@ -37,8 +53,15 @@ func (n *Node) AddEdge(dest *Node, w float64) {
 
 	n.Edges[dest.ID] = WeightedEdge{
 		Weight: w,
+		Source: n,
 		Dest:   dest,
 	}
+
+	dest.Parents[n.ID] = WeightedEdge{
+		Weight: w,
+		Source: dest,
+		Dest:   n,
+	}
 }
 
 // ContainsEdge returns whether or not the graph contains an edge from source to dest.
@@ -60,5 +83,9 @@ func (n *Node) Valid() (bool, error) {
 		return false, errors.New("invalid node; edge map must be initialized")
 	}
 
+	if n.Parents == nil {
+		return false, errors.New("invalid node; parent map must be initialized")
+	}
+
 	return true, nil
 }

internal/graph/node_test.go

@@ -5,6 +5,26 @@ import (
 	"testing"
 )
 
+var (
+	nodeA = Node{
+		ID:              "a",
+		Object:          nil,
+		Edges:           map[string]WeightedEdge{},
+		Parents:         map[string]WeightedEdge{},
+		MinPathStrength: 1.0,
+		ShortestPathLen: 1.0,
+	}
+
+	nodeB = Node{
+		ID:              "b",
+		Object:          nil,
+		Edges:           map[string]WeightedEdge{},
+		Parents:         map[string]WeightedEdge{},
+		MinPathStrength: 1.0,
+		ShortestPathLen: 1.0,
+	}
+)
+
 func TestAddEdge(t *testing.T) {
 	tests := []struct {
 		name   string
@@ -15,21 +35,31 @@ func TestAddEdge(t *testing.T) {
 	}{
 		{
 			name:   "add-edge-w1.0-to-empty-slice-should-return-edges-with-single-value",
-			node:   &Node{"a", nil, map[string]WeightedEdge{}},
-			dest:   &Node{"b", nil, map[string]WeightedEdge{}},
+			node:   &nodeA,
+			dest:   &nodeB,
 			weight: 1.0,
-			want: Node{"a", nil, map[string]WeightedEdge{"b": WeightedEdge{
-				Weight: 1.0,
-				Dest:   &Node{ID: "b", Object: nil, Edges: map[string]WeightedEdge{}},
-			}}},
+			want: Node{
+				ID:     "a",
+				Object: nil,
+				Edges: map[string]WeightedEdge{
+					"b": WeightedEdge{
+						Weight: 1.0,
+						Source: &nodeA,
+						Dest:   &nodeB,
+					},
+				},
+				Parents:         map[string]WeightedEdge{},
+				MinPathStrength: 1.0,
+				ShortestPathLen: 1.0,
+			},
 		},
 
 		{
 			name:   "add-edge-to-same-node-does-nothing",
-			node:   &Node{"a", nil, map[string]WeightedEdge{}},
-			dest:   &Node{"a", nil, map[string]WeightedEdge{}},
+			node:   &nodeA,
+			dest:   &nodeA,
 			weight: 1.0,
-			want:   Node{"a", nil, map[string]WeightedEdge{}},
+			want:   nodeA,
 		},
 	}
 
@@ -38,7 +68,7 @@ func TestAddEdge(t *testing.T) {
 			tt.node.AddEdge(tt.dest, tt.weight)
 
 			if ok := reflect.DeepEqual(*tt.node, tt.want); !ok {
-				t.Errorf("(%+v) AddEdge(%+v, %f) - mismatch \n%+v", tt.node, tt.dest, tt.weight, tt.want)
+				t.Errorf("AddEdge() - mismatch \n\twant: %+v\n\tgot:%+v", tt.want, *tt.node)
 			}
 		})
 	}