Add itemized feedback for dep resolution in init

- Compares manifest, lock and packageTree to separate direct and transitive
dependencies. Based on the constraints, logs them as feedback.
- Creates ConstraintFeedback struct to hold dep constraint data.
- Adds GetUsingFeedback() and GetLockingFeedback() functions to generate
feedback text.

Author: darkowlzz

cmd/dep/init.go

@@ -189,6 +189,9 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 
 	l.Memo = s.HashInputs()
 
+	// Log itemized feedback about the resolved dependencies
+	itemizedFeedback(m, l, pkgT)
+
 	internal.Vlogf("Writing manifest and lock files.")
 
 	sw, err := dep.NewSafeWriter(m, nil, l, dep.VendorAlways)
@@ -239,6 +242,45 @@ func hasImportPathPrefix(s, prefix string) bool {
 	return strings.HasPrefix(s, prefix+"/")
 }
 
+// itemizedFeedback itemizes resolved dependencies and logs the solution as
+// feedback.
+func itemizedFeedback(m *dep.Manifest, l *dep.Lock, pkgT pkgtree.PackageTree) {
+	// Algo:
+	// loop through lock projects
+	// 1. check in manifest for for same entry
+	// 2. if exists in manifest, it's direct dep, goes to manifest & lock
+	// 3. if not exists in manifest, check in pkgT
+	//	3.a. if exists in pkgT, it's direct dep, hint constraint, lock only
+	//	3.b. if not exists in pkgT, it's transitive dep, lock only
+	// 4. log feedback
+	for _, lock := range l.Projects() {
+		r, v, _ := gps.VersionComponentStrings(lock.Version())
+		projectPath := lock.Ident().ProjectRoot
+
+		cf := &internal.ConstraintFeedback{
+			Version:     v,
+			Revision:    r,
+			ProjectPath: projectPath,
+		}
+
+		if _, ok := m.Dependencies[projectPath]; ok {
+			// Direct dependency
+			cf.DependencyType = internal.DepTypeDirect
+			cf.ConstraintType = internal.ConsTypeConstraint
+		} else {
+			if _, ok := pkgT.Packages[string(projectPath)]; ok {
+				// Direct dependency, hint
+				cf.DependencyType = internal.DepTypeDirect
+				cf.ConstraintType = internal.ConsTypeHint
+			} else {
+				// Transitive dependency
+				cf.DependencyType = internal.DepTypeTransitive
+			}
+		}
+		cf.LogFeedback()
+	}
+}
+
 // getProjectPropertiesFromVersion takes a gps.Version and returns a proper
 // gps.ProjectProperties with Constraint value based on the provided version.
 func getProjectPropertiesFromVersion(v gps.Version) gps.ProjectProperties {

internal/internal.go

@@ -7,11 +7,21 @@ package internal
 import (
 	"fmt"
 	"os"
+
+	"github.com/golang/dep/gps"
 )
 
 // Verbose specifies if verbose logging is enabled.
 var Verbose bool
 
+// Constraint types
+const ConsTypeConstraint = "constraint"
+const ConsTypeHint = "hint"
+
+// Dependency types
+const DepTypeDirect = "direct dep"
+const DepTypeTransitive = "transitive dep"
+
 func Logln(args ...interface{}) {
 	fmt.Fprintln(os.Stderr, args...)
 }
@@ -27,3 +37,38 @@ func Vlogf(format string, args ...interface{}) {
 	}
 	Logf(format, args...)
 }
+
+// ConstraintFeedback holds project constraint feedback data
+type ConstraintFeedback struct {
+	Version, Revision, ConstraintType, DependencyType string
+	ProjectPath                                       gps.ProjectRoot
+}
+
+// LogFeedback logs the feedback
+func (cf ConstraintFeedback) LogFeedback() {
+	// "Using" feedback for direct dep
+	if cf.DependencyType == DepTypeDirect {
+		Logf(GetUsingFeedback(cf.Version, cf.ConstraintType, cf.DependencyType, string(cf.ProjectPath)))
+	}
+	// No "Locking" feedback for hints. "Locking" feedback only for constraint and
+	// transitive dep
+	if cf.ConstraintType != ConsTypeHint {
+		Logf(GetLockingFeedback(cf.Version, cf.Revision, cf.DependencyType, string(cf.ProjectPath)))
+	}
+}
+
+// GetUsingFeedback returns dependency using feedback string.
+// Example:
+// Using ^1.0.0 as constraint for direct dep github.com/foo/bar
+// Using 1b8edb3 as hint for direct dep github.com/bar/baz
+func GetUsingFeedback(version, consType, depType, projectPath string) string {
+	return fmt.Sprintf("Using %s as %s for %s %s", version, consType, depType, projectPath)
+}
+
+// GetLockingFeedback returns dependency locking feedback string.
+// Example:
+// Locking in v1.1.4 (bc29b4f) for direct dep github.com/foo/bar
+// Locking in master (436f39d) for transitive dep github.com/baz/qux
+func GetLockingFeedback(version, revision, depType, projectPath string) string {
+	return fmt.Sprintf("Locking in %s (%s) for %s %s", version, revision, depType, projectPath)
+}

internal/internal_test.go

@@ -0,0 +1,39 @@
+// 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 internal
+
+import (
+	"testing"
+)
+
+func TestGetConstraintString(t *testing.T) {
+	cases := []struct {
+		feedback string
+		want     string
+	}{
+		{
+			feedback: GetUsingFeedback("^1.0.0", ConsTypeConstraint, DepTypeDirect, "github.com/foo/bar"),
+			want:     "Using ^1.0.0 as constraint for direct dep github.com/foo/bar",
+		},
+		{
+			feedback: GetUsingFeedback("1b8edb3", ConsTypeHint, DepTypeDirect, "github.com/bar/baz"),
+			want:     "Using 1b8edb3 as hint for direct dep github.com/bar/baz",
+		},
+		{
+			feedback: GetLockingFeedback("v1.1.4", "bc29b4f", DepTypeDirect, "github.com/foo/bar"),
+			want:     "Locking in v1.1.4 (bc29b4f) for direct dep github.com/foo/bar",
+		},
+		{
+			feedback: GetLockingFeedback("master", "436f39d", DepTypeTransitive, "github.com/baz/qux"),
+			want:     "Locking in master (436f39d) for transitive dep github.com/baz/qux",
+		},
+	}
+
+	for _, c := range cases {
+		if c.want != c.feedback {
+			t.Fatalf("Feedbacks are not expected: \n\t(GOT) %v\n\t(WNT) %v", c.feedback, c.want)
+		}
+	}
+}