2017-08-01 16:43:20 +00:00
|
|
|
package main
|
2017-07-14 17:03:54 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
2017-08-01 16:43:20 +00:00
|
|
|
"sort"
|
2018-03-08 21:34:12 +00:00
|
|
|
"sync"
|
2018-04-05 12:33:31 +00:00
|
|
|
"unicode"
|
2017-07-14 17:03:54 +00:00
|
|
|
|
2019-04-23 15:53:20 +00:00
|
|
|
alpm "github.com/Jguer/go-alpm"
|
2019-10-16 21:36:08 +00:00
|
|
|
"github.com/Jguer/yay/v9/pkg/intrange"
|
|
|
|
|
2019-10-16 21:25:40 +00:00
|
|
|
"github.com/Jguer/yay/v9/pkg/stringset"
|
2019-10-16 21:36:08 +00:00
|
|
|
"github.com/Jguer/yay/v9/pkg/types"
|
2018-03-29 02:42:11 +00:00
|
|
|
rpc "github.com/mikkeloscar/aur"
|
2017-07-14 17:03:54 +00:00
|
|
|
)
|
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
// upgrade type describes a system upgrade.
|
|
|
|
type upgrade struct {
|
2017-07-14 17:03:54 +00:00
|
|
|
Name string
|
|
|
|
Repository string
|
|
|
|
LocalVersion string
|
|
|
|
RemoteVersion string
|
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upSlice is a slice of Upgrades
|
2017-08-01 16:43:20 +00:00
|
|
|
type upSlice []upgrade
|
2017-07-17 22:44:46 +00:00
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
func (u upSlice) Len() int { return len(u) }
|
|
|
|
func (u upSlice) Swap(i, j int) { u[i], u[j] = u[j], u[i] }
|
2017-07-17 22:44:46 +00:00
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
func (u upSlice) Less(i, j int) bool {
|
2018-03-26 01:28:31 +00:00
|
|
|
if u[i].Repository == u[j].Repository {
|
|
|
|
iRunes := []rune(u[i].Name)
|
|
|
|
jRunes := []rune(u[j].Name)
|
2019-10-16 21:02:50 +00:00
|
|
|
return LessRunes(iRunes, jRunes)
|
2018-03-26 01:28:31 +00:00
|
|
|
}
|
|
|
|
|
2019-02-04 16:56:02 +00:00
|
|
|
syncDB, err := alpmHandle.SyncDBs()
|
2018-03-26 01:28:31 +00:00
|
|
|
if err != nil {
|
2018-03-20 22:34:06 +00:00
|
|
|
iRunes := []rune(u[i].Repository)
|
|
|
|
jRunes := []rune(u[j].Repository)
|
2019-10-16 21:02:50 +00:00
|
|
|
return LessRunes(iRunes, jRunes)
|
2018-03-26 01:28:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
less := false
|
2019-02-04 16:56:02 +00:00
|
|
|
found := syncDB.ForEach(func(db alpm.DB) error {
|
2019-03-04 16:07:04 +00:00
|
|
|
switch db.Name() {
|
|
|
|
case u[i].Repository:
|
2018-03-26 01:28:31 +00:00
|
|
|
less = true
|
2019-03-04 16:07:04 +00:00
|
|
|
case u[j].Repository:
|
2018-03-26 01:28:31 +00:00
|
|
|
less = false
|
2019-03-04 16:07:04 +00:00
|
|
|
default:
|
2018-03-26 01:28:31 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return fmt.Errorf("")
|
|
|
|
})
|
|
|
|
|
|
|
|
if found != nil {
|
|
|
|
return less
|
2018-03-20 22:34:06 +00:00
|
|
|
}
|
2018-03-26 01:28:31 +00:00
|
|
|
|
2018-04-07 22:20:15 +00:00
|
|
|
iRunes := []rune(u[i].Repository)
|
|
|
|
jRunes := []rune(u[j].Repository)
|
2019-10-16 21:02:50 +00:00
|
|
|
return LessRunes(iRunes, jRunes)
|
2018-04-07 22:20:15 +00:00
|
|
|
|
2018-03-20 22:34:06 +00:00
|
|
|
}
|
2017-07-17 22:44:46 +00:00
|
|
|
|
2018-07-16 14:28:18 +00:00
|
|
|
func getVersionDiff(oldVersion, newVersion string) (left, right string) {
|
|
|
|
if oldVersion == newVersion {
|
2018-08-04 13:22:49 +00:00
|
|
|
return oldVersion + red(""), newVersion + green("")
|
2018-02-21 08:41:25 +00:00
|
|
|
}
|
|
|
|
|
2018-07-16 14:28:18 +00:00
|
|
|
diffPosition := 0
|
2018-04-05 12:33:31 +00:00
|
|
|
|
2018-07-16 14:28:18 +00:00
|
|
|
checkWords := func(str string, index int, words ...string) bool {
|
|
|
|
for _, word := range words {
|
|
|
|
wordLength := len(word)
|
|
|
|
nextIndex := index + 1
|
|
|
|
if (index < len(str)-wordLength) &&
|
|
|
|
(str[nextIndex:(nextIndex+wordLength)] == word) {
|
|
|
|
return true
|
2018-04-05 12:33:31 +00:00
|
|
|
}
|
2018-02-19 17:01:19 +00:00
|
|
|
}
|
2018-07-16 14:28:18 +00:00
|
|
|
return false
|
|
|
|
}
|
2018-04-05 12:33:31 +00:00
|
|
|
|
2018-07-16 14:28:18 +00:00
|
|
|
for index, char := range oldVersion {
|
|
|
|
charIsSpecial := !(unicode.IsLetter(char) || unicode.IsNumber(char))
|
2018-04-05 12:33:31 +00:00
|
|
|
|
2018-07-16 14:28:18 +00:00
|
|
|
if (index >= len(newVersion)) || (char != rune(newVersion[index])) {
|
|
|
|
if charIsSpecial {
|
|
|
|
diffPosition = index
|
2018-04-05 12:33:31 +00:00
|
|
|
}
|
2018-07-16 14:28:18 +00:00
|
|
|
break
|
|
|
|
}
|
2018-04-05 12:33:31 +00:00
|
|
|
|
2018-07-16 14:28:18 +00:00
|
|
|
if charIsSpecial ||
|
|
|
|
(((index == len(oldVersion)-1) || (index == len(newVersion)-1)) &&
|
|
|
|
((len(oldVersion) != len(newVersion)) ||
|
|
|
|
(oldVersion[index] == newVersion[index]))) ||
|
|
|
|
checkWords(oldVersion, index, "rc", "pre", "alpha", "beta") {
|
|
|
|
diffPosition = index + 1
|
2018-04-05 12:33:31 +00:00
|
|
|
}
|
2018-07-16 14:28:18 +00:00
|
|
|
}
|
2018-04-05 12:33:31 +00:00
|
|
|
|
2018-07-16 14:28:18 +00:00
|
|
|
samePart := oldVersion[0:diffPosition]
|
2018-04-05 12:33:31 +00:00
|
|
|
|
2018-07-16 14:28:18 +00:00
|
|
|
left = samePart + red(oldVersion[diffPosition:])
|
|
|
|
right = samePart + green(newVersion[diffPosition:])
|
2018-02-19 17:01:19 +00:00
|
|
|
|
2018-02-21 08:41:25 +00:00
|
|
|
return
|
2018-02-19 17:01:19 +00:00
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upList returns lists of packages to upgrade from each source.
|
2018-08-02 16:14:57 +00:00
|
|
|
func upList(warnings *aurWarnings) (upSlice, upSlice, error) {
|
2017-08-07 13:43:25 +00:00
|
|
|
local, remote, _, remoteNames, err := filterPackages()
|
2017-07-14 17:03:54 +00:00
|
|
|
if err != nil {
|
2018-03-20 16:20:09 +00:00
|
|
|
return nil, nil, err
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
var wg sync.WaitGroup
|
|
|
|
var develUp upSlice
|
2018-08-02 16:14:57 +00:00
|
|
|
var repoUp upSlice
|
|
|
|
var aurUp upSlice
|
2018-03-20 16:20:09 +00:00
|
|
|
|
2019-10-05 16:35:46 +00:00
|
|
|
var errs types.MultiError
|
2017-07-14 17:03:54 +00:00
|
|
|
|
2018-07-31 15:58:49 +00:00
|
|
|
aurdata := make(map[string]*rpc.Pkg)
|
2018-05-08 06:51:49 +00:00
|
|
|
|
2018-09-14 19:18:59 +00:00
|
|
|
if mode == modeAny || mode == modeRepo {
|
2018-05-31 15:23:15 +00:00
|
|
|
fmt.Println(bold(cyan("::") + bold(" Searching databases for updates...")))
|
2018-03-20 16:20:09 +00:00
|
|
|
wg.Add(1)
|
|
|
|
go func() {
|
2018-08-02 16:14:57 +00:00
|
|
|
repoUp, err = upRepo(local)
|
|
|
|
errs.Add(err)
|
2018-03-20 16:20:09 +00:00
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
2018-09-14 19:18:59 +00:00
|
|
|
if mode == modeAny || mode == modeAUR {
|
2018-05-31 15:23:15 +00:00
|
|
|
fmt.Println(bold(cyan("::") + bold(" Searching AUR for updates...")))
|
|
|
|
|
2018-07-31 15:58:49 +00:00
|
|
|
var _aurdata []*rpc.Pkg
|
2018-08-02 16:14:57 +00:00
|
|
|
_aurdata, err = aurInfo(remoteNames, warnings)
|
|
|
|
errs.Add(err)
|
|
|
|
if err == nil {
|
2018-07-31 15:58:49 +00:00
|
|
|
for _, pkg := range _aurdata {
|
|
|
|
aurdata[pkg.Name] = pkg
|
|
|
|
}
|
|
|
|
|
2018-05-31 15:23:15 +00:00
|
|
|
wg.Add(1)
|
|
|
|
go func() {
|
2018-08-02 16:14:57 +00:00
|
|
|
aurUp, err = upAUR(remote, aurdata)
|
|
|
|
errs.Add(err)
|
2018-05-31 15:23:15 +00:00
|
|
|
wg.Done()
|
|
|
|
}()
|
2018-07-31 15:58:49 +00:00
|
|
|
|
|
|
|
if config.Devel {
|
|
|
|
fmt.Println(bold(cyan("::") + bold(" Checking development packages...")))
|
|
|
|
wg.Add(1)
|
|
|
|
go func() {
|
|
|
|
develUp = upDevel(remote, aurdata)
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
}
|
2018-05-31 15:23:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
wg.Wait()
|
|
|
|
|
2018-07-31 15:58:49 +00:00
|
|
|
printLocalNewerThanAUR(remote, aurdata)
|
2018-05-08 06:51:49 +00:00
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
if develUp != nil {
|
2019-10-16 21:25:40 +00:00
|
|
|
names := make(stringset.StringSet)
|
2018-03-20 23:04:28 +00:00
|
|
|
for _, up := range develUp {
|
2019-10-05 17:39:31 +00:00
|
|
|
names.Set(up.Name)
|
2018-03-20 23:04:28 +00:00
|
|
|
}
|
|
|
|
for _, up := range aurUp {
|
2019-10-05 17:39:31 +00:00
|
|
|
if !names.Get(up.Name) {
|
2018-03-20 23:04:28 +00:00
|
|
|
develUp = append(develUp, up)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
aurUp = develUp
|
2018-03-20 16:20:09 +00:00
|
|
|
}
|
|
|
|
|
2018-08-02 16:14:57 +00:00
|
|
|
return aurUp, repoUp, errs.Return()
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
|
2018-07-31 15:58:49 +00:00
|
|
|
func upDevel(remote []alpm.Package, aurdata map[string]*rpc.Pkg) (toUpgrade upSlice) {
|
2018-04-27 00:25:40 +00:00
|
|
|
toUpdate := make([]alpm.Package, 0)
|
|
|
|
toRemove := make([]string, 0)
|
2018-03-08 21:34:12 +00:00
|
|
|
|
|
|
|
var mux1 sync.Mutex
|
|
|
|
var mux2 sync.Mutex
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
|
|
|
|
checkUpdate := func(vcsName string, e shaInfos) {
|
|
|
|
defer wg.Done()
|
|
|
|
|
2017-10-18 02:12:16 +00:00
|
|
|
if e.needsUpdate() {
|
2018-07-31 15:58:49 +00:00
|
|
|
if _, ok := aurdata[vcsName]; ok {
|
|
|
|
for _, pkg := range remote {
|
|
|
|
if pkg.Name() == vcsName {
|
|
|
|
mux1.Lock()
|
|
|
|
toUpdate = append(toUpdate, pkg)
|
|
|
|
mux1.Unlock()
|
|
|
|
return
|
|
|
|
}
|
2017-10-18 05:46:21 +00:00
|
|
|
}
|
|
|
|
}
|
2018-03-08 21:34:12 +00:00
|
|
|
|
|
|
|
mux2.Lock()
|
|
|
|
toRemove = append(toRemove, vcsName)
|
|
|
|
mux2.Unlock()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for vcsName, e := range savedInfo {
|
|
|
|
wg.Add(1)
|
|
|
|
go checkUpdate(vcsName, e)
|
|
|
|
}
|
|
|
|
|
|
|
|
wg.Wait()
|
|
|
|
|
|
|
|
for _, pkg := range toUpdate {
|
|
|
|
if pkg.ShouldIgnore() {
|
2018-05-08 06:51:49 +00:00
|
|
|
printIgnoringPackage(pkg, "latest-commit")
|
2018-03-08 21:34:12 +00:00
|
|
|
} else {
|
2018-03-20 16:20:09 +00:00
|
|
|
toUpgrade = append(toUpgrade, upgrade{pkg.Name(), "devel", pkg.Version(), "latest-commit"})
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
|
|
|
}
|
2018-03-08 21:34:12 +00:00
|
|
|
|
|
|
|
removeVCSPackage(toRemove)
|
2018-03-20 16:20:09 +00:00
|
|
|
return
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upAUR gathers foreign packages and checks if they have new versions.
|
2017-07-14 17:03:54 +00:00
|
|
|
// Output: Upgrade type package list.
|
2018-07-31 15:58:49 +00:00
|
|
|
func upAUR(remote []alpm.Package, aurdata map[string]*rpc.Pkg) (upSlice, error) {
|
2018-03-29 02:42:11 +00:00
|
|
|
toUpgrade := make(upSlice, 0)
|
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
for _, pkg := range remote {
|
2018-07-31 15:58:49 +00:00
|
|
|
aurPkg, ok := aurdata[pkg.Name()]
|
2018-03-20 16:20:09 +00:00
|
|
|
if !ok {
|
|
|
|
continue
|
2018-02-18 23:46:25 +00:00
|
|
|
}
|
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
if (config.TimeUpdate && (int64(aurPkg.LastModified) > pkg.BuildDate().Unix())) ||
|
|
|
|
(alpm.VerCmp(pkg.Version(), aurPkg.Version) < 0) {
|
|
|
|
if pkg.ShouldIgnore() {
|
2018-05-08 06:51:49 +00:00
|
|
|
printIgnoringPackage(pkg, aurPkg.Version)
|
2018-03-20 16:20:09 +00:00
|
|
|
} else {
|
|
|
|
toUpgrade = append(toUpgrade, upgrade{aurPkg.Name, "aur", pkg.Version(), aurPkg.Version})
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-03-20 16:20:09 +00:00
|
|
|
|
2018-03-29 02:42:11 +00:00
|
|
|
return toUpgrade, nil
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
|
2018-05-08 06:51:49 +00:00
|
|
|
func printIgnoringPackage(pkg alpm.Package, newPkgVersion string) {
|
|
|
|
left, right := getVersionDiff(pkg.Version(), newPkgVersion)
|
|
|
|
|
2018-07-30 23:19:21 +00:00
|
|
|
fmt.Printf("%s %s: ignoring package upgrade (%s => %s)\n",
|
|
|
|
yellow(bold(smallArrow)),
|
|
|
|
cyan(pkg.Name()),
|
|
|
|
left, right,
|
|
|
|
)
|
2018-05-08 06:51:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func printLocalNewerThanAUR(
|
2018-07-31 15:58:49 +00:00
|
|
|
remote []alpm.Package, aurdata map[string]*rpc.Pkg) {
|
2018-05-08 06:51:49 +00:00
|
|
|
for _, pkg := range remote {
|
2018-07-31 15:58:49 +00:00
|
|
|
aurPkg, ok := aurdata[pkg.Name()]
|
2018-05-08 06:51:49 +00:00
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
left, right := getVersionDiff(pkg.Version(), aurPkg.Version)
|
|
|
|
|
2018-07-30 23:19:21 +00:00
|
|
|
if !isDevelName(pkg.Name()) && alpm.VerCmp(pkg.Version(), aurPkg.Version) > 0 {
|
|
|
|
fmt.Printf("%s %s: local (%s) is newer than AUR (%s)\n",
|
2018-08-04 13:22:49 +00:00
|
|
|
yellow(bold(smallArrow)),
|
|
|
|
cyan(pkg.Name()),
|
|
|
|
left, right,
|
|
|
|
)
|
2018-05-08 06:51:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upRepo gathers local packages and checks if they have new versions.
|
2017-07-14 17:03:54 +00:00
|
|
|
// Output: Upgrade type package list.
|
2017-08-01 16:43:20 +00:00
|
|
|
func upRepo(local []alpm.Package) (upSlice, error) {
|
2018-07-25 01:04:17 +00:00
|
|
|
slice := upSlice{}
|
|
|
|
|
2019-02-04 16:56:02 +00:00
|
|
|
localDB, err := alpmHandle.LocalDB()
|
2017-07-14 17:03:54 +00:00
|
|
|
if err != nil {
|
2018-07-25 01:04:17 +00:00
|
|
|
return slice, err
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
|
2018-07-25 01:04:17 +00:00
|
|
|
err = alpmHandle.TransInit(alpm.TransFlagNoLock)
|
|
|
|
if err != nil {
|
|
|
|
return slice, err
|
|
|
|
}
|
2017-10-18 02:38:19 +00:00
|
|
|
|
2019-10-13 11:15:51 +00:00
|
|
|
defer func() {
|
|
|
|
err = alpmHandle.TransRelease()
|
|
|
|
}()
|
2018-07-25 01:04:17 +00:00
|
|
|
|
2019-10-13 11:15:51 +00:00
|
|
|
err = alpmHandle.SyncSysupgrade(cmdArgs.existsDouble("u", "sysupgrade"))
|
|
|
|
if err != nil {
|
|
|
|
return slice, err
|
|
|
|
}
|
|
|
|
_ = alpmHandle.TransGetAdd().ForEach(func(pkg alpm.Package) error {
|
2018-07-25 01:04:17 +00:00
|
|
|
localVer := "-"
|
|
|
|
|
2019-02-14 20:44:39 +00:00
|
|
|
if localPkg := localDB.Pkg(pkg.Name()); localPkg != nil {
|
2018-07-25 01:04:17 +00:00
|
|
|
localVer = localPkg.Version()
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
2018-07-25 01:04:17 +00:00
|
|
|
|
|
|
|
slice = append(slice, upgrade{
|
|
|
|
pkg.Name(),
|
|
|
|
pkg.DB().Name(),
|
|
|
|
localVer,
|
|
|
|
pkg.Version(),
|
|
|
|
})
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
|
2017-07-14 17:03:54 +00:00
|
|
|
return slice, nil
|
|
|
|
}
|
2017-08-01 16:43:20 +00:00
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upgradePkgs handles updating the cache and installing updates.
|
2019-10-16 21:25:40 +00:00
|
|
|
func upgradePkgs(aurUp, repoUp upSlice) (stringset.StringSet, stringset.StringSet, error) {
|
|
|
|
ignore := make(stringset.StringSet)
|
|
|
|
aurNames := make(stringset.StringSet)
|
2018-02-18 23:46:25 +00:00
|
|
|
|
2018-05-02 15:46:21 +00:00
|
|
|
allUpLen := len(repoUp) + len(aurUp)
|
|
|
|
if allUpLen == 0 {
|
2018-03-29 02:42:11 +00:00
|
|
|
return ignore, aurNames, nil
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
|
2018-06-11 18:48:20 +00:00
|
|
|
if !config.UpgradeMenu {
|
|
|
|
for _, pkg := range aurUp {
|
2019-10-05 17:39:31 +00:00
|
|
|
aurNames.Set(pkg.Name)
|
2018-06-11 18:48:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ignore, aurNames, nil
|
|
|
|
}
|
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
sort.Sort(repoUp)
|
2018-03-20 22:34:06 +00:00
|
|
|
sort.Sort(aurUp)
|
2018-05-02 15:46:21 +00:00
|
|
|
allUp := append(repoUp, aurUp...)
|
|
|
|
fmt.Printf("%s"+bold(" %d ")+"%s\n", bold(cyan("::")), allUpLen, bold("Packages to upgrade."))
|
2018-05-20 15:17:05 +00:00
|
|
|
allUp.print()
|
2017-08-01 16:43:20 +00:00
|
|
|
|
2018-04-11 03:43:51 +00:00
|
|
|
fmt.Println(bold(green(arrow + " Packages to not upgrade: (eg: 1 2 3, 1-3, ^4 or repo name)")))
|
2018-03-09 03:41:45 +00:00
|
|
|
fmt.Print(bold(green(arrow + " ")))
|
|
|
|
|
2018-04-04 20:26:07 +00:00
|
|
|
numbers, err := getInput(config.AnswerUpgrade)
|
2018-03-09 03:41:45 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
//upgrade menu asks you which packages to NOT upgrade so in this case
|
2018-04-23 17:06:56 +00:00
|
|
|
//include and exclude are kind of swapped
|
2018-03-09 03:41:45 +00:00
|
|
|
//include, exclude, other := parseNumberMenu(string(numberBuf))
|
2019-10-16 21:36:08 +00:00
|
|
|
include, exclude, otherInclude, otherExclude := intrange.ParseNumberMenu(numbers)
|
2017-08-01 16:43:20 +00:00
|
|
|
|
2018-03-09 03:41:45 +00:00
|
|
|
isInclude := len(exclude) == 0 && len(otherExclude) == 0
|
|
|
|
|
|
|
|
for i, pkg := range repoUp {
|
2019-10-05 17:39:31 +00:00
|
|
|
if isInclude && otherInclude.Get(pkg.Repository) {
|
|
|
|
ignore.Set(pkg.Name)
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
2017-08-02 21:56:45 +00:00
|
|
|
|
2019-10-05 18:23:13 +00:00
|
|
|
if isInclude && !include.Get(len(repoUp)-i+len(aurUp)) {
|
2018-03-21 16:30:00 +00:00
|
|
|
continue
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
2018-03-09 03:41:45 +00:00
|
|
|
|
2019-10-05 18:23:13 +00:00
|
|
|
if !isInclude && (exclude.Get(len(repoUp)-i+len(aurUp)) || otherExclude.Get(pkg.Repository)) {
|
2018-03-21 16:30:00 +00:00
|
|
|
continue
|
2018-01-14 17:48:16 +00:00
|
|
|
}
|
2018-03-21 16:30:00 +00:00
|
|
|
|
2019-10-05 17:39:31 +00:00
|
|
|
ignore.Set(pkg.Name)
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
|
2018-03-09 03:41:45 +00:00
|
|
|
for i, pkg := range aurUp {
|
2019-10-05 17:39:31 +00:00
|
|
|
if isInclude && otherInclude.Get(pkg.Repository) {
|
2018-03-09 03:41:45 +00:00
|
|
|
continue
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
|
2019-10-05 18:23:13 +00:00
|
|
|
if isInclude && !include.Get(len(aurUp)-i) {
|
2019-10-05 17:39:31 +00:00
|
|
|
aurNames.Set(pkg.Name)
|
2018-03-09 03:41:45 +00:00
|
|
|
}
|
|
|
|
|
2019-10-05 18:23:13 +00:00
|
|
|
if !isInclude && (exclude.Get(len(aurUp)-i) || otherExclude.Get(pkg.Repository)) {
|
2019-10-05 17:39:31 +00:00
|
|
|
aurNames.Set(pkg.Name)
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
}
|
2018-01-20 22:37:10 +00:00
|
|
|
|
2018-03-21 16:30:00 +00:00
|
|
|
return ignore, aurNames, err
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|