vendor: check in vendors

Bye bye glide...

1 files changed, 269 insertions, 0 deletions

diff --git a/vendor/github.com/mcuadros/go-version/group.go b/vendor/github.com/mcuadros/go-version/group.go
new file mode 100644
index 00000000..b25a30c0
--- /dev/null
+++ b/vendor/github.com/mcuadros/go-version/group.go
@@ -0,0 +1,269 @@
+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
+}