developer/galaxy-game
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

fs storage

Browse Source
This commit is contained in:
Ilia Denisov
2026-03-13 21:07:23 +02:00
committed by GitHub
parent 43039a79bf
commit 9ade76e21d
117 changed files with 1734 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/util/semver.go
+120
View File
@@ -0,0 +1,120 @@
package util
import (
"cmp"
"fmt"
"strconv"
"strings"
)
// SemVer stores a numeric semantic version as major, minor, patch, and build
// components. Components that are not provided are represented as zero values.
type SemVer struct {
Major uint
Minor uint
Patch uint
Build uint
}
// NewSemver constructs a SemVer from v.
//
// NewSemver requires between one and four components ordered as major, minor,
// patch, and build. Components that are not provided are set to zero.
func NewSemver(v ...uint) (SemVer, error) {
s := &SemVer{}
switch len(v) {
case 4:
s.Build = v[3]
fallthrough
case 3:
s.Patch = v[2]
fallthrough
case 2:
s.Minor = v[1]
fallthrough
case 1:
s.Major = v[0]
default:
return *s, fmt.Errorf("new semver: incorrect args count: %d", len(v))
}
return *s, nil
}
// MustSemver returns the SemVer produced by NewSemver(v...).
//
// MustSemver panics if NewSemver returns an error.
func MustSemver(v ...uint) SemVer {
if v, err := NewSemver(v...); err != nil {
panic(err)
} else {
return v
}
}
// ParseSemver parses input into a SemVer.
//
// ParseSemver accepts versions with one to four numeric components separated by
// dots, for example "1", "1.2", "1.2.3", or "1.2.3.4". The input may also use
// the optional "v" or "v." prefix. Missing minor, patch, and build components
// are set to zero.
func ParseSemver(input string) (SemVer, error) {
source := input
switch {
case strings.HasPrefix(input, "v."):
input = strings.TrimPrefix(input, "v.")
case strings.HasPrefix(input, "v"):
input = strings.TrimPrefix(input, "v")
}
if input == "" {
return SemVer{}, fmt.Errorf("parse semver %q: missing major version", source)
}
parts := strings.Split(input, ".")
if len(parts) > 4 {
return SemVer{}, fmt.Errorf("parse semver %q: too many version parts: %d", source, len(parts))
}
values := make([]uint, 0, len(parts))
for idx, part := range parts {
if part == "" {
return SemVer{}, fmt.Errorf("parse semver %q: empty version part at position %d", source, idx+1)
}
value, err := strconv.ParseUint(part, 10, 0)
if err != nil {
return SemVer{}, fmt.Errorf("parse semver %q: parse part %q at position %d: %w", source, part, idx+1, err)
}
values = append(values, uint(value))
}
version, err := NewSemver(values...)
if err != nil {
return SemVer{}, fmt.Errorf("parse semver %q: %w", source, err)
}
return version, nil
}
// ParserSemver calls ParseSemver.
//
// Deprecated: use ParseSemver.
func ParserSemver(input string) (SemVer, error) {
return ParseSemver(input)
}
// CompareSemver compares two semantic versions and returns:
//
// +1 if x is less than y,
// 0 if x equals y,
// -1 if x is greater than y.
func CompareSemver(x, y SemVer) int {
return cmp.Or(
cmp.Compare(y.Major, x.Major),
cmp.Compare(y.Minor, x.Minor),
cmp.Compare(y.Patch, x.Patch),
cmp.Compare(y.Build, x.Build),
)
}
pkg/util/semver_test.go
+280
View File
@@ -0,0 +1,280 @@
package util_test
import (
"testing"
"galaxy/util"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestNewSemver(t *testing.T) {
t.Parallel()
tests := []struct {
name string
input []uint
want util.SemVer
wantErr string
}{
{
name: "major only",
input: []uint{1},
want: util.SemVer{Major: 1},
},
{
name: "major and minor",
input: []uint{1, 2},
want: util.SemVer{Major: 1, Minor: 2},
},
{
name: "major minor and patch",
input: []uint{1, 2, 3},
want: util.SemVer{Major: 1, Minor: 2, Patch: 3},
},
{
name: "all components",
input: []uint{1, 2, 3, 4},
want: util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
},
{
name: "missing major",
input: nil,
wantErr: "incorrect args count: 0",
},
{
name: "too many components",
input: []uint{1, 2, 3, 4, 5},
wantErr: "incorrect args count: 5",
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
got, err := util.NewSemver(tt.input...)
if tt.wantErr != "" {
require.Error(t, err)
assert.Contains(t, err.Error(), tt.wantErr)
assert.Equal(t, util.SemVer{}, got)
return
}
require.NoError(t, err)
assert.Equal(t, tt.want, got)
})
}
}
func TestMustSemver(t *testing.T) {
t.Parallel()
t.Run("returns version", func(t *testing.T) {
t.Parallel()
assert.Equal(t, util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4}, util.MustSemver(1, 2, 3, 4))
})
t.Run("panics on invalid input", func(t *testing.T) {
t.Parallel()
var recovered any
func() {
defer func() {
recovered = recover()
}()
util.MustSemver()
}()
require.NotNil(t, recovered)
err, ok := recovered.(error)
require.True(t, ok)
assert.EqualError(t, err, "new semver: incorrect args count: 0")
})
}
func TestParseSemver(t *testing.T) {
t.Parallel()
tests := []struct {
name string
input string
want util.SemVer
wantErr string
}{
{
name: "major only",
input: "1",
want: util.SemVer{Major: 1},
},
{
name: "major and minor",
input: "1.2",
want: util.SemVer{Major: 1, Minor: 2},
},
{
name: "major minor and patch",
input: "1.2.3",
want: util.SemVer{Major: 1, Minor: 2, Patch: 3},
},
{
name: "all components",
input: "1.2.3.4",
want: util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
},
{
name: "v prefix",
input: "v2.3.4.5",
want: util.SemVer{Major: 2, Minor: 3, Patch: 4, Build: 5},
},
{
name: "v dot prefix",
input: "v.6.7.8.9",
want: util.SemVer{Major: 6, Minor: 7, Patch: 8, Build: 9},
},
{
name: "leading zeros",
input: "v.01.002.0003.0004",
want: util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
},
{
name: "empty input",
input: "",
wantErr: "missing major version",
},
{
name: "prefix without version",
input: "v",
wantErr: "missing major version",
},
{
name: "prefix with dot without version",
input: "v.",
wantErr: "missing major version",
},
{
name: "leading dot",
input: ".1",
wantErr: "empty version part at position 1",
},
{
name: "trailing dot",
input: "1.",
wantErr: "empty version part at position 2",
},
{
name: "empty middle part",
input: "1..2",
wantErr: "empty version part at position 2",
},
{
name: "too many parts",
input: "1.2.3.4.5",
wantErr: "too many version parts: 5",
},
{
name: "non numeric part",
input: "1.2.beta",
wantErr: `parse part "beta"`,
},
{
name: "negative part",
input: "1.-2",
wantErr: `parse part "-2"`,
},
{
name: "spaces are not accepted",
input: " 1.2 ",
wantErr: `parse part " 1"`,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
got, err := util.ParseSemver(tt.input)
if tt.wantErr != "" {
require.Error(t, err)
assert.Contains(t, err.Error(), tt.wantErr)
assert.Equal(t, util.SemVer{}, got)
return
}
require.NoError(t, err)
assert.Equal(t, tt.want, got)
})
}
}
func TestParserSemver(t *testing.T) {
t.Parallel()
got, err := util.ParserSemver("v1.2.3.4")
require.NoError(t, err)
assert.Equal(t, util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4}, got)
}
func TestCompareSemver(t *testing.T) {
t.Parallel()
tests := []struct {
name string
x util.SemVer
y util.SemVer
want int
}{
{
name: "equal versions",
x: util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
y: util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
want: 0,
},
{
name: "x less by major",
x: util.SemVer{Major: 1, Minor: 9, Patch: 9, Build: 9},
y: util.SemVer{Major: 2},
want: 1,
},
{
name: "x greater by major",
x: util.SemVer{Major: 2},
y: util.SemVer{Major: 1, Minor: 9, Patch: 9, Build: 9},
want: -1,
},
{
name: "x less by minor",
x: util.SemVer{Major: 1, Minor: 1, Patch: 9, Build: 9},
y: util.SemVer{Major: 1, Minor: 2},
want: 1,
},
{
name: "x less by patch",
x: util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 9},
y: util.SemVer{Major: 1, Minor: 2, Patch: 4},
want: 1,
},
{
name: "x less by build",
x: util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
y: util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 5},
want: 1,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
assert.Equal(t, tt.want, util.CompareSemver(tt.x, tt.y))
})
}
}