forked from Shiloh/githaven
270 lines
7.4 KiB
Go
270 lines
7.4 KiB
Go
package version
|
|
|
|
import (
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type ConstraintGroup struct {
|
|
constraints []*Constraint
|
|
}
|
|
|
|
// Return a new NewConstrainGroup
|
|
func NewConstrainGroup() *ConstraintGroup {
|
|
group := new(ConstraintGroup)
|
|
|
|
return group
|
|
}
|
|
|
|
// Return a new NewConstrainGroup and create the constraints based on a string
|
|
//
|
|
// Version constraints can be specified in a few different ways:
|
|
//
|
|
// Exact version: You can specify the exact version of a package, for
|
|
// example 1.0.2.
|
|
//
|
|
// Range: By using comparison operators you can specify ranges of valid versions.
|
|
// Valid operators are >, >=, <, <=, !=. An example range would be >=1.0. You can
|
|
// define multiple ranges, separated by a comma: >=1.0,<2.0.
|
|
//
|
|
// Wildcard: You can specify a pattern with a * wildcard. 1.0.* is the equivalent
|
|
// of >=1.0,<1.1.
|
|
//
|
|
// Next Significant Release (Tilde Operator): The ~ operator is best explained by
|
|
// example: ~1.2 is equivalent to >=1.2,<2.0, while ~1.2.3 is equivalent to
|
|
// >=1.2.3,<1.3. As you can see it is mostly useful for projects respecting
|
|
// semantic versioning. A common usage would be to mark the minimum minor
|
|
// version you depend on, like ~1.2 (which allows anything up to, but not
|
|
// including, 2.0). Since in theory there should be no backwards compatibility
|
|
// breaks until 2.0, that works well. Another way of looking at it is that
|
|
// using ~ specifies a minimum version, but allows the last digit specified
|
|
// to go up.
|
|
//
|
|
// By default only stable releases are taken into consideration. If you would like
|
|
// to also get RC, beta, alpha or dev versions of your dependencies you can do so
|
|
// using stability flags. To change that for all packages instead of doing per
|
|
// dependency you can also use the minimum-stability setting.
|
|
//
|
|
// From: http://getcomposer.org/doc/01-basic-usage.md#package-versions
|
|
func NewConstrainGroupFromString(name string) *ConstraintGroup {
|
|
group := new(ConstraintGroup)
|
|
group.fromString(name)
|
|
|
|
return group
|
|
}
|
|
|
|
// Adds a Contraint to the group
|
|
func (self *ConstraintGroup) AddConstraint(constraint ...*Constraint) {
|
|
if self.constraints == nil {
|
|
self.constraints = make([]*Constraint, 0)
|
|
}
|
|
|
|
self.constraints = append(self.constraints, constraint...)
|
|
}
|
|
|
|
// Return all the constraints
|
|
func (self *ConstraintGroup) GetConstraints() []*Constraint {
|
|
return self.constraints
|
|
}
|
|
|
|
// Match a given version againts the group
|
|
//
|
|
// Usage
|
|
// c := version.NewConstrainGroupFromString(">2.0,<=3.0")
|
|
// c.Match("2.5.0beta")
|
|
// Returns: true
|
|
//
|
|
// c := version.NewConstrainGroupFromString("~1.2.3")
|
|
// c.Match("1.2.3.5")
|
|
// Returns: true
|
|
func (self *ConstraintGroup) Match(version string) bool {
|
|
for _, constraint := range self.constraints {
|
|
if constraint.Match(version) == false {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func (self *ConstraintGroup) fromString(constraint string) bool {
|
|
result := RegFind(`(?i)^([^,\s]*?)@(stable|RC|beta|alpha|dev)$`, constraint)
|
|
if result != nil {
|
|
constraint = result[1]
|
|
if constraint == "" {
|
|
constraint = "*"
|
|
}
|
|
}
|
|
|
|
result = RegFind(`(?i)^(dev-[^,\s@]+?|[^,\s@]+?\.x-dev)#.+$`, constraint)
|
|
if result != nil {
|
|
if result[1] != "" {
|
|
constraint = result[1]
|
|
}
|
|
}
|
|
|
|
constraints := RegSplit(`\s*,\s*`, strings.Trim(constraint, " "))
|
|
|
|
if len(constraints) > 1 {
|
|
for _, part := range constraints {
|
|
self.AddConstraint(self.parseConstraint(part)...)
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
self.AddConstraint(self.parseConstraint(constraints[0])...)
|
|
|
|
return true
|
|
}
|
|
|
|
func (self *ConstraintGroup) parseConstraint(constraint string) []*Constraint {
|
|
|
|
stabilityModifier := ""
|
|
|
|
result := RegFind(`(?i)^([^,\s]+?)@(stable|RC|beta|alpha|dev)$`, constraint)
|
|
if result != nil {
|
|
constraint = result[1]
|
|
if result[2] != "stable" {
|
|
stabilityModifier = result[2]
|
|
}
|
|
}
|
|
|
|
result = RegFind(`^[x*](\.[x*])*$`, constraint)
|
|
if result != nil {
|
|
return make([]*Constraint, 0)
|
|
}
|
|
|
|
highVersion := ""
|
|
lowVersion := ""
|
|
|
|
result = RegFind(`(?i)^~(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?`+modifierRegex+`?$`, constraint)
|
|
if result != nil {
|
|
if len(result) > 4 && result[4] != "" {
|
|
last, _ := strconv.Atoi(result[3])
|
|
highVersion = result[1] + "." + result[2] + "." + strconv.Itoa(last+1) + ".0-dev"
|
|
lowVersion = result[1] + "." + result[2] + "." + result[3] + "." + result[4]
|
|
} else if len(result) > 3 && result[3] != "" {
|
|
last, _ := strconv.Atoi(result[2])
|
|
highVersion = result[1] + "." + strconv.Itoa(last+1) + ".0.0-dev"
|
|
lowVersion = result[1] + "." + result[2] + "." + result[3] + ".0"
|
|
} else {
|
|
last, _ := strconv.Atoi(result[1])
|
|
highVersion = strconv.Itoa(last+1) + ".0.0.0-dev"
|
|
if len(result) > 2 && result[2] != "" {
|
|
lowVersion = result[1] + "." + result[2] + ".0.0"
|
|
} else {
|
|
lowVersion = result[1] + ".0.0.0"
|
|
}
|
|
}
|
|
|
|
if len(result) > 5 && result[5] != "" {
|
|
lowVersion = lowVersion + "-" + expandStability(result[5])
|
|
|
|
}
|
|
|
|
if len(result) > 6 && result[6] != "" {
|
|
lowVersion = lowVersion + result[6]
|
|
}
|
|
|
|
if len(result) > 7 && result[7] != "" {
|
|
lowVersion = lowVersion + "-dev"
|
|
}
|
|
|
|
return []*Constraint{
|
|
{">=", lowVersion},
|
|
{"<", highVersion},
|
|
}
|
|
}
|
|
|
|
result = RegFind(`^(\d+)(?:\.(\d+))?(?:\.(\d+))?\.[x*]$`, constraint)
|
|
if result != nil {
|
|
if len(result) > 3 && result[3] != "" {
|
|
highVersion = result[1] + "." + result[2] + "." + result[3] + ".9999999"
|
|
if result[3] == "0" {
|
|
last, _ := strconv.Atoi(result[2])
|
|
lowVersion = result[1] + "." + strconv.Itoa(last-1) + ".9999999.9999999"
|
|
} else {
|
|
last, _ := strconv.Atoi(result[3])
|
|
lowVersion = result[1] + "." + result[2] + "." + strconv.Itoa(last-1) + ".9999999"
|
|
}
|
|
|
|
} else if len(result) > 2 && result[2] != "" {
|
|
highVersion = result[1] + "." + result[2] + ".9999999.9999999"
|
|
if result[2] == "0" {
|
|
last, _ := strconv.Atoi(result[1])
|
|
lowVersion = strconv.Itoa(last-1) + ".9999999.9999999.9999999"
|
|
} else {
|
|
last, _ := strconv.Atoi(result[2])
|
|
lowVersion = result[1] + "." + strconv.Itoa(last-1) + ".9999999.9999999"
|
|
}
|
|
|
|
} else {
|
|
highVersion = result[1] + ".9999999.9999999.9999999"
|
|
if result[1] == "0" {
|
|
return []*Constraint{{"<", highVersion}}
|
|
} else {
|
|
last, _ := strconv.Atoi(result[1])
|
|
lowVersion = strconv.Itoa(last-1) + ".9999999.9999999.9999999"
|
|
}
|
|
}
|
|
|
|
return []*Constraint{
|
|
{">", lowVersion},
|
|
{"<", highVersion},
|
|
}
|
|
}
|
|
|
|
// match operators constraints
|
|
result = RegFind(`^(<>|!=|>=?|<=?|==?)?\s*(.*)`, constraint)
|
|
if result != nil {
|
|
version := Normalize(result[2])
|
|
|
|
if stabilityModifier != "" && parseStability(version) == "stable" {
|
|
version = version + "-" + stabilityModifier
|
|
} else if result[1] == "<" {
|
|
match := RegFind(`(?i)-stable$`, result[2])
|
|
if match == nil {
|
|
version = version + "-dev"
|
|
}
|
|
}
|
|
|
|
if len(result) > 1 && result[1] != "" {
|
|
return []*Constraint{{result[1], version}}
|
|
} else {
|
|
return []*Constraint{{"=", version}}
|
|
|
|
}
|
|
}
|
|
|
|
return []*Constraint{{constraint, stabilityModifier}}
|
|
}
|
|
|
|
func RegFind(pattern, subject string) []string {
|
|
reg := regexp.MustCompile(pattern)
|
|
matched := reg.FindAllStringSubmatch(subject, -1)
|
|
|
|
if matched != nil {
|
|
return matched[0]
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func RegSplit(pattern, subject string) []string {
|
|
reg := regexp.MustCompile(pattern)
|
|
indexes := reg.FindAllStringIndex(subject, -1)
|
|
|
|
laststart := 0
|
|
result := make([]string, len(indexes)+1)
|
|
|
|
for i, element := range indexes {
|
|
result[i] = subject[laststart:element[0]]
|
|
laststart = element[1]
|
|
}
|
|
|
|
result[len(indexes)] = subject[laststart:len(subject)]
|
|
return result
|
|
}
|