versions/v1_4_0/mynewt-newt/newt/newtutil/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.
  */

 package newtutil

 import (
 	"fmt"
 	"regexp"
 	"sort"
 	"strconv"
 	"strings"

 	"mynewt.apache.org/newt/util"

 	log "github.com/Sirupsen/logrus"
 )

 const (
 	VERSION_STABILITY_NONE   = ""
 	VERSION_STABILITY_STABLE = "stable"
 	VERSION_STABILITY_DEV    = "dev"
 	VERSION_STABILITY_LATEST = "latest"

 	// "commit" is not actually a stability, but it takes the place of one in
 	// the repo version notation.  The "commit" string indicates a commit hash,
 	// tag, or branch, rather than a version specifier.
 	VERSION_STABILITY_COMMIT = "commit"
 )

 // Represents an unspecified part in a version.  For example, in "1-latest",
 // the minor and revision parts are floating.
 const VERSION_FLOATING = -1

 type RepoVersionReq struct {
 	CompareType string
 	Ver         RepoVersion
 }

 type RepoVersion struct {
 	Major     int64
 	Minor     int64
 	Revision  int64
 	Stability string
 	Commit    string
 }

 func (v *RepoVersion) IsNormalized() bool {
 	return v.Stability == VERSION_STABILITY_NONE
 }

 func (vm *RepoVersionReq) String() string {
 	return vm.CompareType + vm.Ver.String()
 }

 func CompareRepoVersions(v1 RepoVersion, v2 RepoVersion) int64 {
 	if r := v1.Major - v2.Major; r != 0 {
 		return r
 	}

 	if r := v1.Minor - v2.Minor; r != 0 {
 		return r
 	}

 	if r := v1.Revision - v2.Revision; r != 0 {
 		return r
 	}

 	return 0
 }

 func (v *RepoVersion) Satisfies(verReq RepoVersionReq) bool {
 	if verReq.Ver.Commit != "" && verReq.CompareType != "==" {
 		log.Warningf("RepoVersion comparison with a tag %s %s %s",
 			verReq.Ver, verReq.CompareType, v)
 	}
 	r := CompareRepoVersions(verReq.Ver, *v)
 	switch verReq.CompareType {
 	case "<":
 		if r <= 0 {
 			return false
 		}
 	case "<=":
 		if r < 0 {
 			return false
 		}
 	case ">":
 		if r >= 0 {
 			return false
 		}
 	case ">=":
 		if r > 0 {
 			return false
 		}
 	case "==":
 		if r != 0 {
 			return false
 		}
 	}

 	if verReq.Ver.Stability != v.Stability {
 		return false
 	}

 	return true
 }

 func (v *RepoVersion) SatisfiesAll(verReqs []RepoVersionReq) bool {
 	for _, r := range verReqs {
 		if !v.Satisfies(r) {
 			return false
 		}
 	}

 	return true
 }

 func (ver *RepoVersion) String() string {
 	s := fmt.Sprintf("%d", ver.Major)
 	if ver.Minor != VERSION_FLOATING {
 		s += fmt.Sprintf(".%d", ver.Minor)
 	}
 	if ver.Revision != VERSION_FLOATING {
 		s += fmt.Sprintf(".%d", ver.Revision)
 	}

 	if ver.Stability != VERSION_STABILITY_NONE {
 		s += fmt.Sprintf("-%s", ver.Stability)
 	}

 	if ver.Commit != "" {
 		s += fmt.Sprintf("/%s", ver.Commit)
 	}

 	return s
 }

 func (ver *RepoVersion) ToNuVersion() Version {
 	return Version{
 		Major:    ver.Major,
 		Minor:    ver.Minor,
 		Revision: ver.Revision,
 	}
 }

 func ParseRepoVersion(verStr string) (RepoVersion, error) {
 	var err error

 	stability := VERSION_STABILITY_NONE
 	base := verStr

 	dashIdx := strings.LastIndex(verStr, "-")
 	if dashIdx != -1 {
 		stability = strings.TrimSpace(verStr[dashIdx+1:])
 		base = strings.TrimSpace(verStr[:dashIdx])

 		switch stability {
 		case VERSION_STABILITY_COMMIT:
 			return RepoVersion{Commit: strings.TrimSpace(base)}, nil

 		case VERSION_STABILITY_STABLE:
 		case VERSION_STABILITY_DEV:
 		case VERSION_STABILITY_LATEST:

 		default:
 			return RepoVersion{}, util.FmtNewtError(
 				"Unknown stability (%s) in version %s", stability, verStr)
 		}
 	}

 	parts := strings.Split(base, ".")
 	if len(parts) > 3 {
 		return RepoVersion{},
 			util.FmtNewtError("Invalid version string: %s", verStr)
 	}

 	if len(parts) != 3 && stability == VERSION_STABILITY_NONE {
 		return RepoVersion{},
 			util.FmtNewtError("Invalid version string: %s", verStr)
 	}

 	// Assume no parts of the version are specified.
 	ver := RepoVersion{
 		Major:     VERSION_FLOATING,
 		Minor:     VERSION_FLOATING,
 		Revision:  VERSION_FLOATING,
 		Stability: stability,
 	}

 	// Convert each dot-delimited part to an integer.
 	if ver.Major, err = strconv.ParseInt(parts[0], 10, 64); err != nil {
 		return RepoVersion{}, util.NewNewtError(err.Error())
 	}
 	if len(parts) >= 2 {
 		if ver.Minor, err = strconv.ParseInt(parts[1], 10, 64); err != nil {
 			return RepoVersion{}, util.NewNewtError(err.Error())
 		}
 	}
 	if len(parts) == 3 {
 		if ver.Revision, err = strconv.ParseInt(parts[2], 10, 64); err != nil {
 			return RepoVersion{}, util.NewNewtError(err.Error())
 		}
 	}

 	return ver, nil
 }

 // Parse a set of version string constraints on a dependency.
 // This function
 // The version string contains a list of version constraints in the following format:
 //    - <comparison><version>
 // Where <comparison> can be any one of the following comparison
 //   operators: <=, <, >, >=, ==
 // And <version> is specified in the form: X.Y.Z where X, Y and Z are all
 // int64 types in decimal form
 func ParseRepoVersionReqs(versStr string) ([]RepoVersionReq, error) {
 	var err error

 	verReqs := []RepoVersionReq{}

 	re, err := regexp.Compile(`(<=|>=|==|>|<)([\d\.]+)`)
 	if err != nil {
 		return nil, err
 	}

 	matches := re.FindAllStringSubmatch(versStr, -1)
 	if matches != nil {
 		for _, match := range matches {
 			vm := RepoVersionReq{}
 			vm.CompareType = match[1]
 			if vm.Ver, err = ParseRepoVersion(match[2]); err != nil {
 				return nil, err
 			}

 			verReqs = append(verReqs, vm)
 		}
 	} else {
 		vm := RepoVersionReq{}
 		vm.CompareType = "=="
 		if vm.Ver, err = ParseRepoVersion(versStr); err != nil {
 			return nil, err
 		}

 		verReqs = append(verReqs, vm)
 	}

 	if len(verReqs) == 0 {
 		verReqs = nil
 	}

 	return verReqs, nil
 }

 func RepoVerReqsString(verReqs []RepoVersionReq) string {
 	s := ""
 	for i, r := range verReqs {
 		if i != 0 {
 			s += " "
 		}
 		s += r.String()
 	}

 	return s
 }

 type verSorter struct {
 	vers []RepoVersion
 }

 func (v verSorter) Len() int {
 	return len(v.vers)
 }
 func (v verSorter) Swap(i, j int) {
 	v.vers[i], v.vers[j] = v.vers[j], v.vers[i]
 }
 func (v verSorter) Less(i, j int) bool {
 	a := v.vers[i]
 	b := v.vers[j]

 	return CompareRepoVersions(a, b) < 0
 }

 func SortVersions(vers []RepoVersion) {
 	sorter := verSorter{
 		vers: vers,
 	}

 	sort.Sort(sorter)
 }

 func SortedVersions(vers []RepoVersion) []RepoVersion {
 	clone := make([]RepoVersion, len(vers))
 	copy(clone, vers)

 	SortVersions(clone)
 	return clone
 }

 func SortedVersionsDesc(vers []RepoVersion) []RepoVersion {
 	slice := SortedVersions(vers)
 	size := len(slice)
 	for i := 0; i < size/2; i++ {
 		j := size - 1 - i
 		slice[i], slice[j] = slice[j], slice[i]
 	}

 	return slice
 }
	/**
	* 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.
	*/

	package newtutil

	import (
	"fmt"
	"regexp"
	"sort"
	"strconv"
	"strings"

	"mynewt.apache.org/newt/util"

	log "github.com/Sirupsen/logrus"
	)

	const (
	VERSION_STABILITY_NONE = ""
	VERSION_STABILITY_STABLE = "stable"
	VERSION_STABILITY_DEV = "dev"
	VERSION_STABILITY_LATEST = "latest"

	// "commit" is not actually a stability, but it takes the place of one in
	// the repo version notation. The "commit" string indicates a commit hash,
	// tag, or branch, rather than a version specifier.
	VERSION_STABILITY_COMMIT = "commit"
	)

	// Represents an unspecified part in a version. For example, in "1-latest",
	// the minor and revision parts are floating.
	const VERSION_FLOATING = -1

	type RepoVersionReq struct {
	CompareType string
	Ver RepoVersion
	}

	type RepoVersion struct {
	Major int64
	Minor int64
	Revision int64
	Stability string
	Commit string
	}

	func (v *RepoVersion) IsNormalized() bool {
	return v.Stability == VERSION_STABILITY_NONE
	}

	func (vm *RepoVersionReq) String() string {
	return vm.CompareType + vm.Ver.String()
	}

	func CompareRepoVersions(v1 RepoVersion, v2 RepoVersion) int64 {
	if r := v1.Major - v2.Major; r != 0 {
	return r
	}

	if r := v1.Minor - v2.Minor; r != 0 {
	return r
	}

	if r := v1.Revision - v2.Revision; r != 0 {
	return r
	}

	return 0
	}

	func (v *RepoVersion) Satisfies(verReq RepoVersionReq) bool {
	if verReq.Ver.Commit != "" && verReq.CompareType != "==" {
	log.Warningf("RepoVersion comparison with a tag %s %s %s",
	verReq.Ver, verReq.CompareType, v)
	}
	r := CompareRepoVersions(verReq.Ver, *v)
	switch verReq.CompareType {
	case "<":
	if r <= 0 {
	return false
	}
	case "<=":
	if r < 0 {
	return false
	}
	case ">":
	if r >= 0 {
	return false
	}
	case ">=":
	if r > 0 {
	return false
	}
	case "==":
	if r != 0 {
	return false
	}
	}

	if verReq.Ver.Stability != v.Stability {
	return false
	}

	return true
	}

	func (v *RepoVersion) SatisfiesAll(verReqs []RepoVersionReq) bool {
	for _, r := range verReqs {
	if !v.Satisfies(r) {
	return false
	}
	}

	return true
	}

	func (ver *RepoVersion) String() string {
	s := fmt.Sprintf("%d", ver.Major)
	if ver.Minor != VERSION_FLOATING {
	s += fmt.Sprintf(".%d", ver.Minor)
	}
	if ver.Revision != VERSION_FLOATING {
	s += fmt.Sprintf(".%d", ver.Revision)
	}

	if ver.Stability != VERSION_STABILITY_NONE {
	s += fmt.Sprintf("-%s", ver.Stability)
	}

	if ver.Commit != "" {
	s += fmt.Sprintf("/%s", ver.Commit)
	}

	return s
	}

	func (ver *RepoVersion) ToNuVersion() Version {
	return Version{
	Major: ver.Major,
	Minor: ver.Minor,
	Revision: ver.Revision,
	}
	}

	func ParseRepoVersion(verStr string) (RepoVersion, error) {
	var err error

	stability := VERSION_STABILITY_NONE
	base := verStr

	dashIdx := strings.LastIndex(verStr, "-")
	if dashIdx != -1 {
	stability = strings.TrimSpace(verStr[dashIdx+1:])
	base = strings.TrimSpace(verStr[:dashIdx])

	switch stability {
	case VERSION_STABILITY_COMMIT:
	return RepoVersion{Commit: strings.TrimSpace(base)}, nil

	case VERSION_STABILITY_STABLE:
	case VERSION_STABILITY_DEV:
	case VERSION_STABILITY_LATEST:

	default:
	return RepoVersion{}, util.FmtNewtError(
	"Unknown stability (%s) in version %s", stability, verStr)
	}
	}

	parts := strings.Split(base, ".")
	if len(parts) > 3 {
	return RepoVersion{},
	util.FmtNewtError("Invalid version string: %s", verStr)
	}

	if len(parts) != 3 && stability == VERSION_STABILITY_NONE {
	return RepoVersion{},
	util.FmtNewtError("Invalid version string: %s", verStr)
	}

	// Assume no parts of the version are specified.
	ver := RepoVersion{
	Major: VERSION_FLOATING,
	Minor: VERSION_FLOATING,
	Revision: VERSION_FLOATING,
	Stability: stability,
	}

	// Convert each dot-delimited part to an integer.
	if ver.Major, err = strconv.ParseInt(parts[0], 10, 64); err != nil {
	return RepoVersion{}, util.NewNewtError(err.Error())
	}
	if len(parts) >= 2 {
	if ver.Minor, err = strconv.ParseInt(parts[1], 10, 64); err != nil {
	return RepoVersion{}, util.NewNewtError(err.Error())
	}
	}
	if len(parts) == 3 {
	if ver.Revision, err = strconv.ParseInt(parts[2], 10, 64); err != nil {
	return RepoVersion{}, util.NewNewtError(err.Error())
	}
	}

	return ver, nil
	}

	// Parse a set of version string constraints on a dependency.
	// This function
	// The version string contains a list of version constraints in the following format:
	// - <comparison><version>
	// Where <comparison> can be any one of the following comparison
	// operators: <=, <, >, >=, ==
	// And <version> is specified in the form: X.Y.Z where X, Y and Z are all
	// int64 types in decimal form
	func ParseRepoVersionReqs(versStr string) ([]RepoVersionReq, error) {
	var err error

	verReqs := []RepoVersionReq{}

	re, err := regexp.Compile(`(<=\|>=\|==\|>\|<)([\d\.]+)`)
	if err != nil {
	return nil, err
	}

	matches := re.FindAllStringSubmatch(versStr, -1)
	if matches != nil {
	for _, match := range matches {
	vm := RepoVersionReq{}
	vm.CompareType = match[1]
	if vm.Ver, err = ParseRepoVersion(match[2]); err != nil {
	return nil, err
	}

	verReqs = append(verReqs, vm)
	}
	} else {
	vm := RepoVersionReq{}
	vm.CompareType = "=="
	if vm.Ver, err = ParseRepoVersion(versStr); err != nil {
	return nil, err
	}

	verReqs = append(verReqs, vm)
	}

	if len(verReqs) == 0 {
	verReqs = nil
	}

	return verReqs, nil
	}

	func RepoVerReqsString(verReqs []RepoVersionReq) string {
	s := ""
	for i, r := range verReqs {
	if i != 0 {
	s += " "
	}
	s += r.String()
	}

	return s
	}

	type verSorter struct {
	vers []RepoVersion
	}

	func (v verSorter) Len() int {
	return len(v.vers)
	}
	func (v verSorter) Swap(i, j int) {
	v.vers[i], v.vers[j] = v.vers[j], v.vers[i]
	}
	func (v verSorter) Less(i, j int) bool {
	a := v.vers[i]
	b := v.vers[j]

	return CompareRepoVersions(a, b) < 0
	}

	func SortVersions(vers []RepoVersion) {
	sorter := verSorter{
	vers: vers,
	}

	sort.Sort(sorter)
	}

	func SortedVersions(vers []RepoVersion) []RepoVersion {
	clone := make([]RepoVersion, len(vers))
	copy(clone, vers)

	SortVersions(clone)
	return clone
	}

	func SortedVersionsDesc(vers []RepoVersion) []RepoVersion {
	slice := SortedVersions(vers)
	size := len(slice)
	for i := 0; i < size/2; i++ {
	j := size - 1 - i
	slice[i], slice[j] = slice[j], slice[i]
	}

	return slice
	}