mirror/yay
0
0
Fork 0
mirror of https://github.com/Jguer/yay.git synced 2024-11-06 17:17:22 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #113 from Jguer/colorPrint

Browse Source 
Color print
This commit is contained in:
J Guerreiro 2018-01-26 15:27:50 +00:00 committed by GitHub
commit b69bab8c51
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 221 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
cmd.go
View File

@ -561,9 +561,9 @@ func numberMenu(pkgS []string, flags []string) (err error) {
aurQ.printSearch(numpq + 1)
}
fmt.Printf("\x1b[32m%s %s\x1b[0m\nNumbers: ",
"Type the numbers or ranges (e.g. 1-10) you want to install.",
"Separate each one of them with a space.")
fmt.Println(greenFg("Type the numbers or ranges (e.g. 1-10) you want to install. " +
"Separate each one of them with a space."))
fmt.Print("Numbers: ")
reader := bufio.NewReader(os.Stdin)
numberBuf, overflow, err := reader.ReadLine()
if err != nil || overflow {
@ -673,7 +673,8 @@ func passToMakepkg(dir string, args ...string) (err error) {
if err == nil {
_ = saveVCSInfo()
if config.CleanAfter {
fmt.Println("\x1b[1;32m==> CleanAfter enabled. Deleting source folder.\x1b[0m")
fmt.Println(boldGreenFg(arrow +
" CleanAfter enabled. Deleting source folder."))
os.RemoveAll(dir)
}
}

8
config.go
View File

@ -146,10 +146,12 @@ func editor() string {
}
fallthrough
default:
fmt.Printf("\x1b[1;31;40mWarning: \x1B[1;33;40m$EDITOR\x1b[0;37;40m is not set.\x1b[0m\nPlease add $EDITOR or to your environment variables.\n")
fmt.Println(boldRedFgBlackBg("Warning:"),
boldYellowFgBlackBg("$EDITOR"), whiteFgBlackBg("is not set"))
fmt.Println("Please add $EDITOR or to your environment variables.")
editorLoop:
fmt.Printf("\x1b[32m%s\x1b[0m ", "Edit PKGBUILD with:")
fmt.Print(greenFg("Edit PKGBUILD with:"))
var editorInput string
_, err := fmt.Scanln(&editorInput)
if err != nil {
@ -181,7 +183,7 @@ func continueTask(s string, def string) (cont bool) {
}
var response string
fmt.Printf("\x1b[1;32m==> %s\x1b[1;37m %s\x1b[0m", s, postFix)
fmt.Println(boldGreenFg(arrow+" "+s), boldWhiteFg(postFix))
n, err := fmt.Scanln(&response)
if err != nil || n == 0 {

4
download.go
View File

@ -97,7 +97,7 @@ func getPkgbuildfromABS(pkgN string, path string) (err error) {
} else {
return fmt.Errorf("Not in standard repositories")
}
fmt.Printf("\x1b[1;32m==>\x1b[1;33m %s \x1b[1;32mfound in ABS.\x1b[0m\n", pkgN)
fmt.Println(boldGreenFg(arrow), boldYellowFg(pkgN), boldGreenFg("found in ABS."))
errD := downloadAndUnpack(url, path, true)
return errD
}
@ -116,7 +116,7 @@ func getPkgbuildfromAUR(pkgN string, dir string) (err error) {
return fmt.Errorf("no results")
}
fmt.Printf("\x1b[1;32m==>\x1b[1;33m %s \x1b[1;32mfound in AUR.\x1b[0m\n", pkgN)
fmt.Println(boldGreenFg(arrow), boldYellowFg(pkgN), boldGreenFg("found in AUR."))
downloadAndUnpack(baseURL+aq[0].URLPath, dir, false)
return
}

6
install.go
View File

@ -58,13 +58,15 @@ func install(parser *arguments) error {
for _, pkg := range dc.AurMake {
if pkg.Maintainer == "" {
fmt.Printf("\x1b[1;31;40m==> Warning:\x1b[0;;40m %s is orphaned.\x1b[0m\n", pkg.Name+"-"+pkg.Version)
fmt.Println(boldRedFgBlackBg(arrow+"Warning:"),
blackBg(pkg.Name+"-"+pkg.Version+"is orphaned"))
}
}
for _, pkg := range dc.Aur {
if pkg.Maintainer == "" {
fmt.Printf("\x1b[1;31;40m==> Warning:\x1b[0;;40m %s is orphaned.\x1b[0m\n", pkg.Name+"-"+pkg.Version)
fmt.Println(boldRedFgBlackBg(arrow+"Warning:"),
blackBg(pkg.Name+"-"+pkg.Version+"is orphaned"))
}
}

249
print.go
View File

@ -3,11 +3,15 @@ package main
import (
"fmt"
"os"
"strconv"
"strings"
alpm "github.com/jguer/go-alpm"
rpc "github.com/mikkeloscar/aur"
)
const arrow = "==>"
// Human returns results in Human readable format.
func human(size int64) string {
floatsize := float32(size)
@ -29,25 +33,28 @@ func (q aurQuery) printSearch(start int) {
var toprint string
if config.SearchMode == NumberMenu {
if config.SortMode == BottomUp {
toprint += fmt.Sprintf("\x1b[33m%d\x1b[0m ", len(q)+start-i-1)
toprint += yellowFg(strconv.Itoa(len(q)+start-i-1) + " ")
} else {
toprint += fmt.Sprintf("\x1b[33m%d\x1b[0m ", start+i)
toprint += yellowFg(strconv.Itoa(start+i) + " ")
}
} else if config.SearchMode == Minimal {
fmt.Println(res.Name)
continue
}
toprint += fmt.Sprintf("\x1b[1m%s/\x1b[33m%s \x1b[36m%s \x1b[0m(%d) ", "aur", res.Name, res.Version, res.NumVotes)
toprint += boldWhiteFg("aur/") + boldYellowFg(res.Name) +
" " + boldCyanFg(res.Version) +
" (" + strconv.Itoa(res.NumVotes) + ") "
if res.Maintainer == "" {
toprint += fmt.Sprintf("\x1b[31;40m(Orphaned)\x1b[0m ")
toprint += redFgBlackBg("(Orphaned)") + " "
}
if res.OutOfDate != 0 {
toprint += fmt.Sprintf("\x1b[31;40m(Out-of-date)\x1b[0m ")
toprint += redFgBlackBg("(Out-of-date)") + " "
}
if _, err := localDb.PkgByName(res.Name); err == nil {
toprint += fmt.Sprintf("\x1b[32;40mInstalled\x1b[0m")
toprint += greenFgBlackBg("Installed")
}
toprint += "\n " + res.Description
fmt.Println(toprint)
@ -60,16 +67,16 @@ func (s repoQuery) printSearch() {
var toprint string
if config.SearchMode == NumberMenu {
if config.SortMode == BottomUp {
toprint += fmt.Sprintf("\x1b[33m%d\x1b[0m ", len(s)-i)
toprint += yellowFg(strconv.Itoa(len(s)-i) + " ")
} else {
toprint += fmt.Sprintf("\x1b[33m%d\x1b[0m ", i+1)
toprint += yellowFg(strconv.Itoa(i+1) + " ")
}
} else if config.SearchMode == Minimal {
fmt.Println(res.Name())
continue
}
toprint += fmt.Sprintf("\x1b[1m%s/\x1b[33m%s \x1b[36m%s \x1b[0m",
res.DB().Name(), res.Name(), res.Version())
toprint += boldWhiteFg(res.DB().Name()+"/") + boldYellowFg(res.Name()) +
" " + boldCyanFg(res.Version()) + " "
if len(res.Groups().Slice()) != 0 {
toprint += fmt.Sprint(res.Groups().Slice(), " ")
@ -78,7 +85,7 @@ func (s repoQuery) printSearch() {
localDb, err := alpmHandle.LocalDb()
if err == nil {
if _, err = localDb.PkgByName(res.Name()); err == nil {
toprint += fmt.Sprintf("\x1b[32;40mInstalled\x1b[0m")
toprint += greenFgBlackBg("Installed")
}
}
@ -89,17 +96,17 @@ func (s repoQuery) printSearch() {
func printDeps(repoDeps []string, aurDeps []string) {
if len(repoDeps) != 0 {
fmt.Print("\x1b[1;32m==> Repository dependencies: \x1b[0m")
fmt.Print(boldGreenFg(arrow + " Repository dependencies: "))
for _, repoD := range repoDeps {
fmt.Print("\x1b[33m", repoD, " \x1b[0m")
fmt.Print(yellowFg(repoD) + " ")
}
fmt.Print("\n")
}
if len(aurDeps) != 0 {
fmt.Print("\x1b[1;32m==> AUR dependencies: \x1b[0m")
fmt.Print(boldGreenFg(arrow + " AUR dependencies: "))
for _, aurD := range aurDeps {
fmt.Print("\x1b[33m", aurD, " \x1b[0m")
fmt.Print(yellowFg(aurD) + " ")
}
fmt.Print("\n")
}
@ -107,59 +114,21 @@ func printDeps(repoDeps []string, aurDeps []string) {
// PrintInfo prints package info like pacman -Si.
func PrintInfo(a *rpc.Pkg) {
fmt.Println("\x1b[1;37mRepository :\x1b[0m", "aur")
fmt.Println("\x1b[1;37mName :\x1b[0m", a.Name)
fmt.Println("\x1b[1;37mVersion :\x1b[0m", a.Version)
fmt.Println("\x1b[1;37mDescription :\x1b[0m", a.Description)
if a.URL != "" {
fmt.Println("\x1b[1;37mURL :\x1b[0m", a.URL)
} else {
fmt.Println("\x1b[1;37mURL :\x1b[0m", "None")
}
fmt.Println("\x1b[1;37mLicenses :\x1b[0m", strings.Join(a.License, " "))
// if len(a.Provides) != 0 {
// fmt.Println("\x1b[1;37mProvides :\x1b[0m",
// Strings.join(a.Provides, " "))
// } else {
// fmt.Println("\x1b[1;37mProvides :\x1b[0m", "None")
// }
if len(a.Depends) != 0 {
fmt.Println("\x1b[1;37mDepends On :\x1b[0m", strings.Join(a.Depends, " "))
} else {
fmt.Println("\x1b[1;37mDepends On :\x1b[0m", "None")
}
if len(a.MakeDepends) != 0 {
fmt.Println("\x1b[1;37mMake depends On :\x1b[0m", strings.Join(a.MakeDepends, " "))
} else {
fmt.Println("\x1b[1;37mMake depends On :\x1b[0m", "None")
}
if len(a.OptDepends) != 0 {
fmt.Println("\x1b[1;37mOptional Deps :\x1b[0m", strings.Join(a.OptDepends, " "))
} else {
fmt.Println("\x1b[1;37mOptional Deps :\x1b[0m", "None")
}
if len(a.Conflicts) != 0 {
fmt.Println("\x1b[1;37mConflicts With :\x1b[0m", strings.Join(a.Conflicts, " "))
} else {
fmt.Println("\x1b[1;37mConflicts With :\x1b[0m", "None")
}
if a.Maintainer != "" {
fmt.Println("\x1b[1;37mMaintainer :\x1b[0m", a.Maintainer)
} else {
fmt.Println("\x1b[1;37mMaintainer :\x1b[0m", "None")
}
fmt.Println("\x1b[1;37mVotes :\x1b[0m", a.NumVotes)
fmt.Println("\x1b[1;37mPopularity :\x1b[0m", a.Popularity)
fmt.Println(boldWhiteFg("Repository :"), "aur")
fmt.Println(boldWhiteFg("Name :"), a.Name)
fmt.Println(boldWhiteFg("Version :"), a.Version)
fmt.Println(boldWhiteFg("Description :"), a.Description)
fmt.Println(boldWhiteFg("URL :"), a.URL)
fmt.Println(boldWhiteFg("Licenses :"), strings.Join(a.License, " "))
fmt.Println(boldWhiteFg("Depends On :"), strings.Join(a.Depends, " "))
fmt.Println(boldWhiteFg("Make Deps :"), strings.Join(a.MakeDepends, " "))
fmt.Println(boldWhiteFg("Optional Deps :"), strings.Join(a.OptDepends, " "))
fmt.Println(boldWhiteFg("Conflicts With :"), strings.Join(a.Conflicts, " "))
fmt.Println(boldWhiteFg("Maintainer :"), a.Maintainer)
fmt.Println(boldWhiteFg("Votes :"), a.NumVotes)
fmt.Println(boldWhiteFg("Popularity :"), a.Popularity)
if a.OutOfDate != 0 {
fmt.Println("\x1b[1;37mOut-of-date :\x1b[0m", "Yes")
fmt.Println(boldWhiteFg("Out-of-date :"), "Yes")
}
fmt.Println()
@ -180,7 +149,7 @@ func biggestPackages() {
}
for i := 0; i < 10; i++ {
fmt.Printf("%s: \x1B[0;33m%s\x1B[0m\n", pkgS[i].Name(), human(pkgS[i].ISize()))
fmt.Println(pkgS[i].Name() + ": " + yellowFg(human(pkgS[i].ISize())))
}
// Could implement size here as well, but we just want the general idea
}
@ -198,15 +167,15 @@ func localStatistics() error {
}
fmt.Printf("\n Yay version r%s\n", version)
fmt.Println("\x1B[1;34m===========================================\x1B[0m")
fmt.Printf("\x1B[1;32mTotal installed packages: \x1B[0;33m%d\x1B[0m\n", info.Totaln)
fmt.Printf("\x1B[1;32mTotal foreign installed packages: \x1B[0;33m%d\x1B[0m\n", len(remoteNames))
fmt.Printf("\x1B[1;32mExplicitly installed packages: \x1B[0;33m%d\x1B[0m\n", info.Expln)
fmt.Printf("\x1B[1;32mTotal Size occupied by packages: \x1B[0;33m%s\x1B[0m\n", human(info.TotalSize))
fmt.Println("\x1B[1;34m===========================================\x1B[0m")
fmt.Println("\x1B[1;32mTen biggest packages\x1B[0m")
fmt.Println(boldCyanFg("==========================================="))
fmt.Println(boldGreenFg("Total installed packages: ") + yellowFg(strconv.Itoa(info.Totaln)))
fmt.Println(boldGreenFg("Total foreign installed packages: ") + yellowFg(strconv.Itoa(len(remoteNames))))
fmt.Println(boldGreenFg("Explicitly installed packages: ") + yellowFg(strconv.Itoa(info.Expln)))
fmt.Println(boldGreenFg("Total Size occupied by packages: ") + yellowFg(human(info.TotalSize)))
fmt.Println(boldCyanFg("==========================================="))
fmt.Println(boldGreenFg("Ten biggest packages"))
biggestPackages()
fmt.Println("\x1B[1;34m===========================================\x1B[0m")
fmt.Println(boldCyanFg("==========================================="))
var q aurQuery
var j int
@ -242,15 +211,18 @@ func localStatistics() error {
for _, res := range q {
if res.Maintainer == "" {
fmt.Printf("\x1b[1;31;40mWarning: \x1B[1;33;40m%s\x1b[0;37;40m is orphaned.\x1b[0m\n", res.Name)
fmt.Println(boldRedFgBlackBg(arrow+"Warning:"),
boldYellowFgBlackBg(res.Name), whiteFgBlackBg("is orphaned"))
}
if res.OutOfDate != 0 {
fmt.Printf("\x1b[1;31;40mWarning: \x1B[1;33;40m%s\x1b[0;37;40m is out-of-date in AUR.\x1b[0m\n", res.Name)
fmt.Println(boldRedFgBlackBg(arrow+"Warning:"),
boldYellowFgBlackBg(res.Name), whiteFgBlackBg("is out-of-date in AUR"))
}
}
for _, res := range outcast {
fmt.Printf("\x1b[1;31;40mWarning: \x1B[1;33;40m%s\x1b[0;37;40m is not available in AUR.\x1b[0m\n", res)
fmt.Println(boldRedFgBlackBg(arrow+"Warning:"),
boldYellowFgBlackBg(res), whiteFgBlackBg("is not available in AUR"))
}
return nil
@ -297,3 +269,122 @@ func printUpdateList() error {
return nil
}
func blackBg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[0;;40m" + in + "\x1b[0m"
}
return in
}
func redFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[0;31m" + in + "\x1b[0m"
}
return in
}
func greenFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[0;32m" + in + "\x1b[0m"
}
return in
}
func yellowFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[0;33m" + in + "\x1b[0m"
}
return in
}
func boldFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[1m" + in + "\x1b[0m"
}
return in
}
func boldGreenFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[1;32m" + in + "\x1b[0m"
}
return in
}
func boldYellowFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[1;33m" + in + "\x1b[0m"
}
return in
}
func boldBlueFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[1;34m" + in + "\x1b[0m"
}
return in
}
func boldCyanFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[1;36m" + in + "\x1b[0m"
}
return in
}
func boldWhiteFg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[1;37m" + in + "\x1b[0m"
}
return in
}
func redFgBlackBg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[0;31;40m" + in + "\x1b[0m"
}
return in
}
func greenFgBlackBg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[0;32;40m" + in + "\x1b[0m"
}
return in
}
func whiteFgBlackBg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[0;37;40m" + in + "\x1b[0m"
}
return in
}
func boldRedFgBlackBg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[1;31;40m" + in + "\x1b[0m"
}
return in
}
func boldYellowFgBlackBg(in string) string {
if alpmConf.Options&alpm.ConfColor > 0 {
return "\x1b[1;33;40m" + in + "\x1b[0m"
}
return in
}

6
query.go
View File

@ -81,7 +81,7 @@ func (q aurQuery) missingPackage(pkgS []string) {
}
if !found {
fmt.Println("\x1b[31mUnable to find", depName, "in AUR\x1b[0m")
fmt.Println(redFg("Unable to find" + depName + "in AUR"))
}
}
}
@ -303,7 +303,7 @@ func hangingPackages() (hanging []string, err error) {
requiredby := pkg.ComputeRequiredBy()
if len(requiredby) == 0 {
hanging = append(hanging, pkg.Name())
fmt.Printf("%s: \x1B[0;33m%s\x1B[0m\n", pkg.Name(), human(pkg.ISize()))
fmt.Println(pkg.Name() + ": " + yellowFg(human(pkg.ISize())))
}
return nil
@ -372,7 +372,7 @@ big:
requiredby := pkg.ComputeRequiredBy()
if len(requiredby) == 0 {
hanging = append(hanging, pkgName)
fmt.Printf("%s: \x1B[0;33m%s\x1B[0m\n", pkg.Name(), human(pkg.ISize()))
fmt.Println(pkg.Name() + ": " + yellowFg(human(pkg.ISize())))
}
}
}

49
upgrade.go
View File

@ -64,28 +64,39 @@ func (u upSlice) Print(start int) {
new, errNew := pkgb.NewCompleteVersion(i.RemoteVersion)
var left, right string
f := func(name string) (color int) {
f := func(name string) (output string) {
var hash = 5381
for i := 0; i < len(name); i++ {
hash = int(name[i]) + ((hash << 5) + (hash))
}
return hash%6 + 31
return fmt.Sprintf("\x1b[1;%dm%s\x1b[0m", hash%6+31, name)
}
fmt.Printf("\x1b[33m%-2d\x1b[0m ", len(u)+start-k-1)
fmt.Printf("\x1b[1;%dm%s\x1b[0m/\x1b[1;39m%-25s\t\t\x1b[0m", f(i.Repository), i.Repository, i.Name)
fmt.Print(yellowFg(fmt.Sprintf("%2d ", len(u)+start-k-1)))
fmt.Print(f(i.Repository), "/", boldWhiteFg(i.Name))
if errOld != nil {
left = fmt.Sprintf("\x1b[31m%20s\x1b[0m", "Invalid Version")
left = redFg("Invalid Version")
} else {
left = fmt.Sprintf("\x1b[31m%18s\x1b[0m-%s", old.Version, old.Pkgrel)
if old.Version == new.Version {
left = string(old.Version) + "-" + redFg(string(old.Pkgrel))
} else {
left = redFg(string(old.Version)) + "-" + string(old.Pkgrel)
}
}
if errNew != nil {
right = fmt.Sprintf("\x1b[31m%s\x1b[0m", "Invalid Version")
right = redFg("Invalid Version")
} else {
right = fmt.Sprintf("\x1b[31m%s\x1b[0m-%s", new.Version, new.Pkgrel)
if old.Version == new.Version {
right = string(new.Version) + "-" + greenFg(string(new.Pkgrel))
} else {
right = boldGreenFg(string(new.Version)) + "-" + string(new.Pkgrel)
}
}
fmt.Printf("%s -> %s\n", left, right)
w := 70 - len(i.Repository) - len(i.Name) + len(left)
fmt.Printf(fmt.Sprintf("%%%ds", w),
fmt.Sprintf("%s -> %s\n", left, right))
}
}
@ -100,14 +111,14 @@ func upList() (aurUp upSlice, repoUp upSlice, err error) {
aurC := make(chan upSlice)
errC := make(chan error)
fmt.Println("\x1b[1;36;1m::\x1b[0m\x1b[1m Searching databases for updates...\x1b[0m")
fmt.Println(boldCyanFg("::"), boldFg("Searching databases for updates..."))
go func() {
repoUpList, err := upRepo(local)
errC <- err
repoC <- repoUpList
}()
fmt.Println("\x1b[1;36;1m::\x1b[0m\x1b[1m Searching AUR for updates...\x1b[0m")
fmt.Println(boldCyanFg("::"), boldFg("Searching AUR for updates..."))
go func() {
aurUpList, err := upAUR(remote, remoteNames)
errC <- err
@ -151,7 +162,8 @@ func upDevel(remote []alpm.Package, packageC chan upgrade, done chan bool) {
}
if found {
if pkg.ShouldIgnore() {
fmt.Printf("\x1b[33mwarning:\x1b[0m %s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), "git")
fmt.Print(yellowFg("Warning: "))
fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), "git")
} else {
packageC <- upgrade{e.Package, "devel", e.SHA[0:6], "git"}
}
@ -176,7 +188,7 @@ func upAUR(remote []alpm.Package, remoteNames []string) (toUpgrade upSlice, err
if config.Devel {
routines++
go upDevel(remote, packageC, done)
fmt.Println("\x1b[1;36;1m::\x1b[0m\x1b[1m Checking development packages...\x1b[0m")
fmt.Println(boldCyanFg("::"), boldFg("Checking development packages..."))
}
for i := len(remote); i != 0; i = j {
@ -208,7 +220,8 @@ func upAUR(remote []alpm.Package, remoteNames []string) (toUpgrade upSlice, err
if (config.TimeUpdate && (int64(qtemp[x].LastModified) > local[i].BuildDate().Unix())) ||
(alpm.VerCmp(local[i].Version(), qtemp[x].Version) < 0) {
if local[i].ShouldIgnore() {
fmt.Printf("\x1b[33mwarning:\x1b[0m %s ignoring package upgrade (%s => %s)\n", local[i].Name(), local[i].Version(), qtemp[x].Version)
fmt.Print(yellowFg("Warning: "))
fmt.Printf("%s ignoring package upgrade (%s => %s)\n", local[i].Name(), local[i].Version(), qtemp[x].Version)
} else {
packageC <- upgrade{qtemp[x].Name, "aur", local[i].Version(), qtemp[x].Version}
}
@ -255,7 +268,8 @@ func upRepo(local []alpm.Package) (upSlice, error) {
newPkg := pkg.NewVersion(dbList)
if newPkg != nil {
if pkg.ShouldIgnore() {
fmt.Printf("\x1b[33mwarning:\x1b[0m %s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), newPkg.Version())
fmt.Print(yellowFg("Warning: "))
fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), newPkg.Version())
} else {
slice = append(slice, upgrade{pkg.Name(), newPkg.DB().Name(), pkg.Version(), newPkg.Version()})
}
@ -300,12 +314,13 @@ func upgradePkgs(flags []string) error {
var repoNums []int
var aurNums []int
sort.Sort(repoUp)
fmt.Printf("\x1b[1;34;1m:: \x1b[0m\x1b[1m%d Packages to upgrade.\x1b[0m\n", len(aurUp)+len(repoUp))
fmt.Println(boldBlueFg("::"), len(aurUp)+len(repoUp), boldWhiteFg("Packages to upgrade."))
repoUp.Print(len(aurUp) + 1)
aurUp.Print(1)
if !config.NoConfirm {
fmt.Print("\x1b[32mEnter packages you don't want to upgrade.\x1b[0m\nNumbers: ")
fmt.Println(greenFg("Enter packages you don't want to upgrade."))
fmt.Print("Numbers: ")
reader := bufio.NewReader(os.Stdin)
numberBuf, overflow, err := reader.ReadLine()