semver

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 25, 2016 License: MIT, Apache-2.0 Imports: 7 Imported by: 0

README

semver for golang Build Status GoDoc Coverage Status

semver is a Semantic Versioning library written in golang. It fully covers spec version 2.0.0.

Usage

$ go get github.com/blang/semver

Note: Always vendor your dependencies or fix on a specific version tag.

import github.com/blang/semver
v1, err := semver.Make("1.0.0-beta")
v2, err := semver.Make("2.0.0-beta")
v1.Compare(v2)

Also check the GoDocs.

Why should I use this lib?

  • Fully spec compatible
  • No reflection
  • No regex
  • Fully tested (Coverage >99%)
  • Readable parsing/validation errors
  • Fast (See Benchmarks)
  • Only Stdlib
  • Uses values instead of pointers
  • Many features, see below

Features

  • Parsing and validation at all levels
  • Comparator-like comparisons
  • Compare Helper Methods
  • InPlace manipulation
  • Sortable (implements sort.Interface)
  • database/sql compatible (sql.Scanner/Valuer)
  • encoding/json compatible (json.Marshaler/Unmarshaler)

Example

Have a look at full examples in examples/main.go

import github.com/blang/semver

v, err := semver.Make("0.0.1-alpha.preview+123.github")
fmt.Printf("Major: %d\n", v.Major)
fmt.Printf("Minor: %d\n", v.Minor)
fmt.Printf("Patch: %d\n", v.Patch)
fmt.Printf("Pre: %s\n", v.Pre)
fmt.Printf("Build: %s\n", v.Build)

// Prerelease versions array
if len(v.Pre) > 0 {
    fmt.Println("Prerelease versions:")
    for i, pre := range v.Pre {
        fmt.Printf("%d: %q\n", i, pre)
    }
}

// Build meta data array
if len(v.Build) > 0 {
    fmt.Println("Build meta data:")
    for i, build := range v.Build {
        fmt.Printf("%d: %q\n", i, build)
    }
}

v001, err := semver.Make("0.0.1")
// Compare using helpers: v.GT(v2), v.LT, v.GTE, v.LTE
v001.GT(v) == true
v.LT(v001) == true
v.GTE(v) == true
v.LTE(v) == true

// Or use v.Compare(v2) for comparisons (-1, 0, 1):
v001.Compare(v) == 1
v.Compare(v001) == -1
v.Compare(v) == 0

// Manipulate Version in place:
v.Pre[0], err = semver.NewPRVersion("beta")
if err != nil {
    fmt.Printf("Error parsing pre release version: %q", err)
}

fmt.Println("\nValidate versions:")
v.Build[0] = "?"

err = v.Validate()
if err != nil {
    fmt.Printf("Validation failed: %s\n", err)
}

Benchmarks

BenchmarkParseSimple         5000000      328    ns/op    49 B/op   1 allocs/op
BenchmarkParseComplex        1000000     2105    ns/op   263 B/op   7 allocs/op
BenchmarkParseAverage        1000000     1301    ns/op   168 B/op   4 allocs/op
BenchmarkStringSimple       10000000      130    ns/op     5 B/op   1 allocs/op
BenchmarkStringLarger        5000000      280    ns/op    32 B/op   2 allocs/op
BenchmarkStringComplex       3000000      512    ns/op    80 B/op   3 allocs/op
BenchmarkStringAverage       5000000      387    ns/op    47 B/op   2 allocs/op
BenchmarkValidateSimple    500000000        7.92 ns/op     0 B/op   0 allocs/op
BenchmarkValidateComplex     2000000      923    ns/op     0 B/op   0 allocs/op
BenchmarkValidateAverage     5000000      452    ns/op     0 B/op   0 allocs/op
BenchmarkCompareSimple     100000000       11.2  ns/op     0 B/op   0 allocs/op
BenchmarkCompareComplex     50000000       40.9  ns/op     0 B/op   0 allocs/op
BenchmarkCompareAverage     50000000       43.8  ns/op     0 B/op   0 allocs/op
BenchmarkSort                5000000      436    ns/op   259 B/op   2 allocs/op

See benchmark cases at semver_test.go

Motivation

I simply couldn't find any lib supporting the full spec. Others were just wrong or used reflection and regex which i don't like.

Contribution

Feel free to make a pull request. For bigger changes create a issue first to discuss about it.

License

See LICENSE file.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var SpecVersion = Version{
	Major: 2,
	Minor: 0,
	Patch: 0,
}

SpecVersion is the latest fully supported spec version of semver

Functions

func NewBuildVersion 

func NewBuildVersion(s string) (string, error)

NewBuildVersion creates a new valid build version

func Sort 

func Sort(versions []Version)

Sort sorts a slice of versions

Types

type PRVersion 

type PRVersion struct {
	VersionStr string
	VersionNum uint64
	IsNum      bool
}

PRVersion represents a PreRelease Version

func NewPRVersion 

func NewPRVersion(s string) (PRVersion, error)

NewPRVersion creates a new valid prerelease version

func (PRVersion) Compare 

func (v PRVersion) Compare(o PRVersion) int

Compare compares two PreRelease Versions v and o: -1 == v is less than o 0 == v is equal to o 1 == v is greater than o

func (PRVersion) IsNumeric 

func (v PRVersion) IsNumeric() bool

IsNumeric checks if prerelease-version is numeric

func (PRVersion) String 

func (v PRVersion) String() string

PreRelease version to string

type Version 

type Version struct {
	Major uint64
	Minor uint64
	Patch uint64
	Pre   []PRVersion
	Build []string //No Precendence
}

Version represents a semver compatible version

func Make 

func Make(s string) (Version, error)

Make is an alias for Parse, parses version string and returns a validated Version or error

func MustParse 

func MustParse(s string) Version

MustParse is like Parse but panics if the version cannot be parsed.

func New 

func New(s string) (vp *Version, err error)

New is an alias for Parse and returns a pointer, parses version string and returns a validated Version or error

func Parse 

func Parse(s string) (Version, error)

Parse parses version string and returns a validated Version or error

func (Version) Compare 

func (v Version) Compare(o Version) int

Compare compares Versions v to o: -1 == v is less than o 0 == v is equal to o 1 == v is greater than o

func (Version) EQ 

func (v Version) EQ(o Version) bool

EQ checks if v is equal to o.

func (Version) Equals 

func (v Version) Equals(o Version) bool

Equals checks if v is equal to o.

func (Version) GE 

func (v Version) GE(o Version) bool

GE checks if v is greater than or equal to o.

func (Version) GT 

func (v Version) GT(o Version) bool

GT checks if v is greater than o.

func (Version) GTE 

func (v Version) GTE(o Version) bool

GTE checks if v is greater than or equal to o.

func (Version) LE 

func (v Version) LE(o Version) bool

LE checks if v is less than or equal to o.

func (Version) LT 

func (v Version) LT(o Version) bool

LT checks if v is less than o.

func (Version) LTE 

func (v Version) LTE(o Version) bool

LTE checks if v is less than or equal to o.

func (Version) MarshalJSON 

func (v Version) MarshalJSON() ([]byte, error)

MarshalJSON implements the encoding/json.Marshaler interface.

func (Version) NE 

func (v Version) NE(o Version) bool

NE checks if v is not equal to o.

func (*Version) Scan 

func (v *Version) Scan(src interface{}) (err error)

Scan implements the database/sql.Scanner interface.

func (Version) String 

func (v Version) String() string

Version to string

func (*Version) UnmarshalJSON 

func (v *Version) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON implements the encoding/json.Unmarshaler interface.

func (Version) Validate 

func (v Version) Validate() error

Validate validates v and returns error in case

func (Version) Value 

func (v Version) Value() (driver.Value, error)

Value implements the database/sql/driver.Valuer interface.

type Versions 

type Versions []Version

Versions represents multiple versions.

func (Versions) Len 

func (s Versions) Len() int

Len returns length of version collection

func (Versions) Less 

func (s Versions) Less(i, j int) bool

Less checks if version at index i is less than version at index j

func (Versions) Swap 

func (s Versions) Swap(i, j int)

Swap swaps two versions inside the collection by its indices

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.