First pass

Author: avidal

cmd/dep/gb_importer.go

@@ -0,0 +1,157 @@
+// Copyright 2017 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 (
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/golang/dep"
+	fb "github.com/golang/dep/internal/feedback"
+	"github.com/golang/dep/internal/gps"
+	"github.com/pkg/errors"
+)
+
+// gbImporter imports gb configuration into the dep configuration format.
+type gbImporter struct {
+	manifest gbManifest
+	logger   *log.Logger
+	verbose  bool
+	sm       gps.SourceManager
+}
+
+func newGbImporter(logger *log.Logger, verbose bool, sm gps.SourceManager) *gbImporter {
+	return &gbImporter{
+		logger:  logger,
+		verbose: verbose,
+		sm:      sm,
+	}
+}
+
+// gbManifest represents the manifest file for GB projects
+type gbManifest struct {
+	Version      int            `json:"version"`
+	Dependencies []gbDependency `json:"dependencies"`
+}
+
+type gbDependency struct {
+	Importpath string `json:"importpath"`
+	Repository string `json:"repository"`
+
+	Revision string `json:"revision"`
+	Branch   string `json:"branch"`
+
+	Path string `json:"path,omitempty"`
+}
+
+func (i *gbImporter) Name() string {
+	return "gb"
+}
+
+func (i *gbImporter) HasDepMetadata(dir string) bool {
+	// gb stores the manifest in the vendor tree
+	var m = filepath.Join(dir, "vendor", "manifest")
+	if _, err := os.Stat(m); err != nil {
+		return false
+	}
+
+	return true
+}
+
+func (i *gbImporter) Import(dir string, pr gps.ProjectRoot) (*dep.Manifest, *dep.Lock, error) {
+	err := i.load(dir)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return i.convert(pr)
+}
+
+// load the gb manifest
+func (i *gbImporter) load(projectDir string) error {
+	i.logger.Println("Detected gb manifest file...")
+	var err error
+	var mf = filepath.Join(projectDir, "vendor", "manifest")
+	if i.verbose {
+		i.logger.Printf("  Loading %s", mf)
+	}
+
+	var buf []byte
+	if buf, err = ioutil.ReadFile(mf); err != nil {
+		return errors.Wrapf(err, "Unable to read %s", mf)
+	}
+	if err = json.Unmarshal(buf, &i.manifest); err != nil {
+		return errors.Wrapf(err, "Unable to parse %s", mf)
+	}
+
+	return nil
+}
+
+// convert the gb manifest into dep configuration files.
+func (i *gbImporter) convert(pr gps.ProjectRoot) (*dep.Manifest, *dep.Lock, error) {
+	i.logger.Println("Converting from gb manifest...")
+
+	manifest := &dep.Manifest{
+		Constraints: make(gps.ProjectConstraints),
+	}
+
+	lock := &dep.Lock{}
+
+	for _, pkg := range i.manifest.Dependencies {
+		pc, err := i.buildProjectConstraint(pkg)
+		if err != nil {
+			return nil, nil, err
+		}
+		manifest.Constraints[pc.Ident.ProjectRoot] = gps.ProjectProperties{Source: pc.Ident.Source, Constraint: pc.Constraint}
+
+		lp := i.buildLockedProject(pkg, manifest)
+		lock.P = append(lock.P, lp)
+	}
+
+	return manifest, lock, nil
+}
+
+func (i *gbImporter) buildProjectConstraint(pkg gbDependency) (pc gps.ProjectConstraint, err error) {
+	if pkg.Importpath == "" {
+		err = errors.New("Invalid gb configuration, package import path is required")
+		return
+	}
+
+	pc.Ident = gps.ProjectIdentifier{ProjectRoot: gps.ProjectRoot(pkg.Importpath), Source: pkg.Repository}
+	pc.Constraint, err = i.sm.InferConstraint(pkg.Revision, pc.Ident)
+	if err != nil {
+		return
+	}
+
+	f := fb.NewConstraintFeedback(pc, fb.DepTypeImported)
+	f.LogFeedback(i.logger)
+
+	return
+}
+
+func (i *gbImporter) buildLockedProject(pkg gbDependency, manifest *dep.Manifest) gps.LockedProject {
+	pi := gps.ProjectIdentifier{
+		ProjectRoot: gps.ProjectRoot(pkg.Importpath),
+		Source:      pkg.Repository,
+	}
+	revision := gps.Revision(pkg.Revision)
+	pp := manifest.Constraints[pi.ProjectRoot]
+
+	version, err := lookupVersionForLockedProject(pi, pp.Constraint, revision, i.sm)
+	if err != nil {
+		// Only warn about the problem, it is not enough to warrant failing
+		i.logger.Println(err.Error())
+	}
+
+	lp := gps.NewLockedProject(pi, version, nil)
+
+	f := fb.NewLockedProjectFeedback(lp, fb.DepTypeImported)
+	f.LogFeedback(i.logger)
+
+	return lp
+}

cmd/dep/root_analyzer.go

@@ -73,6 +73,7 @@ func (a *rootAnalyzer) importManifestAndLock(dir string, pr gps.ProjectRoot, sup
 	importers := []importer{
 		newGlideImporter(logger, a.ctx.Verbose, a.sm),
 		newGodepImporter(logger, a.ctx.Verbose, a.sm),
+		newGbImporter(logger, a.ctx.Verbose, a.sm),
 	}
 
 	for _, i := range importers {