versions/v1_4_0/mynewt-newt/newt/repo/version.go - mynewt-documentation - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 // Contains all repo version detection functionality.

 package repo

 import (
 	"strings"

 	log "github.com/Sirupsen/logrus"

 	"mynewt.apache.org/newt/newt/newtutil"
 	"mynewt.apache.org/newt/util"
 )

 var versionYmlMissing = util.FmtNewtError("version.yml missing")
 var versionYmlBad = util.FmtNewtError("version.yml bad")

 func versString(vers []newtutil.RepoVersion) string {
 	s := "["

 	for _, v := range vers {
 		if len(s) > 1 {
 			s += ","
 		}
 		s += v.String()
 	}

 	s += "]"
 	return s
 }

 func (r *Repo) DepsForVersion(ver newtutil.RepoVersion) []*RepoDependency {
 	// If the project uses a specific commit of this repo rather than a version
 	// specifier, ignore the commit string when calculating dependencies.
 	// Repos specify dependencies for tags and branches corresponding to
 	// version numbers rather than this particular commit.
 	ver.Commit = ""

 	commit, err := r.CommitFromVer(ver)
 	if err != nil {
 		return nil
 	}

 	return r.deps[commit]
 }

 // Removes extra information from a git commit string.  This throws away
 // information and causes some ambiguity, but it allows git commits to be
 // specified in a user-friendly manner (e.g., "mynewt_1_3_0_tag" rather than
 // "tags/mynewt_1_3_0_tag").
 func normalizeCommit(commit string) string {
 	commit = strings.TrimPrefix(commit, "tags/")
 	commit = strings.TrimPrefix(commit, "origin/")
 	commit = strings.TrimPrefix(commit, "heads/")
 	return commit
 }

 // Retrieves the repo's currently checked-out hash.
 func (r *Repo) CurrentHash() (string, error) {
 	dl := r.downloader
 	commit, err := dl.HashFor(r.Path(), "HEAD")
 	if err != nil {
 		return "",
 			util.FmtNewtError("Error finding current hash for \"%s\": %s",
 				r.Name(), err.Error())
 	}
 	return commit, nil
 }

 // Retrieves all commit strings corresponding to the repo's current state.
 func (r *Repo) CurrentCommits() ([]string, error) {
 	commits, err := r.downloader.CommitsFor(r.Path(), "HEAD")
 	if err != nil {
 		return nil, err
 	}

 	return commits, nil
 }

 // Retrieves the commit that the specified version maps to in `repository.yml`.
 // Note: This returns the specific commit in `repository.yml`; there may be
 // other commits that refer to the same point in the repo's history.
 func (r *Repo) CommitFromVer(ver newtutil.RepoVersion) (string, error) {
 	if ver.Commit != "" {
 		return ver.Commit, nil
 	}

 	nver, err := r.NormalizeVersion(ver)
 	if err != nil {
 		return "", err
 	}

 	commit := r.vers[nver]
 	if commit == "" {
 		return "",
 			util.FmtNewtError(
 				"repo \"%s\" version %s does not map to a commit",
 				r.Name(), nver.String())
 	}

 	return commit, nil
 }

 // Determines whether the two specified commits refer to the same point in the
 // repo's history.
 func (r *Repo) CommitsEquivalent(c1 string, c2 string) (bool, error) {
 	if c1 == "" {
 		return c2 == "", nil
 	} else if c2 == "" {
 		return false, nil
 	}

 	commits, err := r.downloader.CommitsFor(r.Path(), c1)
 	if err != nil {
 		return false, err
 	}

 	for _, c := range commits {
 		if c == c2 {
 			return true, nil
 		}
 	}

 	return false, nil
 }

 // Retrieves the unique commit hash corresponding to the specified repo
 // version.
 func (r *Repo) HashFromVer(ver newtutil.RepoVersion) (string, error) {
 	commit, err := r.CommitFromVer(ver)
 	if err != nil {
 		return "", err
 	}

 	hash, err := r.downloader.HashFor(r.Path(), commit)
 	if err != nil {
 		return "", err
 	}

 	return hash, nil
 }

 // Retrieves all versions that map to the specified commit string.
 // Note: This function only considers the specified commit.  If any equivalent
 // commits exist, they are not considered here.
 func (r *Repo) VersFromCommit(commit string) []newtutil.RepoVersion {
 	var vers []newtutil.RepoVersion

 	for v, c := range r.vers {
 		if c == commit {
 			vers = append(vers, v)
 		}
 	}

 	newtutil.SortVersions(vers)
 	return vers
 }

 // Retrieves all versions that map to any of the specified commit strings.
 // Note: This function only considers the specified commits.  If any equivalent
 // commits exist, they are not considered here.
 func (r *Repo) VersFromCommits(commits []string) []newtutil.RepoVersion {
 	var vers []newtutil.RepoVersion
 	for _, c := range commits {
 		vers = append(vers, r.VersFromCommit(normalizeCommit(c))...)
 	}

 	newtutil.SortVersions(vers)
 	return vers
 }

 // Retrieves all versions that map to the specified commit.  Versions that map
 // to equivalent commits are also included.
 func (r *Repo) VersFromEquivCommit(
 	commit string) ([]newtutil.RepoVersion, error) {

 	commits, err := r.downloader.CommitsFor(r.Path(), commit)
 	if err != nil {
 		return nil, err
 	}

 	return r.VersFromCommits(commits), nil
 }

 // Converts the specified versions to their equivalent x.x.x forms for this
 // repo.  For example, this might convert "0-dev" to "0.0.0" (depending on the
 // `repository.yml` file contents).
 func (r *Repo) NormalizedVersions() ([]newtutil.RepoVersion, error) {
 	verMap := map[newtutil.RepoVersion]struct{}{}

 	for ver, _ := range r.vers {
 		nver, err := r.NormalizeVersion(ver)
 		if err != nil {
 			return nil, err
 		}
 		verMap[nver] = struct{}{}
 	}

 	vers := make([]newtutil.RepoVersion, 0, len(verMap))
 	for ver, _ := range verMap {
 		vers = append(vers, ver)
 	}

 	return vers, nil
 }

 // Converts the specified version to its equivalent x.x.x form for this repo.
 // For example, this might convert "0-dev" to "0.0.0" (depending on the
 // `repository.yml` file contents).
 func (r *Repo) NormalizeVersion(
 	ver newtutil.RepoVersion) (newtutil.RepoVersion, error) {

 	origVer := ver
 	for {
 		if ver.Stability == "" ||
 			ver.Stability == newtutil.VERSION_STABILITY_NONE {
 			return ver, nil
 		}

 		verStr := r.vers[ver]
 		if verStr == "" {
 			return ver, util.FmtNewtError(
 				"cannot normalize version \"%s\" for repo \"%s\"; "+
 					"no mapping to numeric version",
 				origVer.String(), r.Name())
 		}

 		nextVer, err := newtutil.ParseRepoVersion(verStr)
 		if err != nil {
 			return ver, err
 		}
 		ver = nextVer
 	}
 }

 // Normalizes the version component of a version requirement.
 func (r *Repo) NormalizeVerReq(verReq newtutil.RepoVersionReq) (
 	newtutil.RepoVersionReq, error) {

 	ver, err := r.NormalizeVersion(verReq.Ver)
 	if err != nil {
 		return verReq, err
 	}

 	verReq.Ver = ver
 	return verReq, nil
 }

 // Normalizes the version component of each specified version requirement.
 func (r *Repo) NormalizeVerReqs(verReqs []newtutil.RepoVersionReq) (
 	[]newtutil.RepoVersionReq, error) {

 	result := make([]newtutil.RepoVersionReq, len(verReqs))
 	for i, verReq := range verReqs {
 		n, err := r.NormalizeVerReq(verReq)
 		if err != nil {
 			return nil, err
 		}
 		result[i] = n
 	}

 	return result, nil
 }

 // Compares the two specified versions for equality.  Two versions are equal if
 // they ultimately map to the same commit object.
 func (r *Repo) VersionsEqual(v1 newtutil.RepoVersion,
 	v2 newtutil.RepoVersion) bool {

 	if newtutil.CompareRepoVersions(v1, v2) == 0 {
 		return true
 	}

 	h1, err := r.HashFromVer(v1)
 	if err != nil {
 		return false
 	}

 	h2, err := r.HashFromVer(v2)
 	if err != nil {
 		return false
 	}

 	return h1 == h2
 }

 // Parses the `version.yml` file at the specified path.  On success, the parsed
 // version is returned.
 func parseVersionYml(path string) (newtutil.RepoVersion, error) {
 	yc, err := newtutil.ReadConfigPath(path)
 	if err != nil {
 		if util.IsNotExist(err) {
 			return newtutil.RepoVersion{}, versionYmlMissing
 		} else {
 			return newtutil.RepoVersion{}, versionYmlBad
 		}
 	}

 	verString := yc.GetValString("repo.version", nil)
 	if verString == "" {
 		return newtutil.RepoVersion{}, versionYmlBad
 	}

 	ver, err := newtutil.ParseRepoVersion(verString)
 	if err != nil || !ver.IsNormalized() {
 		return newtutil.RepoVersion{}, versionYmlBad
 	}

 	return ver, nil
 }

 // Reads and parses the `version.yml` file belonging to an installed repo.
 func (r *Repo) installedVersionYml() (*newtutil.RepoVersion, error) {
 	ver, err := parseVersionYml(r.Path() + "/" + REPO_VER_FILE_NAME)
 	if err != nil {
 		return nil, err
 	}

 	return &ver, nil
 }

 // Downloads and parses the `version.yml` file from the repo at the specified
 // commit.
 func (r *Repo) nonInstalledVersionYml(
 	commit string) (*newtutil.RepoVersion, error) {

 	filePath, err := r.downloadFile(commit, REPO_VER_FILE_NAME)
 	if err != nil {
 		// The download failed.  Determine if the commit string is bad or if
 		// the file just doesn't exist in that commit.
 		if _, e2 := r.downloader.CommitType(r.localPath, commit); e2 != nil {
 			// Bad commit string.
 			return nil, err
 		}

 		// The commit exists, but it doesn't contain a `version.yml` file.
 		// Assume the commit corresponds to version 0.0.0.
 		return nil, versionYmlMissing
 	}

 	ver, err := parseVersionYml(filePath)
 	if err != nil {
 		return nil, err
 	}

 	return &ver, nil
 }

 // Tries to determine which repo version meets the specified criteria:
 //  * Maps to the specified commit string (or an equivalent commit).
 //  * Is equal to the specified version read from `version.yml` (if not-null).
 func (r *Repo) inferVersion(commit string, vyVer *newtutil.RepoVersion) (
 	*newtutil.RepoVersion, error) {

 	// Search `repository.yml` for versions that the specified commit maps to.
 	ryVers, err := r.VersFromEquivCommit(commit)
 	if err != nil {
 		return nil, err
 	}

 	// If valid versions were derived from both `version.yml` and the specified
 	// commit+`repository.yml`, look for a common version.
 	if vyVer != nil {
 		if len(ryVers) > 0 {
 			for _, cv := range ryVers {
 				if newtutil.CompareRepoVersions(*vyVer, cv) == 0 {
 					return vyVer, nil
 				}
 			}

 			util.StatusMessage(util.VERBOSITY_QUIET,
 				"WARNING: Version mismatch in %s:%s; "+
 					"repository.yml:%s, version.yml:%s\n",
 				r.Name(), commit, versString(ryVers), vyVer.String())
 		} else {
 			// If the set of commits don't match a version from
 			// `repository.yml`, record the commit hash in the version
 			// specifier.  This will distinguish the returned version from its
 			// corresponding official release.
 			hash, err := r.downloader.HashFor(r.Path(), commit)
 			if err != nil {
 				return nil, err
 			}
 			vyVer.Commit = hash
 		}

 		// Always prefer the version in `version.yml`.
 		log.Debugf("Inferred version %s from %s:%s from version.yml",
 			vyVer.String(), r.Name(), commit)
 		return vyVer, nil
 	}

 	if len(ryVers) > 0 {
 		log.Debugf("Inferred version %s for %s:%s from repository.yml",
 			ryVers[0].String(), r.Name(), commit)
 		return &ryVers[0], nil
 	}

 	return nil, nil
 }

 // Retrieves the installed version of the repo.  Returns nil if the version
 // cannot be detected.
 func (r *Repo) InstalledVersion() (*newtutil.RepoVersion, error) {
 	vyVer, err := r.installedVersionYml()
 	if err != nil && err != versionYmlMissing && err != versionYmlBad {
 		return nil, err
 	}

 	hash, err := r.CurrentHash()
 	if err != nil {
 		return nil, err
 	}

 	ver, err := r.inferVersion(hash, vyVer)
 	if err != nil {
 		return nil, err
 	}

 	return ver, nil
 }

 // Retrieves the repo version corresponding to the specified commit.  Returns
 // nil if the version cannot be detected.
 func (r *Repo) NonInstalledVersion(
 	commit string) (*newtutil.RepoVersion, error) {

 	ver, versionYmlErr := r.nonInstalledVersionYml(commit)
 	if versionYmlErr != nil &&
 		versionYmlErr != versionYmlMissing &&
 		versionYmlErr != versionYmlBad {

 		return nil, versionYmlErr
 	}

 	ver, err := r.inferVersion(commit, ver)
 	if err != nil {
 		return nil, err
 	}

 	if ver == nil {
 		if versionYmlErr == versionYmlMissing {
 			util.StatusMessage(util.VERBOSITY_QUIET,
 				"WARNING: %s:%s does not contain a `version.yml` file.\n",
 				r.Name(), commit)
 		} else if versionYmlErr == versionYmlBad {
 			util.StatusMessage(util.VERBOSITY_QUIET,
 				"WARNING: %s:%s contains a malformed `version.yml` file.\n",
 				r.Name(), commit)
 		}
 	}

 	return ver, nil
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	// Contains all repo version detection functionality.

	package repo

	import (
	"strings"

	log "github.com/Sirupsen/logrus"

	"mynewt.apache.org/newt/newt/newtutil"
	"mynewt.apache.org/newt/util"
	)

	var versionYmlMissing = util.FmtNewtError("version.yml missing")
	var versionYmlBad = util.FmtNewtError("version.yml bad")

	func versString(vers []newtutil.RepoVersion) string {
	s := "["

	for _, v := range vers {
	if len(s) > 1 {
	s += ","
	}
	s += v.String()
	}

	s += "]"
	return s
	}

	func (r Repo) DepsForVersion(ver newtutil.RepoVersion) []RepoDependency {
	// If the project uses a specific commit of this repo rather than a version
	// specifier, ignore the commit string when calculating dependencies.
	// Repos specify dependencies for tags and branches corresponding to
	// version numbers rather than this particular commit.
	ver.Commit = ""

	commit, err := r.CommitFromVer(ver)
	if err != nil {
	return nil
	}

	return r.deps[commit]
	}

	// Removes extra information from a git commit string. This throws away
	// information and causes some ambiguity, but it allows git commits to be
	// specified in a user-friendly manner (e.g., "mynewt_1_3_0_tag" rather than
	// "tags/mynewt_1_3_0_tag").
	func normalizeCommit(commit string) string {
	commit = strings.TrimPrefix(commit, "tags/")
	commit = strings.TrimPrefix(commit, "origin/")
	commit = strings.TrimPrefix(commit, "heads/")
	return commit
	}

	// Retrieves the repo's currently checked-out hash.
	func (r *Repo) CurrentHash() (string, error) {
	dl := r.downloader
	commit, err := dl.HashFor(r.Path(), "HEAD")
	if err != nil {
	return "",
	util.FmtNewtError("Error finding current hash for \"%s\": %s",
	r.Name(), err.Error())
	}
	return commit, nil
	}

	// Retrieves all commit strings corresponding to the repo's current state.
	func (r *Repo) CurrentCommits() ([]string, error) {
	commits, err := r.downloader.CommitsFor(r.Path(), "HEAD")
	if err != nil {
	return nil, err
	}

	return commits, nil
	}

	// Retrieves the commit that the specified version maps to in `repository.yml`.
	// Note: This returns the specific commit in `repository.yml`; there may be
	// other commits that refer to the same point in the repo's history.
	func (r *Repo) CommitFromVer(ver newtutil.RepoVersion) (string, error) {
	if ver.Commit != "" {
	return ver.Commit, nil
	}

	nver, err := r.NormalizeVersion(ver)
	if err != nil {
	return "", err
	}

	commit := r.vers[nver]
	if commit == "" {
	return "",
	util.FmtNewtError(
	"repo \"%s\" version %s does not map to a commit",
	r.Name(), nver.String())
	}

	return commit, nil
	}

	// Determines whether the two specified commits refer to the same point in the
	// repo's history.
	func (r *Repo) CommitsEquivalent(c1 string, c2 string) (bool, error) {
	if c1 == "" {
	return c2 == "", nil
	} else if c2 == "" {
	return false, nil
	}

	commits, err := r.downloader.CommitsFor(r.Path(), c1)
	if err != nil {
	return false, err
	}

	for _, c := range commits {
	if c == c2 {
	return true, nil
	}
	}

	return false, nil
	}

	// Retrieves the unique commit hash corresponding to the specified repo
	// version.
	func (r *Repo) HashFromVer(ver newtutil.RepoVersion) (string, error) {
	commit, err := r.CommitFromVer(ver)
	if err != nil {
	return "", err
	}

	hash, err := r.downloader.HashFor(r.Path(), commit)
	if err != nil {
	return "", err
	}

	return hash, nil
	}

	// Retrieves all versions that map to the specified commit string.
	// Note: This function only considers the specified commit. If any equivalent
	// commits exist, they are not considered here.
	func (r *Repo) VersFromCommit(commit string) []newtutil.RepoVersion {
	var vers []newtutil.RepoVersion

	for v, c := range r.vers {
	if c == commit {
	vers = append(vers, v)
	}
	}

	newtutil.SortVersions(vers)
	return vers
	}

	// Retrieves all versions that map to any of the specified commit strings.
	// Note: This function only considers the specified commits. If any equivalent
	// commits exist, they are not considered here.
	func (r *Repo) VersFromCommits(commits []string) []newtutil.RepoVersion {
	var vers []newtutil.RepoVersion
	for _, c := range commits {
	vers = append(vers, r.VersFromCommit(normalizeCommit(c))...)
	}

	newtutil.SortVersions(vers)
	return vers
	}

	// Retrieves all versions that map to the specified commit. Versions that map
	// to equivalent commits are also included.
	func (r *Repo) VersFromEquivCommit(
	commit string) ([]newtutil.RepoVersion, error) {

	commits, err := r.downloader.CommitsFor(r.Path(), commit)
	if err != nil {
	return nil, err
	}

	return r.VersFromCommits(commits), nil
	}

	// Converts the specified versions to their equivalent x.x.x forms for this
	// repo. For example, this might convert "0-dev" to "0.0.0" (depending on the
	// `repository.yml` file contents).
	func (r *Repo) NormalizedVersions() ([]newtutil.RepoVersion, error) {
	verMap := map[newtutil.RepoVersion]struct{}{}

	for ver, _ := range r.vers {
	nver, err := r.NormalizeVersion(ver)
	if err != nil {
	return nil, err
	}
	verMap[nver] = struct{}{}
	}

	vers := make([]newtutil.RepoVersion, 0, len(verMap))
	for ver, _ := range verMap {
	vers = append(vers, ver)
	}

	return vers, nil
	}

	// Converts the specified version to its equivalent x.x.x form for this repo.
	// For example, this might convert "0-dev" to "0.0.0" (depending on the
	// `repository.yml` file contents).
	func (r *Repo) NormalizeVersion(
	ver newtutil.RepoVersion) (newtutil.RepoVersion, error) {

	origVer := ver
	for {
	if ver.Stability == "" \|\|
	ver.Stability == newtutil.VERSION_STABILITY_NONE {
	return ver, nil
	}

	verStr := r.vers[ver]
	if verStr == "" {
	return ver, util.FmtNewtError(
	"cannot normalize version \"%s\" for repo \"%s\"; "+
	"no mapping to numeric version",
	origVer.String(), r.Name())
	}

	nextVer, err := newtutil.ParseRepoVersion(verStr)
	if err != nil {
	return ver, err
	}
	ver = nextVer
	}
	}

	// Normalizes the version component of a version requirement.
	func (r *Repo) NormalizeVerReq(verReq newtutil.RepoVersionReq) (
	newtutil.RepoVersionReq, error) {

	ver, err := r.NormalizeVersion(verReq.Ver)
	if err != nil {
	return verReq, err
	}

	verReq.Ver = ver
	return verReq, nil
	}

	// Normalizes the version component of each specified version requirement.
	func (r *Repo) NormalizeVerReqs(verReqs []newtutil.RepoVersionReq) (
	[]newtutil.RepoVersionReq, error) {

	result := make([]newtutil.RepoVersionReq, len(verReqs))
	for i, verReq := range verReqs {
	n, err := r.NormalizeVerReq(verReq)
	if err != nil {
	return nil, err
	}
	result[i] = n
	}

	return result, nil
	}

	// Compares the two specified versions for equality. Two versions are equal if
	// they ultimately map to the same commit object.
	func (r *Repo) VersionsEqual(v1 newtutil.RepoVersion,
	v2 newtutil.RepoVersion) bool {

	if newtutil.CompareRepoVersions(v1, v2) == 0 {
	return true
	}

	h1, err := r.HashFromVer(v1)
	if err != nil {
	return false
	}

	h2, err := r.HashFromVer(v2)
	if err != nil {
	return false
	}

	return h1 == h2
	}

	// Parses the `version.yml` file at the specified path. On success, the parsed
	// version is returned.
	func parseVersionYml(path string) (newtutil.RepoVersion, error) {
	yc, err := newtutil.ReadConfigPath(path)
	if err != nil {
	if util.IsNotExist(err) {
	return newtutil.RepoVersion{}, versionYmlMissing
	} else {
	return newtutil.RepoVersion{}, versionYmlBad
	}
	}

	verString := yc.GetValString("repo.version", nil)
	if verString == "" {
	return newtutil.RepoVersion{}, versionYmlBad
	}

	ver, err := newtutil.ParseRepoVersion(verString)
	if err != nil \|\| !ver.IsNormalized() {
	return newtutil.RepoVersion{}, versionYmlBad
	}

	return ver, nil
	}

	// Reads and parses the `version.yml` file belonging to an installed repo.
	func (r Repo) installedVersionYml() (newtutil.RepoVersion, error) {
	ver, err := parseVersionYml(r.Path() + "/" + REPO_VER_FILE_NAME)
	if err != nil {
	return nil, err
	}

	return &ver, nil
	}

	// Downloads and parses the `version.yml` file from the repo at the specified
	// commit.
	func (r *Repo) nonInstalledVersionYml(
	commit string) (*newtutil.RepoVersion, error) {

	filePath, err := r.downloadFile(commit, REPO_VER_FILE_NAME)
	if err != nil {
	// The download failed. Determine if the commit string is bad or if
	// the file just doesn't exist in that commit.
	if _, e2 := r.downloader.CommitType(r.localPath, commit); e2 != nil {
	// Bad commit string.
	return nil, err
	}

	// The commit exists, but it doesn't contain a `version.yml` file.
	// Assume the commit corresponds to version 0.0.0.
	return nil, versionYmlMissing
	}

	ver, err := parseVersionYml(filePath)
	if err != nil {
	return nil, err
	}

	return &ver, nil
	}

	// Tries to determine which repo version meets the specified criteria:
	// * Maps to the specified commit string (or an equivalent commit).
	// * Is equal to the specified version read from `version.yml` (if not-null).
	func (r Repo) inferVersion(commit string, vyVer newtutil.RepoVersion) (
	*newtutil.RepoVersion, error) {

	// Search `repository.yml` for versions that the specified commit maps to.
	ryVers, err := r.VersFromEquivCommit(commit)
	if err != nil {
	return nil, err
	}

	// If valid versions were derived from both `version.yml` and the specified
	// commit+`repository.yml`, look for a common version.
	if vyVer != nil {
	if len(ryVers) > 0 {
	for _, cv := range ryVers {
	if newtutil.CompareRepoVersions(*vyVer, cv) == 0 {
	return vyVer, nil
	}
	}

	util.StatusMessage(util.VERBOSITY_QUIET,
	"WARNING: Version mismatch in %s:%s; "+
	"repository.yml:%s, version.yml:%s\n",
	r.Name(), commit, versString(ryVers), vyVer.String())
	} else {
	// If the set of commits don't match a version from
	// `repository.yml`, record the commit hash in the version
	// specifier. This will distinguish the returned version from its
	// corresponding official release.
	hash, err := r.downloader.HashFor(r.Path(), commit)
	if err != nil {
	return nil, err
	}
	vyVer.Commit = hash
	}

	// Always prefer the version in `version.yml`.
	log.Debugf("Inferred version %s from %s:%s from version.yml",
	vyVer.String(), r.Name(), commit)
	return vyVer, nil
	}

	if len(ryVers) > 0 {
	log.Debugf("Inferred version %s for %s:%s from repository.yml",
	ryVers[0].String(), r.Name(), commit)
	return &ryVers[0], nil
	}

	return nil, nil
	}

	// Retrieves the installed version of the repo. Returns nil if the version
	// cannot be detected.
	func (r Repo) InstalledVersion() (newtutil.RepoVersion, error) {
	vyVer, err := r.installedVersionYml()
	if err != nil && err != versionYmlMissing && err != versionYmlBad {
	return nil, err
	}

	hash, err := r.CurrentHash()
	if err != nil {
	return nil, err
	}

	ver, err := r.inferVersion(hash, vyVer)
	if err != nil {
	return nil, err
	}

	return ver, nil
	}

	// Retrieves the repo version corresponding to the specified commit. Returns
	// nil if the version cannot be detected.
	func (r *Repo) NonInstalledVersion(
	commit string) (*newtutil.RepoVersion, error) {

	ver, versionYmlErr := r.nonInstalledVersionYml(commit)
	if versionYmlErr != nil &&
	versionYmlErr != versionYmlMissing &&
	versionYmlErr != versionYmlBad {

	return nil, versionYmlErr
	}

	ver, err := r.inferVersion(commit, ver)
	if err != nil {
	return nil, err
	}

	if ver == nil {
	if versionYmlErr == versionYmlMissing {
	util.StatusMessage(util.VERBOSITY_QUIET,
	"WARNING: %s:%s does not contain a `version.yml` file.\n",
	r.Name(), commit)
	} else if versionYmlErr == versionYmlBad {
	util.StatusMessage(util.VERBOSITY_QUIET,
	"WARNING: %s:%s contains a malformed `version.yml` file.\n",
	r.Name(), commit)
	}
	}

	return ver, nil
	}