Fix issues with the new init algo implementation

- Avoid running solver twice and use gps.Prepare to get the final lock.
- Improve manifest constraints population based on the algo in the new spec doc.

Author: darkowlzz

cmd/dep/init.go

@@ -137,7 +137,24 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 
 	// Run solver with project versions found on disk
 	internal.Vlogf("Solving...")
-	soln, err := getSolverSolution(root, pkgT, m, l, sm)
+	params := gps.SolveParameters{
+		RootDir:         root,
+		RootPackageTree: pkgT,
+		Manifest:        m,
+		Lock:            l,
+		ProjectAnalyzer: dep.Analyzer{},
+	}
+
+	if *verbose {
+		params.Trace = true
+		params.TraceLogger = log.New(os.Stderr, "", 0)
+	}
+	s, err := gps.Prepare(params, sm)
+	if err != nil {
+		return errors.Wrap(err, "prepare solver")
+	}
+
+	soln, err := s.Solve()
 	if err != nil {
 		handleAllTheFailuresOfTheWorld(err)
 		return err
@@ -154,14 +171,14 @@ func (cmd *initCommand) Run(ctx *dep.Ctx, args []string) error {
 		}
 	}
 
-	// Run solver again with appropriate constraint solutions from previous run
-	// to generate the final lock.
-	soln, err = getSolverSolution(root, pkgT, m, l, sm)
+	// Run gps.Prepare with appropriate constraint solutions from solve run
+	// to generate the final lock memo.
+	s, err = gps.Prepare(params, sm)
 	if err != nil {
-		handleAllTheFailuresOfTheWorld(err)
-		return err
+		return errors.Wrap(err, "prepare solver")
 	}
-	l = dep.LockFromInterface(soln)
+
+	l.Memo = s.HashInputs()
 
 	internal.Vlogf("Writing manifest and lock files.")
 
@@ -210,43 +227,45 @@ func hasImportPathPrefix(s, prefix string) bool {
 	return strings.HasPrefix(s, prefix+"/")
 }
 
+// getVersionConstituents extracts version constituents
+func getVersionConstituents(v gps.Version) (version, revision string) {
+	switch tv := v.(type) {
+	case gps.UnpairedVersion:
+		version = tv.String()
+	case gps.Revision:
+		revision = tv.String()
+	case gps.PairedVersion:
+		version = tv.Unpair().String()
+		revision = tv.Underlying().String()
+	}
+
+	return version, revision
+}
+
 // getProjectPropertiesFromVersion takes a gps.Version and returns a proper
-// gps.ProjectProperties with Constraint value based on the version type.
+// gps.ProjectProperties with Constraint value based on the provided version.
 func getProjectPropertiesFromVersion(v gps.Version) gps.ProjectProperties {
 	pp := gps.ProjectProperties{}
+
+	// constituent version and revision. Ignoring revison for manifest.
+	cv, _ := getVersionConstituents(v)
+
 	switch v.Type() {
-	case gps.IsBranch, gps.IsVersion, gps.IsRevision:
-		pp.Constraint = v
+	case gps.IsBranch:
+		pp.Constraint = gps.NewBranch(cv)
+	case gps.IsVersion:
+		pp.Constraint = gps.NewVersion(cv)
 	case gps.IsSemver:
-		c, _ := gps.NewSemverConstraint("^" + v.String())
+		// TODO: remove "^" when https://github.com/golang/dep/issues/225 is ready.
+		c, _ := gps.NewSemverConstraint("^" + cv)
 		pp.Constraint = c
+	case gps.IsRevision:
+		pp.Constraint = nil
 	}
 
 	return pp
 }
 
-// getSolverSolution runs gps solver and returns a solution.
-func getSolverSolution(root string, pkgT pkgtree.PackageTree, m *dep.Manifest, l *dep.Lock, sm *gps.SourceMgr) (gps.Solution, error) {
-	params := gps.SolveParameters{
-		RootDir:         root,
-		RootPackageTree: pkgT,
-		Manifest:        m,
-		Lock:            l,
-		ProjectAnalyzer: dep.Analyzer{},
-	}
-
-	if *verbose {
-		params.Trace = true
-		params.TraceLogger = log.New(os.Stderr, "", 0)
-	}
-	s, err := gps.Prepare(params, sm)
-	if err != nil {
-		return nil, errors.Wrap(err, "prepare solver")
-	}
-
-	return s.Solve()
-}
-
 type projectData struct {
 	constraints  gps.ProjectConstraints          // constraints that could be found
 	dependencies map[gps.ProjectRoot][]string    // all dependencies (imports) found by project root