1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
package slackware_com
import (
"errors"
"fmt"
"path"
"strconv"
"strings"
"unicode"
)
func VerifyPackageFile(filePath string, ascFilePath string) (bool, error) {
return true, nil
}
type PackageName struct {
Application string
Version string
Arch string
Build int
Tag string
}
func parseBuildTag(str string) (int, string, error) {
runes := []rune(str)
var v []rune
for _, r := range runes {
if !unicode.IsDigit(r) {
break
}
v = append(v, r)
}
build, err := strconv.Atoi(string(v))
if err != nil {
return 0, "", fmt.Errorf("build number: %w", err)
}
return build, str[len(v):], err
}
func NewPackageName(name string) (PackageName, error) {
strs := strings.Split(name, "-")
if len(strs) < 4 {
return PackageName{}, fmt.Errorf("badly formatted package name '%s'", name)
}
build, tag, err := parseBuildTag(strs[len(strs)-1])
if err != nil {
return PackageName{}, err
}
return PackageName{
Application: strings.Join(strs[:len(strs)-3], "-"),
Version: strs[len(strs)-3],
Arch: strs[len(strs)-2],
Build: build,
Tag: tag,
}, nil
}
func MustPackageName(name string) PackageName {
pkg, err := NewPackageName(name)
if err != nil {
panic(err)
}
return pkg
}
func NewPackageNameFromPath(filePath string) (PackageName, error) {
fileName := path.Base(filePath)
str, ok := strings.CutSuffix(fileName, path.Ext(fileName))
if !ok {
return PackageName{}, errors.New("file extension missing")
}
return NewPackageName(str)
}
func IsPackage(filePath string) bool {
ext := path.Ext(filePath)
switch ext {
case ".tbz", ".tgz", ".tlz", ".txz":
return true
default:
return false
}
}
func (p *PackageName) String() string {
return fmt.Sprintf("%s-%s-%s-%d%s", p.Application, p.Version, p.Arch, p.Build, p.Tag)
}
func (p *PackageName) AppplicationVersion() string {
return fmt.Sprintf("%s-%s", p.Application, p.Version)
}
// PackageNamePattern is the shorthand string used to specify a package.
type PackageNamePattern string
func MustPackageNamePattern(name string) PackageNamePattern {
return PackageNamePattern(name)
}
func (p *PackageNamePattern) IsMatch(pkg PackageName) bool {
return p.String() == pkg.Application ||
p.String() == fmt.Sprintf("%s-%s", pkg.Application, pkg.Version)
}
func (p *PackageNamePattern) String() string {
return string(*p)
}
|
