vendor/github.com/blang/semver/semver.go

   1 package semver
   2
   3 import (
   4         "errors"
   5         "fmt"
   6         "strconv"
   7         "strings"
   8 )
   9
  10 const (
  11         numbers  string = "0123456789"
  12         alphas          = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-"
  13         alphanum        = alphas + numbers
  14 )
  15
  16 // SpecVersion is the latest fully supported spec version of semver
  17 var SpecVersion = Version{
  18         Major: 2,
  19         Minor: 0,
  20         Patch: 0,
  21 }
  22
  23 // Version represents a semver compatible version
  24 type Version struct {
  25         Major uint64
  26         Minor uint64
  27         Patch uint64
  28         Pre   []PRVersion
  29         Build []string //No Precendence
  30 }
  31
  32 // Version to string
  33 func (v Version) String() string {
  34         b := make([]byte, 0, 5)
  35         b = strconv.AppendUint(b, v.Major, 10)
  36         b = append(b, '.')
  37         b = strconv.AppendUint(b, v.Minor, 10)
  38         b = append(b, '.')
  39         b = strconv.AppendUint(b, v.Patch, 10)
  40
  41         if len(v.Pre) > 0 {
  42                 b = append(b, '-')
  43                 b = append(b, v.Pre[0].String()...)
  44
  45                 for _, pre := range v.Pre[1:] {
  46                         b = append(b, '.')
  47                         b = append(b, pre.String()...)
  48                 }
  49         }
  50
  51         if len(v.Build) > 0 {
  52                 b = append(b, '+')
  53                 b = append(b, v.Build[0]...)
  54
  55                 for _, build := range v.Build[1:] {
  56                         b = append(b, '.')
  57                         b = append(b, build...)
  58                 }
  59         }
  60
  61         return string(b)
  62 }
  63
  64 // Equals checks if v is equal to o.
  65 func (v Version) Equals(o Version) bool {
  66         return (v.Compare(o) == 0)
  67 }
  68
  69 // EQ checks if v is equal to o.
  70 func (v Version) EQ(o Version) bool {
  71         return (v.Compare(o) == 0)
  72 }
  73
  74 // NE checks if v is not equal to o.
  75 func (v Version) NE(o Version) bool {
  76         return (v.Compare(o) != 0)
  77 }
  78
  79 // GT checks if v is greater than o.
  80 func (v Version) GT(o Version) bool {
  81         return (v.Compare(o) == 1)
  82 }
  83
  84 // GTE checks if v is greater than or equal to o.
  85 func (v Version) GTE(o Version) bool {
  86         return (v.Compare(o) >= 0)
  87 }
  88
  89 // GE checks if v is greater than or equal to o.
  90 func (v Version) GE(o Version) bool {
  91         return (v.Compare(o) >= 0)
  92 }
  93
  94 // LT checks if v is less than o.
  95 func (v Version) LT(o Version) bool {
  96         return (v.Compare(o) == -1)
  97 }
  98
  99 // LTE checks if v is less than or equal to o.
 100 func (v Version) LTE(o Version) bool {
 101         return (v.Compare(o) <= 0)
 102 }
 103
 104 // LE checks if v is less than or equal to o.
 105 func (v Version) LE(o Version) bool {
 106         return (v.Compare(o) <= 0)
 107 }
 108
 109 // Compare compares Versions v to o:
 110 // -1 == v is less than o
 111 // 0 == v is equal to o
 112 // 1 == v is greater than o
 113 func (v Version) Compare(o Version) int {
 114         if v.Major != o.Major {
 115                 if v.Major > o.Major {
 116                         return 1
 117                 }
 118                 return -1
 119         }
 120         if v.Minor != o.Minor {
 121                 if v.Minor > o.Minor {
 122                         return 1
 123                 }
 124                 return -1
 125         }
 126         if v.Patch != o.Patch {
 127                 if v.Patch > o.Patch {
 128                         return 1
 129                 }
 130                 return -1
 131         }
 132
 133         // Quick comparison if a version has no prerelease versions
 134         if len(v.Pre) == 0 && len(o.Pre) == 0 {
 135                 return 0
 136         } else if len(v.Pre) == 0 && len(o.Pre) > 0 {
 137                 return 1
 138         } else if len(v.Pre) > 0 && len(o.Pre) == 0 {
 139                 return -1
 140         }
 141
 142         i := 0
 143         for ; i < len(v.Pre) && i < len(o.Pre); i++ {
 144                 if comp := v.Pre[i].Compare(o.Pre[i]); comp == 0 {
 145                         continue
 146                 } else if comp == 1 {
 147                         return 1
 148                 } else {
 149                         return -1
 150                 }
 151         }
 152
 153         // If all pr versions are the equal but one has further prversion, this one greater
 154         if i == len(v.Pre) && i == len(o.Pre) {
 155                 return 0
 156         } else if i == len(v.Pre) && i < len(o.Pre) {
 157                 return -1
 158         } else {
 159                 return 1
 160         }
 161
 162 }
 163
 164 // Validate validates v and returns error in case
 165 func (v Version) Validate() error {
 166         // Major, Minor, Patch already validated using uint64
 167
 168         for _, pre := range v.Pre {
 169                 if !pre.IsNum { //Numeric prerelease versions already uint64
 170                         if len(pre.VersionStr) == 0 {
 171                                 return fmt.Errorf("Prerelease can not be empty %q", pre.VersionStr)
 172                         }
 173                         if !containsOnly(pre.VersionStr, alphanum) {
 174                                 return fmt.Errorf("Invalid character(s) found in prerelease %q", pre.VersionStr)
 175                         }
 176                 }
 177         }
 178
 179         for _, build := range v.Build {
 180                 if len(build) == 0 {
 181                         return fmt.Errorf("Build meta data can not be empty %q", build)
 182                 }
 183                 if !containsOnly(build, alphanum) {
 184                         return fmt.Errorf("Invalid character(s) found in build meta data %q", build)
 185                 }
 186         }
 187
 188         return nil
 189 }
 190
 191 // New is an alias for Parse and returns a pointer, parses version string and returns a validated Version or error
 192 func New(s string) (vp *Version, err error) {
 193         v, err := Parse(s)
 194         vp = &v
 195         return
 196 }
 197
 198 // Make is an alias for Parse, parses version string and returns a validated Version or error
 199 func Make(s string) (Version, error) {
 200         return Parse(s)
 201 }
 202
 203 // ParseTolerant allows for certain version specifications that do not strictly adhere to semver
 204 // specs to be parsed by this library. It does so by normalizing versions before passing them to
 205 // Parse(). It currently trims spaces, removes a "v" prefix, and adds a 0 patch number to versions
 206 // with only major and minor components specified
 207 func ParseTolerant(s string) (Version, error) {
 208         s = strings.TrimSpace(s)
 209         s = strings.TrimPrefix(s, "v")
 210
 211         // Split into major.minor.(patch+pr+meta)
 212         parts := strings.SplitN(s, ".", 3)
 213         if len(parts) < 3 {
 214                 if strings.ContainsAny(parts[len(parts)-1], "+-") {
 215                         return Version{}, errors.New("Short version cannot contain PreRelease/Build meta data")
 216                 }
 217                 for len(parts) < 3 {
 218                         parts = append(parts, "0")
 219                 }
 220                 s = strings.Join(parts, ".")
 221         }
 222
 223         return Parse(s)
 224 }
 225
 226 // Parse parses version string and returns a validated Version or error
 227 func Parse(s string) (Version, error) {
 228         if len(s) == 0 {
 229                 return Version{}, errors.New("Version string empty")
 230         }
 231
 232         // Split into major.minor.(patch+pr+meta)
 233         parts := strings.SplitN(s, ".", 3)
 234         if len(parts) != 3 {
 235                 return Version{}, errors.New("No Major.Minor.Patch elements found")
 236         }
 237
 238         // Major
 239         if !containsOnly(parts[0], numbers) {
 240                 return Version{}, fmt.Errorf("Invalid character(s) found in major number %q", parts[0])
 241         }
 242         if hasLeadingZeroes(parts[0]) {
 243                 return Version{}, fmt.Errorf("Major number must not contain leading zeroes %q", parts[0])
 244         }
 245         major, err := strconv.ParseUint(parts[0], 10, 64)
 246         if err != nil {
 247                 return Version{}, err
 248         }
 249
 250         // Minor
 251         if !containsOnly(parts[1], numbers) {
 252                 return Version{}, fmt.Errorf("Invalid character(s) found in minor number %q", parts[1])
 253         }
 254         if hasLeadingZeroes(parts[1]) {
 255                 return Version{}, fmt.Errorf("Minor number must not contain leading zeroes %q", parts[1])
 256         }
 257         minor, err := strconv.ParseUint(parts[1], 10, 64)
 258         if err != nil {
 259                 return Version{}, err
 260         }
 261
 262         v := Version{}
 263         v.Major = major
 264         v.Minor = minor
 265
 266         var build, prerelease []string
 267         patchStr := parts[2]
 268
 269         if buildIndex := strings.IndexRune(patchStr, '+'); buildIndex != -1 {
 270                 build = strings.Split(patchStr[buildIndex+1:], ".")
 271                 patchStr = patchStr[:buildIndex]
 272         }
 273
 274         if preIndex := strings.IndexRune(patchStr, '-'); preIndex != -1 {
 275                 prerelease = strings.Split(patchStr[preIndex+1:], ".")
 276                 patchStr = patchStr[:preIndex]
 277         }
 278
 279         if !containsOnly(patchStr, numbers) {
 280                 return Version{}, fmt.Errorf("Invalid character(s) found in patch number %q", patchStr)
 281         }
 282         if hasLeadingZeroes(patchStr) {
 283                 return Version{}, fmt.Errorf("Patch number must not contain leading zeroes %q", patchStr)
 284         }
 285         patch, err := strconv.ParseUint(patchStr, 10, 64)
 286         if err != nil {
 287                 return Version{}, err
 288         }
 289
 290         v.Patch = patch
 291
 292         // Prerelease
 293         for _, prstr := range prerelease {
 294                 parsedPR, err := NewPRVersion(prstr)
 295                 if err != nil {
 296                         return Version{}, err
 297                 }
 298                 v.Pre = append(v.Pre, parsedPR)
 299         }
 300
 301         // Build meta data
 302         for _, str := range build {
 303                 if len(str) == 0 {
 304                         return Version{}, errors.New("Build meta data is empty")
 305                 }
 306                 if !containsOnly(str, alphanum) {
 307                         return Version{}, fmt.Errorf("Invalid character(s) found in build meta data %q", str)
 308                 }
 309                 v.Build = append(v.Build, str)
 310         }
 311
 312         return v, nil
 313 }
 314
 315 // MustParse is like Parse but panics if the version cannot be parsed.
 316 func MustParse(s string) Version {
 317         v, err := Parse(s)
 318         if err != nil {
 319                 panic(`semver: Parse(` + s + `): ` + err.Error())
 320         }
 321         return v
 322 }
 323
 324 // PRVersion represents a PreRelease Version
 325 type PRVersion struct {
 326         VersionStr string
 327         VersionNum uint64
 328         IsNum      bool
 329 }
 330
 331 // NewPRVersion creates a new valid prerelease version
 332 func NewPRVersion(s string) (PRVersion, error) {
 333         if len(s) == 0 {
 334                 return PRVersion{}, errors.New("Prerelease is empty")
 335         }
 336         v := PRVersion{}
 337         if containsOnly(s, numbers) {
 338                 if hasLeadingZeroes(s) {
 339                         return PRVersion{}, fmt.Errorf("Numeric PreRelease version must not contain leading zeroes %q", s)
 340                 }
 341                 num, err := strconv.ParseUint(s, 10, 64)
 342
 343                 // Might never be hit, but just in case
 344                 if err != nil {
 345                         return PRVersion{}, err
 346                 }
 347                 v.VersionNum = num
 348                 v.IsNum = true
 349         } else if containsOnly(s, alphanum) {
 350                 v.VersionStr = s
 351                 v.IsNum = false
 352         } else {
 353                 return PRVersion{}, fmt.Errorf("Invalid character(s) found in prerelease %q", s)
 354         }
 355         return v, nil
 356 }
 357
 358 // IsNumeric checks if prerelease-version is numeric
 359 func (v PRVersion) IsNumeric() bool {
 360         return v.IsNum
 361 }
 362
 363 // Compare compares two PreRelease Versions v and o:
 364 // -1 == v is less than o
 365 // 0 == v is equal to o
 366 // 1 == v is greater than o
 367 func (v PRVersion) Compare(o PRVersion) int {
 368         if v.IsNum && !o.IsNum {
 369                 return -1
 370         } else if !v.IsNum && o.IsNum {
 371                 return 1
 372         } else if v.IsNum && o.IsNum {
 373                 if v.VersionNum == o.VersionNum {
 374                         return 0
 375                 } else if v.VersionNum > o.VersionNum {
 376                         return 1
 377                 } else {
 378                         return -1
 379                 }
 380         } else { // both are Alphas
 381                 if v.VersionStr == o.VersionStr {
 382                         return 0
 383                 } else if v.VersionStr > o.VersionStr {
 384                         return 1
 385                 } else {
 386                         return -1
 387                 }
 388         }
 389 }
 390
 391 // PreRelease version to string
 392 func (v PRVersion) String() string {
 393         if v.IsNum {
 394                 return strconv.FormatUint(v.VersionNum, 10)
 395         }
 396         return v.VersionStr
 397 }
 398
 399 func containsOnly(s string, set string) bool {
 400         return strings.IndexFunc(s, func(r rune) bool {
 401                 return !strings.ContainsRune(set, r)
 402         }) == -1
 403 }
 404
 405 func hasLeadingZeroes(s string) bool {
 406         return len(s) > 1 && s[0] == '0'
 407 }
 408
 409 // NewBuildVersion creates a new valid build version
 410 func NewBuildVersion(s string) (string, error) {
 411         if len(s) == 0 {
 412                 return "", errors.New("Buildversion is empty")
 413         }
 414         if !containsOnly(s, alphanum) {
 415                 return "", fmt.Errorf("Invalid character(s) found in build meta data %q", s)
 416         }
 417         return s, nil
 418 }