From 346a579c2324277f8aae70ff1d72e5ebf8745e4b Mon Sep 17 00:00:00 2001 From: morganamilo Date: Sat, 17 Feb 2018 17:39:10 +0000 Subject: [PATCH 01/18] Add function to wrap rpc.Info with warnings Warns for orphans, out of date and missing Respects requestsplitn in config --- query.go | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/query.go b/query.go index ed0a30b6..4d1cc39f 100644 --- a/query.go +++ b/query.go @@ -380,3 +380,50 @@ big: } return } + +func min(a, b int) int { + if a < b { + return a + } + return a +} + +func aurInfo(names []string) ([]rpc.Pkg, error) { + info := make([]rpc.Pkg, 0, len(names)) + seen := make(map[string]int) + + for n := 0; n < len(names); n += config.RequestSplitN { + max := min(len(names), n + config.RequestSplitN) + tempInfo, err := rpc.Info(names[n:max]) + if err != nil { + return info, err + } + info = append(info, tempInfo...) + } + + for k, pkg := range info { + seen[pkg.Name] = k + } + + for _, name := range names { + i, ok := seen[name] + if !ok { + fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), + boldYellowFgBlackBg(name), whiteFgBlackBg("is not available in AUR")) + continue + } + + pkg := info[i] + + if pkg.Maintainer == "" { + fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), + boldYellowFgBlackBg(pkg.Name), whiteFgBlackBg("is orphaned")) + } + if pkg.OutOfDate != 0 { + fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), + boldYellowFgBlackBg(pkg.Name), whiteFgBlackBg("is out-of-date in AUR")) + } + } + + return info, nil +} From 3fb77b1d7255564d712d0c792b10f2031f52a64e Mon Sep 17 00:00:00 2001 From: morganamilo Date: Sat, 17 Feb 2018 17:44:30 +0000 Subject: [PATCH 02/18] Use aurInfo() for -G --- cmd.go | 11 +-------- download.go | 69 ++++++++++++++++++++++++++++++----------------------- 2 files changed, 40 insertions(+), 40 deletions(-) diff --git a/cmd.go b/cmd.go index f3043d20..23eceb51 100644 --- a/cmd.go +++ b/cmd.go @@ -448,16 +448,7 @@ func handleYay() (err error) { } func handleGetpkgbuild() (err error) { - for pkg := range cmdArgs.targets { - err = getPkgbuild(pkg) - if err != nil { - //we print the error instead of returning it - //seems as we can handle multiple errors without stoping - //theres no easy way around this right now - fmt.Println(pkg+":", err) - } - } - + err = getPkgbuilds(cmdArgs.formatTargets()) return } diff --git a/download.go b/download.go index af2b479f..b76408f1 100644 --- a/download.go +++ b/download.go @@ -7,8 +7,6 @@ import ( "os" "os/exec" "strings" - - rpc "github.com/mikkeloscar/aur" ) func downloadFile(path string, url string) (err error) { @@ -63,60 +61,71 @@ func downloadAndUnpack(url string, path string, trim bool) (err error) { return } -func getPkgbuild(pkg string) (err error) { +func getPkgbuilds(pkgs []string) (error) { + //possibleAurs := make([]string, 0, 0) wd, err := os.Getwd() if err != nil { - return + return err } wd = wd + "/" - err = getPkgbuildfromABS(pkg, wd) - if err == nil { - return + missing, err := getPkgbuildsfromABS(pkgs, wd) + if err != nil { + return err } - err = getPkgbuildfromAUR(pkg, wd) - return + err = getPkgbuildsfromAUR(missing, wd) + return err } // GetPkgbuild downloads pkgbuild from the ABS. -func getPkgbuildfromABS(pkgN string, path string) (err error) { +func getPkgbuildsfromABS(pkgs []string, path string) (missing []string, err error) { dbList, err := alpmHandle.SyncDbs() if err != nil { return } - for _, db := range dbList.Slice() { - pkg, err := db.PkgByName(pkgN) - if err == nil { - var url string - if db.Name() == "core" || db.Name() == "extra" { - url = "https://projects.archlinux.org/svntogit/packages.git/snapshot/packages/" + pkg.Base() + ".tar.gz" - } else if db.Name() == "community" { - url = "https://projects.archlinux.org/svntogit/community.git/snapshot/community-packages/" + pkg.Base() + ".tar.gz" - } else { - return fmt.Errorf("Not in standard repositories") + nextPkg: + for _, pkgN := range pkgs { + for _, db := range dbList.Slice() { + pkg, err := db.PkgByName(pkgN) + if err == nil { + var url string + if db.Name() == "core" || db.Name() == "extra" { + url = "https://projects.archlinux.org/svntogit/packages.git/snapshot/packages/" + pkg.Base() + ".tar.gz" + } else if db.Name() == "community" { + url = "https://projects.archlinux.org/svntogit/community.git/snapshot/community-packages/" + pkg.Base() + ".tar.gz" + } else { + fmt.Println(pkgN + " not in standard repositories") + } + + errD := downloadAndUnpack(url, path, true) + if errD != nil { + fmt.Println(boldYellowFg(pkg.Name()), boldGreenFg(errD.Error())) + } + + fmt.Println(boldGreenFg(arrow), boldGreenFg("Downloaded"), boldYellowFg(pkg.Name()), boldGreenFg("from ABS")) + continue nextPkg } - fmt.Println(boldGreenFg(arrow), boldYellowFg(pkgN), boldGreenFg("found in ABS.")) - errD := downloadAndUnpack(url, path, true) - return errD } + + missing = append(missing, pkgN) } - return fmt.Errorf("package not found") + + return } // GetPkgbuild downloads pkgbuild from the AUR. -func getPkgbuildfromAUR(pkgN string, dir string) (err error) { - aq, err := rpc.Info([]string{pkgN}) +func getPkgbuildsfromAUR(pkgs []string, dir string) (err error) { + aq, err := aurInfo(pkgs) if err != nil { return err } - if len(aq) == 0 { - return fmt.Errorf("no results") + for _, pkg := range aq { + downloadAndUnpack(baseURL+aq[0].URLPath, dir, false) + fmt.Println(boldGreenFg(arrow), boldGreenFg("Downloaded"), boldYellowFg(pkg.Name), boldGreenFg("from AUR")) } - fmt.Println(boldGreenFg(arrow), boldYellowFg(pkgN), boldGreenFg("found in AUR.")) - downloadAndUnpack(baseURL+aq[0].URLPath, dir, false) return } From e71d66f3c6a7152d0cb554aa926bc425beb096d0 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Sat, 17 Feb 2018 18:08:00 +0000 Subject: [PATCH 03/18] use aurInfo() for -Ps --- print.go | 48 +----------------------------------------------- 1 file changed, 1 insertion(+), 47 deletions(-) diff --git a/print.go b/print.go index 381071a4..3ee6a157 100644 --- a/print.go +++ b/print.go @@ -256,53 +256,7 @@ func localStatistics() error { biggestPackages() fmt.Println(boldCyanFg("===========================================")) - var q aurQuery - var j int - for i := len(remoteNames); i != 0; i = j { - j = i - config.RequestSplitN - if j < 0 { - j = 0 - } - qtemp, err := rpc.Info(remoteNames[j:i]) - q = append(q, qtemp...) - if err != nil { - return err - } - } - - var outcast []string - for _, s := range remoteNames { - found := false - for _, i := range q { - if s == i.Name { - found = true - break - } - } - if !found { - outcast = append(outcast, s) - } - } - - if err != nil { - return err - } - - for _, res := range q { - if res.Maintainer == "" { - fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), - boldYellowFgBlackBg(res.Name), whiteFgBlackBg("is orphaned")) - } - if res.OutOfDate != 0 { - fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), - boldYellowFgBlackBg(res.Name), whiteFgBlackBg("is out-of-date in AUR")) - } - } - - for _, res := range outcast { - fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), - boldYellowFgBlackBg(res), whiteFgBlackBg("is not available in AUR")) - } + aurInfo(remoteNames) return nil } From 7558f8fcf872fe7a9bbccfc21b565aa1f36bff27 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Sat, 17 Feb 2018 23:35:54 +0000 Subject: [PATCH 04/18] Use aurInfo for -S and -Su This also improves the dependency by switching to stringSets for some structures that previously contained duplicates. --- dependencies.go | 33 +++++++++++++++++---------------- install.go | 9 --------- upgrade.go | 3 +-- 3 files changed, 18 insertions(+), 27 deletions(-) diff --git a/dependencies.go b/dependencies.go index 75aa7992..912521ad 100644 --- a/dependencies.go +++ b/dependencies.go @@ -2,13 +2,12 @@ package main import ( "strings" - alpm "github.com/jguer/go-alpm" rpc "github.com/mikkeloscar/aur" ) type depTree struct { - ToProcess []string + ToProcess stringSet Repo map[string]*alpm.Package Aur map[string]*rpc.Pkg Missing stringSet @@ -23,7 +22,7 @@ type depCatagories struct { func makeDepTree() *depTree { dt := depTree{ - make([]string, 0), + make(stringSet), make(map[string]*alpm.Package), make(map[string]*rpc.Pkg), make(stringSet), @@ -188,12 +187,10 @@ func getDepTree(pkgs []string) (*depTree, error) { continue } - dt.ToProcess = append(dt.ToProcess, pkg) + dt.ToProcess.set(pkg) } - if len(dt.ToProcess) > 0 { - err = depTreeRecursive(dt, localDb, syncDb, false) - } + err = depTreeRecursive(dt, localDb, syncDb, false) return dt, err } @@ -239,16 +236,20 @@ func repoTreeRecursive(pkg *alpm.Package, dt *depTree, localDb *alpm.Db, syncDb } func depTreeRecursive(dt *depTree, localDb *alpm.Db, syncDb alpm.DbList, isMake bool) (err error) { - nextProcess := make([]string, 0) - currentProcess := make([]string, 0, len(dt.ToProcess)) + if len(dt.ToProcess) == 0 { + return + } + nextProcess := make(stringSet) + currentProcess := make(stringSet) //strip version conditions - for _, dep := range dt.ToProcess { - currentProcess = append(currentProcess, getNameFromDep(dep)) + for dep := range dt.ToProcess { + currentProcess.set(getNameFromDep(dep)) } //assume toprocess only contains aur stuff we have not seen - info, err := rpc.Info(currentProcess) + info, err := aurInfo(currentProcess.toSlice()) + if err != nil { return } @@ -265,16 +266,16 @@ func depTreeRecursive(dt *depTree, localDb *alpm.Db, syncDb alpm.DbList, isMake //loop through to process and check if we now have //each packaged cached //if its not cached we assume its missing - for k, pkgName := range currentProcess { + for pkgName := range currentProcess { pkg, exists := dt.Aur[pkgName] //did not get it in the request if !exists { - dt.Missing.set(dt.ToProcess[k]) + dt.Missing.set(pkgName) continue } - //for reach dep and makedep + //for each dep and makedep for _, deps := range [2][]string{pkg.Depends, pkg.MakeDepends} { for _, versionedDep := range deps { dep := getNameFromDep(versionedDep) @@ -311,7 +312,7 @@ func depTreeRecursive(dt *depTree, localDb *alpm.Db, syncDb alpm.DbList, isMake } //if all else fails add it to next search - nextProcess = append(nextProcess, versionedDep) + nextProcess.set(versionedDep) } } } diff --git a/install.go b/install.go index 25178b41..acee44cc 100644 --- a/install.go +++ b/install.go @@ -59,15 +59,6 @@ func install(parser *arguments) error { return err } - for _, pkg := range dc.Aur { - if pkg.Maintainer == "" { - fmt.Println(boldRedFgBlackBg(arrow+" Warning:"), - blackBg(pkg.Name+"-"+pkg.Version+" is orphaned")) - } - } - - - //printDownloadsFromRepo("Repo", dc.Repo) //printDownloadsFromRepo("Repo Make", dc.RepoMake) //printDownloadsFromAur("AUR", dc.Aur) diff --git a/upgrade.go b/upgrade.go index fd2712d5..2926164f 100644 --- a/upgrade.go +++ b/upgrade.go @@ -10,7 +10,6 @@ import ( "unicode" alpm "github.com/jguer/go-alpm" - rpc "github.com/mikkeloscar/aur" pkgb "github.com/mikkeloscar/gopkgbuild" ) @@ -203,7 +202,7 @@ func upAUR(remote []alpm.Package, remoteNames []string) (toUpgrade upSlice, err routines++ go func(local []alpm.Package, remote []string) { - qtemp, err := rpc.Info(remote) + qtemp, err := aurInfo(remote) if err != nil { fmt.Println(err) done <- true From 2856a7276c05d586afb67b9315f988773e5d376d Mon Sep 17 00:00:00 2001 From: morganamilo Date: Sun, 18 Feb 2018 23:46:25 +0000 Subject: [PATCH 05/18] Refactoring and improving insall process This commit mostly focuses on merging the install() and upgradePkgs() functions to be more integrated. Instead of both making their own aur queries they now both combine theyre needes into one query. This gives us a speed up and allows us to easily print orphands, misising and out of date in one clean block. --- cmd.go | 4 +- install.go | 109 +++++++++++++++++++++++++++++++++++++++++------------ print.go | 9 +++-- query.go | 49 +++++++----------------- upgrade.go | 104 ++++++++++++++++++++------------------------------ 5 files changed, 145 insertions(+), 130 deletions(-) diff --git a/cmd.go b/cmd.go index 23eceb51..b2752167 100644 --- a/cmd.go +++ b/cmd.go @@ -488,10 +488,10 @@ func handleSync() (err error) { err = syncSearch(targets) } else if cmdArgs.existsArg("c", "clean") { err = passToPacman(cmdArgs) - } else if cmdArgs.existsArg("u", "sysupgrade") { - err = upgradePkgs(make([]string, 0)) } else if cmdArgs.existsArg("i", "info") { err = syncInfo(targets) + } else if cmdArgs.existsArg("u", "sysupgrade") { + err = install(cmdArgs) } else if len(cmdArgs.targets) > 0 { err = install(cmdArgs) } diff --git a/install.go b/install.go index acee44cc..3b53627b 100644 --- a/install.go +++ b/install.go @@ -15,46 +15,96 @@ import ( // Install handles package installs func install(parser *arguments) error { - aurs, repos, missing, err := packageSlices(parser.targets.toSlice()) + aur, repo, err := packageSlices(parser.targets.toSlice()) + if err != nil { + return err + } + srcinfos := make(map[string]*gopkg.PKGBUILD) + var dc *depCatagories + + //fmt.Println(greenFg(arrow), greenFg("Resolving Dependencies")) + requestTargets := aur + + //remotenames: names of all non repo packages on the system + _, _, _, remoteNames, err := filterPackages() + if err != nil { + return err + } + + //cache as a stringset. maybe make it return a string set in the first + //place + remoteNamesCache := make(stringSet) + for _, name := range remoteNames { + remoteNamesCache.set(name) + } + + //if we are doing -u also request every non repo package on the system + if parser.existsArg("u", "sysupgrade") { + requestTargets = append(requestTargets, remoteNames...) + } + + + fmt.Println(boldCyanFg("::"), boldFg("Querying AUR...")) + dt , err := getDepTree(requestTargets) if err != nil { return err } - if len(missing) > 0 { - fmt.Println(missing) - fmt.Println("Could not find all Targets") + //only error if direct targets or deps are missing + missing := make(stringSet) + for missingName := range dt.Missing { + if !remoteNamesCache.get(missingName) { + missing.set(missingName) + } } + if len(missing) > 0 { + printMissing(missing) + return fmt.Errorf("Could not find all required packages") + } + + //create the arguments to pass for the repo install arguments := parser.copy() arguments.delArg("u", "sysupgrade") arguments.delArg("y", "refresh") arguments.op = "S" arguments.targets = make(stringSet) - arguments.addTarget(repos...) - - if len(repos) != 0 { - err := passToPacman(arguments) - if err != nil { - fmt.Println("Error installing repo packages.") - } - } - - if len(aurs) != 0 { - //todo mamakeke pretty - fmt.Println(greenFg(arrow), greenFg("Resolving Dependencies")) - - dt, err := getDepTree(aurs) + + if parser.existsArg("u", "sysupgrade") { + repoUp, aurUp, err := upgradePkgs(dt) if err != nil { return err } - if len(dt.Missing) > 0 { - fmt.Println(dt.Missing) - return fmt.Errorf("Could not find all Deps") + for pkg := range aurUp { + parser.addTarget(pkg) + } + + for pkg := range repoUp { + arguments.addTarget(pkg) } - dc, err := getDepCatagories(aurs, dt) + + //discard stuff thats + //not a target and + //not an upgrade and + //is installed + for pkg := range dt.Aur { + if !parser.targets.get(pkg) && remoteNamesCache.get(pkg) { + delete(dt.Aur, pkg) + } + } + } + + for _, pkg := range repo { + arguments.addTarget(pkg) + } + + + hasAur := len(dt.Aur) != 0 + if hasAur { + dc, err = getDepCatagories(parser.formatTargets(), dt) if err != nil { return err } @@ -69,8 +119,17 @@ func install(parser *arguments) error { printDepCatagories(dc) fmt.Println() + } + + if len(arguments.targets) > 0 { + err := passToPacman(arguments) + if err != nil { + fmt.Println("Error installing repo packages.") + } + } - if !arguments.existsArg("gendb") { + if hasAur { + if !parser.existsArg("gendb") { err = checkForConflicts(dc) if err != nil { return err @@ -98,7 +157,7 @@ func install(parser *arguments) error { return err } - if len(dc.Repo) > 0 { + /*if len(dc.Repo) > 0 { arguments := parser.copy() arguments.delArg("u", "sysupgrade") arguments.delArg("y", "refresh") @@ -116,7 +175,7 @@ func install(parser *arguments) error { if err != nil { return err } - } + }*/ if arguments.existsArg("gendb") { fmt.Println("GenDB finished. No packages were installed") diff --git a/print.go b/print.go index 3ee6a157..88d620ef 100644 --- a/print.go +++ b/print.go @@ -2,7 +2,7 @@ package main import ( "fmt" - "os" +// "os" "strconv" "strings" @@ -272,7 +272,8 @@ func printMissing(missing stringSet) { //todo make it less hacky func printNumberOfUpdates() error { - old := os.Stdout // keep backup of the real stdout + //todo + /*old := os.Stdout // keep backup of the real stdout os.Stdout = nil aurUp, repoUp, err := upList() os.Stdout = old // restoring the real stdout @@ -280,11 +281,13 @@ func printNumberOfUpdates() error { return err } fmt.Println(len(aurUp) + len(repoUp)) + */ return nil } //todo make it less hacky func printUpdateList() error { + /* old := os.Stdout // keep backup of the real stdout os.Stdout = nil aurUp, repoUp, err := upList() @@ -299,7 +302,7 @@ func printUpdateList() error { for _, pkg := range aurUp { fmt.Println(pkg.Name) } - +*/ return nil } diff --git a/query.go b/query.go index 4d1cc39f..ff5944f9 100644 --- a/query.go +++ b/query.go @@ -153,16 +153,23 @@ func syncSearch(pkgS []string) (err error) { // SyncInfo serves as a pacman -Si for repo packages and AUR packages. func syncInfo(pkgS []string) (err error) { - aurS, repoS, missing, err := packageSlices(pkgS) + var info []rpc.Pkg + aurS, repoS, err := packageSlices(pkgS) if err != nil { return } + if len(aurS) != 0 { + info, err = aurInfo(aurS) + if err != nil { + fmt.Println(err) + } + } + //repo always goes first if len(repoS) != 0 { arguments := cmdArgs.copy() arguments.delTarget(aurS...) - arguments.delTarget(missing...) err = passToPacman(arguments) if err != nil { @@ -171,20 +178,11 @@ func syncInfo(pkgS []string) (err error) { } if len(aurS) != 0 { - q, err := rpc.Info(aurS) - if err != nil { - fmt.Println(err) - } - for _, aurP := range q { - PrintInfo(&aurP) + for _, pkg := range info { + PrintInfo(&pkg) } } - //todo - //if len(missing) != 0 { - // printMissing(missing) - //} - return } @@ -239,8 +237,7 @@ func queryRepo(pkgInputN []string) (s repoQuery, n int, err error) { } // PackageSlices separates an input slice into aur and repo slices -func packageSlices(toCheck []string) (aur []string, repo []string, missing []string, err error) { - possibleAur := make([]string, 0) +func packageSlices(toCheck []string) (aur []string, repo []string, err error) { dbList, err := alpmHandle.SyncDbs() if err != nil { return @@ -263,30 +260,10 @@ func packageSlices(toCheck []string) (aur []string, repo []string, missing []str if found { repo = append(repo, pkg) } else { - possibleAur = append(possibleAur, pkg) + aur = append(aur, pkg) } } - if len(possibleAur) == 0 { - return - } - - info, err := rpc.Info(possibleAur) - if err != nil { - fmt.Println(err) - } - -outer: - for _, pkg := range possibleAur { - for _, rpcpkg := range info { - if rpcpkg.Name == pkg { - aur = append(aur, pkg) - continue outer - } - } - missing = append(missing, pkg) - } - return } diff --git a/upgrade.go b/upgrade.go index 2926164f..d1c3da17 100644 --- a/upgrade.go +++ b/upgrade.go @@ -103,7 +103,7 @@ func (u upSlice) Print(start int) { } // upList returns lists of packages to upgrade from each source. -func upList() (aurUp upSlice, repoUp upSlice, err error) { +func upList(dt *depTree) (aurUp upSlice, repoUp upSlice, err error) { local, remote, _, remoteNames, err := filterPackages() if err != nil { return @@ -122,7 +122,7 @@ func upList() (aurUp upSlice, repoUp upSlice, err error) { fmt.Println(boldCyanFg("::"), boldFg("Searching AUR for updates...")) go func() { - aurUpList, err := upAUR(remote, remoteNames) + aurUpList, err := upAUR(remote, remoteNames, dt) errC <- err aurC <- aurUpList }() @@ -179,8 +179,7 @@ func upDevel(remote []alpm.Package, packageC chan upgrade, done chan bool) { // upAUR gathers foreign packages and checks if they have new versions. // Output: Upgrade type package list. -func upAUR(remote []alpm.Package, remoteNames []string) (toUpgrade upSlice, err error) { - var j int +func upAUR(remote []alpm.Package, remoteNames []string, dt *depTree) (toUpgrade upSlice, err error) { var routines int var routineDone int @@ -193,48 +192,31 @@ func upAUR(remote []alpm.Package, remoteNames []string) (toUpgrade upSlice, err fmt.Println(boldCyanFg("::"), boldFg("Checking development packages...")) } - for i := len(remote); i != 0; i = j { - //Split requests so AUR RPC doesn't get mad at us. - j = i - config.RequestSplitN - if j < 0 { - j = 0 - } - - routines++ - go func(local []alpm.Package, remote []string) { - qtemp, err := aurInfo(remote) - if err != nil { - fmt.Println(err) - done <- true - return + routines++ + go func(remote []alpm.Package, remoteNames []string, dt *depTree) { + for _, pkg := range remote { + aurPkg, ok := dt.Aur[pkg.Name()] + if !ok { + continue } - // For each item in query: Search equivalent in foreign. - // We assume they're ordered and are returned ordered - // and will only be missing if they don't exist in AUR. - max := len(qtemp) - 1 - var missing, x int - for i := range local { - x = i - missing - if x > max { - break - } else if qtemp[x].Name == local[i].Name() { - 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.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} - } - } - continue + if (config.TimeUpdate && (int64(aurPkg.LastModified) > pkg.BuildDate().Unix())) || + (alpm.VerCmp(pkg.Version(), aurPkg.Version) < 0) { + if pkg.ShouldIgnore() { + fmt.Print(yellowFg("Warning: ")) + fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), aurPkg.Version) } else { - missing++ + packageC <- upgrade{aurPkg.Name, "aur", pkg.Version(), aurPkg.Version} } } - done <- true - }(remote[j:i], remoteNames[j:i]) + } + + done <- true + }(remote, remoteNames, dt) + + if routineDone == routines { + err = nil + return } for { @@ -304,17 +286,20 @@ func removeIntListFromList(src, target []int) []int { } // upgradePkgs handles updating the cache and installing updates. -func upgradePkgs(flags []string) error { - aurUp, repoUp, err := upList() - if err != nil { - return err - } else if len(aurUp)+len(repoUp) == 0 { - fmt.Println("\nThere is nothing to do") - return err - } - +func upgradePkgs(dt *depTree) (stringSet, stringSet, error) { var repoNums []int var aurNums []int + repoNames := make(stringSet) + aurNames := make(stringSet) + + aurUp, repoUp, err := upList(dt) + if err != nil { + return repoNames, aurNames, err + } else if len(aurUp)+len(repoUp) == 0 { + fmt.Println("\nThere is nothing to do") + return repoNames, aurNames, err + } + sort.Sort(repoUp) fmt.Println(boldBlueFg("::"), len(aurUp)+len(repoUp), boldWhiteFg("Packages to upgrade.")) repoUp.Print(len(aurUp) + 1) @@ -328,7 +313,7 @@ func upgradePkgs(flags []string) error { numberBuf, overflow, err := reader.ReadLine() if err != nil || overflow { fmt.Println(err) - return err + return repoNames, aurNames, err } result := strings.Fields(string(numberBuf)) @@ -382,13 +367,7 @@ func upgradePkgs(flags []string) error { repoNums = removeIntListFromList(excludeRepo, repoNums) } - arguments := cmdArgs.copy() - arguments.delArg("u", "sysupgrade") - arguments.delArg("y", "refresh") - - var repoNames []string - var aurNames []string - + if len(repoUp) != 0 { repoloop: for i, k := range repoUp { @@ -397,7 +376,7 @@ func upgradePkgs(flags []string) error { continue repoloop } } - repoNames = append(repoNames, k.Name) + repoNames.set(k.Name) } } @@ -409,12 +388,9 @@ func upgradePkgs(flags []string) error { continue aurloop } } - aurNames = append(aurNames, k.Name) + aurNames.set(k.Name) } } - arguments.addTarget(repoNames...) - arguments.addTarget(aurNames...) - err = install(arguments) - return err + return repoNames, aurNames, err } From 3f7c731f999b1f5914a5e23f39c2943961ce17d1 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 04:25:36 +0000 Subject: [PATCH 06/18] Make aurInfo concurrent --- query.go | 33 ++++++++++++++++++++++++++++----- 1 file changed, 28 insertions(+), 5 deletions(-) diff --git a/query.go b/query.go index ff5944f9..e76a2c6b 100644 --- a/query.go +++ b/query.go @@ -4,6 +4,7 @@ import ( "fmt" "sort" "strings" + "sync" alpm "github.com/jguer/go-alpm" rpc "github.com/mikkeloscar/aur" @@ -368,14 +369,36 @@ func min(a, b int) int { func aurInfo(names []string) ([]rpc.Pkg, error) { info := make([]rpc.Pkg, 0, len(names)) seen := make(map[string]int) + var mux sync.Mutex + var wg sync.WaitGroup + var err error + + makeRequest := func(n, max int) { + tempInfo, requestErr := rpc.Info(names[n:max]) + if err != nil { + return + } + if requestErr != nil { + //return info, err + err = requestErr + return + } + mux.Lock() + info = append(info, tempInfo...) + mux.Unlock() + wg.Done() + } for n := 0; n < len(names); n += config.RequestSplitN { max := min(len(names), n + config.RequestSplitN) - tempInfo, err := rpc.Info(names[n:max]) - if err != nil { - return info, err - } - info = append(info, tempInfo...) + wg.Add(1) + go makeRequest(n, max) + } + + wg.Wait() + + if err != nil { + return info, err } for k, pkg := range info { From 46cc1f2c0900890a79c487192e219cf650a9da6f Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 05:02:05 +0000 Subject: [PATCH 07/18] Display missing, orphans and out of date in groups Instead of printing each warning on a seperate line, group up the warnings by type (missing, orphan, out of date) and display each group on its own line. --- query.go | 37 +++++++++++++++++++++++++++++++------ 1 file changed, 31 insertions(+), 6 deletions(-) diff --git a/query.go b/query.go index e76a2c6b..a8525151 100644 --- a/query.go +++ b/query.go @@ -373,6 +373,10 @@ func aurInfo(names []string) ([]rpc.Pkg, error) { var wg sync.WaitGroup var err error + missing := make([]string, 0, len(names)) + orphans := make([]string, 0, len(names)) + outOfDate := make([]string, 0, len(names)) + makeRequest := func(n, max int) { tempInfo, requestErr := rpc.Info(names[n:max]) if err != nil { @@ -408,22 +412,43 @@ func aurInfo(names []string) ([]rpc.Pkg, error) { for _, name := range names { i, ok := seen[name] if !ok { - fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), - boldYellowFgBlackBg(name), whiteFgBlackBg("is not available in AUR")) + missing = append(missing, name) continue } pkg := info[i] if pkg.Maintainer == "" { - fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), - boldYellowFgBlackBg(pkg.Name), whiteFgBlackBg("is orphaned")) + orphans = append(orphans, name) } if pkg.OutOfDate != 0 { - fmt.Println(boldRedFgBlackBg(arrow+"Warning:"), - boldYellowFgBlackBg(pkg.Name), whiteFgBlackBg("is out-of-date in AUR")) + outOfDate = append(outOfDate, name) } } + if len(missing) > 0 { + fmt.Print(boldRedFgBlackBg(arrow + " Missing AUR Packages:")) + for _, name := range missing { + fmt.Print(" " + boldYellowFgBlackBg(name)) + } + fmt.Println() + } + + if len(orphans) > 0 { + fmt.Print(boldRedFgBlackBg(arrow + " Orphaned AUR Packages:")) + for _, name := range orphans { + fmt.Print(" " + boldYellowFgBlackBg(name)) + } + fmt.Println() + } + + if len(outOfDate) > 0 { + fmt.Print(boldRedFgBlackBg(arrow + " Out Of Date AUR Packages:")) + for _, name := range outOfDate { + fmt.Print(" " + boldYellowFgBlackBg(name)) + } + fmt.Println() + } + return info, nil } From dab8f1b5d2aff1ecec6386bad58e5b196b5bfc94 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 06:52:11 +0000 Subject: [PATCH 08/18] Improve gendb and formatting Exit after parsing srcinfo with db do it actually does something. when using gendb dont bother generating srcinfos. Improved the formatting for some things mainly downloading and parsing. --- install.go | 125 ++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 91 insertions(+), 34 deletions(-) diff --git a/install.go b/install.go index 3b53627b..c506b805 100644 --- a/install.go +++ b/install.go @@ -52,18 +52,13 @@ func install(parser *arguments) error { } //only error if direct targets or deps are missing - missing := make(stringSet) - for missingName := range dt.Missing { + for missingName := range dt.Missing { if !remoteNamesCache.get(missingName) { - missing.set(missingName) + return fmt.Errorf(boldRedFgBlackBg(arrow+" Error: ") + + blackBg("Could not find all required package")) } } - if len(missing) > 0 { - printMissing(missing) - return fmt.Errorf("Could not find all required packages") - } - //create the arguments to pass for the repo install arguments := parser.copy() arguments.delArg("u", "sysupgrade") @@ -124,7 +119,7 @@ func install(parser *arguments) error { if len(arguments.targets) > 0 { err := passToPacman(arguments) if err != nil { - fmt.Println("Error installing repo packages.") + fmt.Errorf("Error installing repo packages.") } } @@ -176,22 +171,33 @@ func install(parser *arguments) error { return err } }*/ - - if arguments.existsArg("gendb") { - fmt.Println("GenDB finished. No packages were installed") - return nil - } - + // if !continueTask("Proceed with install?", "nN") { // return fmt.Errorf("Aborting due to user") // } + //this downloads the package build sources but also causes + //a version bumb for vsc packages + //that should not edit the sources so we should be safe to skip + //it and parse the srcinfo at the current version + if arguments.existsArg("gendb") { + err = parsesrcinfosFile(dc.Aur, srcinfos, dc.Bases) + if err != nil { + return err + } + + + fmt.Println(boldGreenFg(arrow+" GenDB finished. No packages were installed")) + return nil + } + err = downloadPkgBuildsSources(dc.Aur) if err != nil { return err } - err = parsesrcinfos(dc.Aur, srcinfos) + + err = parsesrcinfosGenerate(dc.Aur, srcinfos, dc.Bases) if err != nil { return err } @@ -329,10 +335,67 @@ func askEditPkgBuilds(pkgs []*rpc.Pkg, bases map[string][]*rpc.Pkg) error { return nil } -func parsesrcinfos(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD) error { - for _, pkg := range pkgs { +func updateVSCdb(pkgbuild *gopkg.PKGBUILD) { + for _, pkgsource := range pkgbuild.Source { + owner, repo := parseSource(pkgsource) + if owner != "" && repo != "" { + err := branchInfo(pkgbuild.Pkgbase, owner, repo) + if err != nil { + fmt.Println(err) + } + } + } +} + +func parsesrcinfosFile(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, bases map[string][]*rpc.Pkg) error { + for k, pkg := range pkgs { dir := config.BuildDir + pkg.PackageBase + "/" + str := boldCyanFg("::") + boldFg(" Parsing SRCINFO (%d/%d): %s-%s") + str2 := "" + if len(bases[pkg.PackageBase]) > 1 || pkg.PackageBase != pkg.Name { + str2 += " (" + for _, split := range bases[pkg.PackageBase] { + str2 += split.Name + " " + } + str2 = str2[:len(str2)-1] + ")" + } + fmt.Printf(str, k+1, len(pkgs), pkg.PackageBase, pkg.Version) + fmt.Print(str2) + fmt.Println() + + + pkgbuild, err := gopkg.ParseSRCINFO(dir + ".SRCINFO") + if err != nil { + return fmt.Errorf("%s: %s", pkg.Name, err) + } + + srcinfos[pkg.PackageBase] = pkgbuild + updateVSCdb(pkgbuild) + } + + return nil +} + +func parsesrcinfosGenerate(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, bases map[string][]*rpc.Pkg) error { + for k, pkg := range pkgs { + dir := config.BuildDir + pkg.PackageBase + "/" + + str := "Parsing SRCINFO (%d/%d): %s-%s" + str2 := "" + if len(bases[pkg.PackageBase]) > 1 || pkg.PackageBase != pkg.Name { + str2 += " (" + for _, split := range bases[pkg.PackageBase] { + str2 += split.Name + " " + } + str2 = str2[:len(str2)-1] + ")" + } + fmt.Printf(str, k+1, len(pkgs), pkg.PackageBase, pkg.Version) + fmt.Print(str2) + fmt.Println() + + + cmd := exec.Command(config.MakepkgBin, "--printsrcinfo") cmd.Stderr = os.Stderr cmd.Dir = dir @@ -348,33 +411,27 @@ func parsesrcinfos(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD) error { } srcinfos[pkg.PackageBase] = pkgbuild - - for _, pkgsource := range pkgbuild.Source { - owner, repo := parseSource(pkgsource) - if owner != "" && repo != "" { - err = branchInfo(pkg.Name, owner, repo) - if err != nil { - return err - } - } - } + updateVSCdb(pkgbuild) } return nil } func dowloadPkgBuilds(pkgs []*rpc.Pkg, bases map[string][]*rpc.Pkg) (err error) { - for _, pkg := range pkgs { + for k, pkg := range pkgs { //todo make pretty - str := "Downloading: " + pkg.PackageBase + "-" + pkg.Version + str := boldCyanFg("::") + boldFg(" Downloading (%d/%d): %s-%s") + str2 := "" if len(bases[pkg.PackageBase]) > 1 || pkg.PackageBase != pkg.Name { - str += " (" + str2 += " (" for _, split := range bases[pkg.PackageBase] { - str += split.Name + " " + str2 += split.Name + " " } - str = str[:len(str)-1] + ")" + str2 = str2[:len(str2)-1] + ")" } - fmt.Println(str) + fmt.Printf(str, k+1, len(pkgs), pkg.PackageBase, pkg.Version) + fmt.Print(str2) + fmt.Println() err = downloadAndUnpack(baseURL+pkg.URLPath, config.BuildDir, false) if err != nil { From 716d775d5fac70fce8b22b13d3023f4f539fa9ed Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 17:01:19 +0000 Subject: [PATCH 09/18] Improve formatting Ignorepkg also colours version differences like the upgrade menu Tweaked formatting when asking for users to eneter number --- cmd.go | 5 ++--- upgrade.go | 57 ++++++++++++++++++++++++++++-------------------------- 2 files changed, 32 insertions(+), 30 deletions(-) diff --git a/cmd.go b/cmd.go index b2752167..2a54afed 100644 --- a/cmd.go +++ b/cmd.go @@ -593,9 +593,8 @@ func numberMenu(pkgS []string, flags []string) (err error) { aurQ.printSearch(numpq + 1) } - 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: ") + fmt.Println(boldGreenFg(arrow) + boldGreenFg(" Packages to not upgrade (eg: 1 2 3, 1-3 or ^4)")) + fmt.Print(boldGreenFg(arrow + " ")) reader := bufio.NewReader(os.Stdin) numberBuf, overflow, err := reader.ReadLine() if err != nil || overflow { diff --git a/upgrade.go b/upgrade.go index d1c3da17..73d3dbaa 100644 --- a/upgrade.go +++ b/upgrade.go @@ -56,12 +56,34 @@ func (u upSlice) Less(i, j int) bool { return false } +func getVersionDiff(oldVersion, newversion string) (left, right string) { + old, errOld := pkgb.NewCompleteVersion(oldVersion) + new, errNew := pkgb.NewCompleteVersion(newversion) + + if errOld != nil { + left = redFg("Invalid Version") + } + if errNew != nil { + right = redFg("Invalid Version") + } + + if errOld == nil && errNew == nil { + if old.Version == new.Version { + left = string(old.Version) + "-" + redFg(string(old.Pkgrel)) + right = string(new.Version) + "-" + greenFg(string(new.Pkgrel)) + } else { + left = redFg(string(old.Version)) + "-" + string(old.Pkgrel) + right = boldGreenFg(string(new.Version)) + "-" + string(new.Pkgrel) + } + } + + return +} + // Print prints the details of the packages to upgrade. func (u upSlice) Print(start int) { for k, i := range u { - old, errOld := pkgb.NewCompleteVersion(i.LocalVersion) - new, errNew := pkgb.NewCompleteVersion(i.RemoteVersion) - var left, right string + left, right := getVersionDiff(i.LocalVersion, i.RemoteVersion) f := func(name string) (output string) { if alpmConf.Options&alpm.ConfColor == 0 { @@ -76,26 +98,6 @@ func (u upSlice) Print(start int) { fmt.Print(yellowFg(fmt.Sprintf("%2d ", len(u)+start-k-1))) fmt.Print(f(i.Repository), "/", boldWhiteFg(i.Name)) - if errOld != nil { - left = redFg("Invalid Version") - } else { - 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 = redFg("Invalid Version") - } else { - if old.Version == new.Version { - right = string(new.Version) + "-" + greenFg(string(new.Pkgrel)) - } else { - right = boldGreenFg(string(new.Version)) + "-" + string(new.Pkgrel) - } - } - w := 70 - len(i.Repository) - len(i.Name) + len(left) fmt.Printf(fmt.Sprintf("%%%ds", w), fmt.Sprintf("%s -> %s\n", left, right)) @@ -167,7 +169,7 @@ func upDevel(remote []alpm.Package, packageC chan upgrade, done chan bool) { 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"} + packageC <- upgrade{e.Package, "devel", pkg.Version() , "commit-" + e.SHA[0:6]} } } else { removeVCSPackage([]string{e.Package}) @@ -203,8 +205,9 @@ func upAUR(remote []alpm.Package, remoteNames []string, dt *depTree) (toUpgrade if (config.TimeUpdate && (int64(aurPkg.LastModified) > pkg.BuildDate().Unix())) || (alpm.VerCmp(pkg.Version(), aurPkg.Version) < 0) { if pkg.ShouldIgnore() { + left, right := getVersionDiff(pkg.Version(), aurPkg.Version) fmt.Print(yellowFg("Warning: ")) - fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), aurPkg.Version) + fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), left, right) } else { packageC <- upgrade{aurPkg.Name, "aur", pkg.Version(), aurPkg.Version} } @@ -306,8 +309,8 @@ func upgradePkgs(dt *depTree) (stringSet, stringSet, error) { aurUp.Print(1) if !config.NoConfirm { - fmt.Println(greenFg("Enter packages you don't want to upgrade.")) - fmt.Print("Numbers: ") + fmt.Println(boldGreenFg(arrow) + greenFg(" Packages to not upgrade (eg: 1 2 3, 1-3 or ^4)")) + fmt.Print(boldGreenFg(arrow + " ")) reader := bufio.NewReader(os.Stdin) numberBuf, overflow, err := reader.ReadLine() From 2f39f5ddc4c61cafa6a0a51f1d3ad3fc19e7a3d2 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 17:35:47 +0000 Subject: [PATCH 10/18] Only print "querying aur" when using the aur --- install.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/install.go b/install.go index c506b805..b83269c5 100644 --- a/install.go +++ b/install.go @@ -44,8 +44,9 @@ func install(parser *arguments) error { requestTargets = append(requestTargets, remoteNames...) } - - fmt.Println(boldCyanFg("::"), boldFg("Querying AUR...")) + if len(requestTargets) > 0 { + fmt.Println(boldCyanFg("::"), boldFg("Querying AUR...")) + } dt , err := getDepTree(requestTargets) if err != nil { return err From c189a98018d478c49b99b08eebabe4da103dd412 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 17:36:33 +0000 Subject: [PATCH 11/18] Re enable -Pu and -Pn --- print.go | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/print.go b/print.go index 88d620ef..407e42e7 100644 --- a/print.go +++ b/print.go @@ -2,7 +2,7 @@ package main import ( "fmt" -// "os" + "os" "strconv" "strings" @@ -273,24 +273,28 @@ func printMissing(missing stringSet) { //todo make it less hacky func printNumberOfUpdates() error { //todo - /*old := os.Stdout // keep backup of the real stdout + old := os.Stdout // keep backup of the real stdout os.Stdout = nil - aurUp, repoUp, err := upList() + _, _, localNames, remoteNames, err := filterPackages() + dt, _ := getDepTree(append(localNames, remoteNames...)) + aurUp, repoUp, err := upList(dt) os.Stdout = old // restoring the real stdout if err != nil { return err } fmt.Println(len(aurUp) + len(repoUp)) - */ + return nil } //todo make it less hacky func printUpdateList() error { - /* old := os.Stdout // keep backup of the real stdout os.Stdout = nil - aurUp, repoUp, err := upList() + _, _, localNames, remoteNames, err := filterPackages() + dt, _ := getDepTree(append(localNames, remoteNames...)) + aurUp, repoUp, err := upList(dt) + os.Stdout = old // restoring the real stdout if err != nil { return err @@ -302,7 +306,7 @@ func printUpdateList() error { for _, pkg := range aurUp { fmt.Println(pkg.Name) } -*/ + return nil } From 4a142425ec0cdb887863e404e65dc68ff2b76609 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 17:53:03 +0000 Subject: [PATCH 12/18] Add support fot CheckDepends Note when installing CheckDepends are still refered to as MakeDepends. They are both only needed during build time so technically that is correct. I don't see much of a use creating a third field so I'm leaving it as is for now. --- dependencies.go | 4 ++-- print.go | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/dependencies.go b/dependencies.go index 912521ad..7dba74d2 100644 --- a/dependencies.go +++ b/dependencies.go @@ -118,7 +118,7 @@ func repoDepCatagoriesRecursive(pkg *alpm.Package, dc *depCatagories, dt *depTre } func depCatagoriesRecursive(pkg *rpc.Pkg, dc *depCatagories, dt *depTree, isMake bool, seen stringSet) { - for _, deps := range [2][]string{pkg.Depends, pkg.MakeDepends} { + for _, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} { for _, _dep := range deps { dep := getNameFromDep(_dep) @@ -276,7 +276,7 @@ func depTreeRecursive(dt *depTree, localDb *alpm.Db, syncDb alpm.DbList, isMake } //for each dep and makedep - for _, deps := range [2][]string{pkg.Depends, pkg.MakeDepends} { + for _, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} { for _, versionedDep := range deps { dep := getNameFromDep(versionedDep) diff --git a/print.go b/print.go index 407e42e7..3bd083dc 100644 --- a/print.go +++ b/print.go @@ -201,6 +201,7 @@ func PrintInfo(a *rpc.Pkg) { 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("Check Deps :"), strings.Join(a.CheckDepends, " ")) fmt.Println(boldWhiteFg("Optional Deps :"), strings.Join(a.OptDepends, " ")) fmt.Println(boldWhiteFg("Conflicts With :"), strings.Join(a.Conflicts, " ")) fmt.Println(boldWhiteFg("Maintainer :"), a.Maintainer) From e015c612d8bf4e995efdc00e52d705febf2987e5 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 18:06:23 +0000 Subject: [PATCH 13/18] Remove -s from makepkg The -s was kept aroung because the package base `python-virtualfish` failed to build without it. I first blamed this on some aur rpc bug because it was missing some deps that were listed in python-virtualfish. As is turned out python-virtualfish actually does some things wrong in it's package build and if it was formated correctly this wouldnt be a problem. I kept the -s in just so it would build even though it might have had some side affects. makepkg not respecting the --dbpath for example. From now on python-virtualfish will fail to build when you dont have all the deps installed. This is their fault and will not be fixed here. --- install.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/install.go b/install.go index b83269c5..34baf835 100644 --- a/install.go +++ b/install.go @@ -481,7 +481,7 @@ func buildInstallPkgBuilds(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, fmt.Println(boldRedFgBlackBg(arrow+" Warning:"), blackBg(pkg.Name+"-"+pkg.Version+" Already made -- skipping build")) } else { - err := passToMakepkg(dir, "-Cscf", "--noconfirm") + err := passToMakepkg(dir, "-Ccf", "--noconfirm") if err != nil { return err } From deed5e679440555f84bec0e03cf60dd1f4f4af69 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Mon, 19 Feb 2018 19:38:34 +0000 Subject: [PATCH 14/18] Fix yay not installing repo deps properly --- install.go | 50 ++++++++++++++++++++++++-------------------------- 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/install.go b/install.go index 34baf835..1c25d24d 100644 --- a/install.go +++ b/install.go @@ -24,7 +24,7 @@ func install(parser *arguments) error { var dc *depCatagories //fmt.Println(greenFg(arrow), greenFg("Resolving Dependencies")) - requestTargets := aur + requestTargets := append(aur, repo...) //remotenames: names of all non repo packages on the system _, _, _, remoteNames, err := filterPackages() @@ -44,7 +44,7 @@ func install(parser *arguments) error { requestTargets = append(requestTargets, remoteNames...) } - if len(requestTargets) > 0 { + if len(aur) > 0 { fmt.Println(boldCyanFg("::"), boldFg("Querying AUR...")) } dt , err := getDepTree(requestTargets) @@ -93,28 +93,32 @@ func install(parser *arguments) error { } } + hasAur := len(dt.Aur) != 0 + dc, err = getDepCatagories(parser.formatTargets(), dt) + if err != nil { + return err + } + + for _, pkg := range dc.Repo { + arguments.addTarget(pkg.Name()) + } + for _, pkg := range repo { arguments.addTarget(pkg) } - hasAur := len(dt.Aur) != 0 + if hasAur { - dc, err = getDepCatagories(parser.formatTargets(), dt) - if err != nil { - return err - } - - //printDownloadsFromRepo("Repo", dc.Repo) - //printDownloadsFromRepo("Repo Make", dc.RepoMake) - //printDownloadsFromAur("AUR", dc.Aur) - //printDownloadsFromAur("AUR Make", dc.AurMake) - - //fmt.Println(dc.MakeOnly) - //fmt.Println(dc.AurSet) - printDepCatagories(dc) fmt.Println() + + if !parser.existsArg("gendb") { + err = checkForConflicts(dc) + if err != nil { + return err + } + } } if len(arguments.targets) > 0 { @@ -125,12 +129,10 @@ func install(parser *arguments) error { } if hasAur { - if !parser.existsArg("gendb") { - err = checkForConflicts(dc) - if err != nil { - return err - } - } + //conflicts have been checked so answer y for them + ask, _ := strconv.Atoi(cmdArgs.globals["ask"]) + uask := alpm.Question(ask) | alpm.QuestionConflictPkg + cmdArgs.globals["ask"] = fmt.Sprint(uask) askCleanBuilds(dc.Aur, dc.Bases) fmt.Println() @@ -304,10 +306,6 @@ func checkForConflicts(dc *depCatagories) error { if !continueTask("Continue with install?", "nN") { return fmt.Errorf("Aborting due to user") } - - ask, _ := strconv.Atoi(cmdArgs.globals["ask"]) - uask := alpm.Question(ask) | alpm.QuestionConflictPkg - cmdArgs.globals["ask"] = fmt.Sprint(uask) } return nil From b50fae1dd430b9de8ea6e7a166efa6e89a501288 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Tue, 20 Feb 2018 06:35:46 +0000 Subject: [PATCH 15/18] Reword conflicting package message The old message was probably easy to confuse with the `replaces` term. --- install.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/install.go b/install.go index 1c25d24d..03e0ed81 100644 --- a/install.go +++ b/install.go @@ -295,7 +295,7 @@ func checkForConflicts(dc *depCatagories) error { fmt.Println( redFg("Package conflicts found:")) for name, pkgs := range toRemove { - str := yellowFg("\t" + name) + " Replaces" + str := "\tInstalling " + yellowFg(name) + " will remove" for pkg := range pkgs { str += " " + yellowFg(pkg) } From 31d6a95c2a1ada67412d16a94e494c0de7a4c5f9 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Tue, 20 Feb 2018 01:23:16 +0000 Subject: [PATCH 16/18] Tweak some of the printting and fix formatting --- install.go | 76 +++++++++++++++++------------------------------------- print.go | 16 ++++++++++++ 2 files changed, 39 insertions(+), 53 deletions(-) diff --git a/install.go b/install.go index 03e0ed81..e8e23520 100644 --- a/install.go +++ b/install.go @@ -44,7 +44,7 @@ func install(parser *arguments) error { requestTargets = append(requestTargets, remoteNames...) } - if len(aur) > 0 { + if len(aur) > 0 || parser.existsArg("u", "sysupgrade") && len(remoteNames) > 0 { fmt.Println(boldCyanFg("::"), boldFg("Querying AUR...")) } dt , err := getDepTree(requestTargets) @@ -107,6 +107,10 @@ func install(parser *arguments) error { arguments.addTarget(pkg) } + if len(dc.Aur) == 0 && len(arguments.targets) == 0 { + fmt.Println("nothing to do ") + return nil + } if hasAur { @@ -119,12 +123,17 @@ func install(parser *arguments) error { return err } } + + if !continueTask("Proceed with install?", "nN") { + return fmt.Errorf("Aborting due to user") + } + } - - if len(arguments.targets) > 0 { + + if !parser.existsArg("gendb") && len(arguments.targets) > 0 { err := passToPacman(arguments) if err != nil { - fmt.Errorf("Error installing repo packages.") + return fmt.Errorf("Error installing repo packages.") } } @@ -134,12 +143,8 @@ func install(parser *arguments) error { uask := alpm.Question(ask) | alpm.QuestionConflictPkg cmdArgs.globals["ask"] = fmt.Sprint(uask) + askCleanBuilds(dc.Aur, dc.Bases) - fmt.Println() - - if !continueTask("Proceed with install?", "nN") { - return fmt.Errorf("Aborting due to user") - } // if !continueTask("Proceed with download?", "nN") { // return fmt.Errorf("Aborting due to user") @@ -302,10 +307,6 @@ func checkForConflicts(dc *depCatagories) error { fmt.Println(str) } - - if !continueTask("Continue with install?", "nN") { - return fmt.Errorf("Aborting due to user") - } } return nil @@ -350,18 +351,8 @@ func parsesrcinfosFile(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, bas for k, pkg := range pkgs { dir := config.BuildDir + pkg.PackageBase + "/" - str := boldCyanFg("::") + boldFg(" Parsing SRCINFO (%d/%d): %s-%s") - str2 := "" - if len(bases[pkg.PackageBase]) > 1 || pkg.PackageBase != pkg.Name { - str2 += " (" - for _, split := range bases[pkg.PackageBase] { - str2 += split.Name + " " - } - str2 = str2[:len(str2)-1] + ")" - } - fmt.Printf(str, k+1, len(pkgs), pkg.PackageBase, pkg.Version) - fmt.Print(str2) - fmt.Println() + str := boldCyanFg("::") + boldFg(" Parsing SRCINFO (%d/%d): %s\n") + fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases)) pkgbuild, err := gopkg.ParseSRCINFO(dir + ".SRCINFO") @@ -380,20 +371,8 @@ func parsesrcinfosGenerate(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, for k, pkg := range pkgs { dir := config.BuildDir + pkg.PackageBase + "/" - str := "Parsing SRCINFO (%d/%d): %s-%s" - str2 := "" - if len(bases[pkg.PackageBase]) > 1 || pkg.PackageBase != pkg.Name { - str2 += " (" - for _, split := range bases[pkg.PackageBase] { - str2 += split.Name + " " - } - str2 = str2[:len(str2)-1] + ")" - } - fmt.Printf(str, k+1, len(pkgs), pkg.PackageBase, pkg.Version) - fmt.Print(str2) - fmt.Println() - - + str := boldCyanFg("::") + boldFg(" Parsing SRCINFO (%d/%d): %s\n") + fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases)) cmd := exec.Command(config.MakepkgBin, "--printsrcinfo") cmd.Stderr = os.Stderr @@ -419,18 +398,9 @@ func parsesrcinfosGenerate(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, func dowloadPkgBuilds(pkgs []*rpc.Pkg, bases map[string][]*rpc.Pkg) (err error) { for k, pkg := range pkgs { //todo make pretty - str := boldCyanFg("::") + boldFg(" Downloading (%d/%d): %s-%s") - str2 := "" - if len(bases[pkg.PackageBase]) > 1 || pkg.PackageBase != pkg.Name { - str2 += " (" - for _, split := range bases[pkg.PackageBase] { - str2 += split.Name + " " - } - str2 = str2[:len(str2)-1] + ")" - } - fmt.Printf(str, k+1, len(pkgs), pkg.PackageBase, pkg.Version) - fmt.Print(str2) - fmt.Println() + str := boldCyanFg("::") + boldFg(" Downloading (%d/%d): %s\n") + + fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases)) err = downloadAndUnpack(baseURL+pkg.URLPath, config.BuildDir, false) if err != nil { @@ -446,7 +416,7 @@ func downloadPkgBuildsSources(pkgs []*rpc.Pkg) (err error) { dir := config.BuildDir + pkg.PackageBase + "/" err = passToMakepkg(dir, "--nobuild", "--nocheck", "--noprepare", "--nodeps") if err != nil { - return + return fmt.Errorf("Error downloading sources: %s", pkg) } } @@ -481,7 +451,7 @@ func buildInstallPkgBuilds(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, } else { err := passToMakepkg(dir, "-Ccf", "--noconfirm") if err != nil { - return err + return fmt.Errorf("Error making: %s", pkg.Name) } } diff --git a/print.go b/print.go index 3bd083dc..4bd6521c 100644 --- a/print.go +++ b/print.go @@ -94,6 +94,22 @@ func (s repoQuery) printSearch() { } } +func formatPkgbase(pkg *rpc.Pkg, bases map[string][]*rpc.Pkg) string { + str := pkg.PackageBase + if len(bases[pkg.PackageBase]) > 1 || pkg.PackageBase != pkg.Name { + str2 := " (" + for _, split := range bases[pkg.PackageBase] { + str2 += split.Name + " " + } + str2 = str2[:len(str2)-1] + ")" + + str += str2 + } + + return str +} + + // printDownloadsFromRepo prints repository packages to be downloaded func printDepCatagories(dc *depCatagories) { repo := "" From 4ef282c54eb01d90bbfb116d523f0739b35831de Mon Sep 17 00:00:00 2001 From: morganamilo Date: Wed, 21 Feb 2018 08:41:25 +0000 Subject: [PATCH 17/18] go fmt --- dependencies.go | 2 +- download.go | 6 +++--- install.go | 34 ++++++++++++++-------------------- print.go | 3 +-- query.go | 8 ++++---- upgrade.go | 43 +++++++++++++++++++++---------------------- 6 files changed, 44 insertions(+), 52 deletions(-) diff --git a/dependencies.go b/dependencies.go index 7dba74d2..67e32057 100644 --- a/dependencies.go +++ b/dependencies.go @@ -1,9 +1,9 @@ package main import ( - "strings" alpm "github.com/jguer/go-alpm" rpc "github.com/mikkeloscar/aur" + "strings" ) type depTree struct { diff --git a/download.go b/download.go index b76408f1..090f7330 100644 --- a/download.go +++ b/download.go @@ -61,7 +61,7 @@ func downloadAndUnpack(url string, path string, trim bool) (err error) { return } -func getPkgbuilds(pkgs []string) (error) { +func getPkgbuilds(pkgs []string) error { //possibleAurs := make([]string, 0, 0) wd, err := os.Getwd() if err != nil { @@ -85,7 +85,7 @@ func getPkgbuildsfromABS(pkgs []string, path string) (missing []string, err erro return } - nextPkg: +nextPkg: for _, pkgN := range pkgs { for _, db := range dbList.Slice() { pkg, err := db.PkgByName(pkgN) @@ -103,7 +103,7 @@ func getPkgbuildsfromABS(pkgs []string, path string) (missing []string, err erro if errD != nil { fmt.Println(boldYellowFg(pkg.Name()), boldGreenFg(errD.Error())) } - + fmt.Println(boldGreenFg(arrow), boldGreenFg("Downloaded"), boldYellowFg(pkg.Name()), boldGreenFg("from ABS")) continue nextPkg } diff --git a/install.go b/install.go index e8e23520..7733c0c5 100644 --- a/install.go +++ b/install.go @@ -5,8 +5,8 @@ import ( "io/ioutil" "os" "os/exec" - "strings" "strconv" + "strings" alpm "github.com/jguer/go-alpm" rpc "github.com/mikkeloscar/aur" @@ -17,7 +17,7 @@ import ( func install(parser *arguments) error { aur, repo, err := packageSlices(parser.targets.toSlice()) if err != nil { - return err + return err } srcinfos := make(map[string]*gopkg.PKGBUILD) @@ -29,7 +29,7 @@ func install(parser *arguments) error { //remotenames: names of all non repo packages on the system _, _, _, remoteNames, err := filterPackages() if err != nil { - return err + return err } //cache as a stringset. maybe make it return a string set in the first @@ -44,10 +44,10 @@ func install(parser *arguments) error { requestTargets = append(requestTargets, remoteNames...) } - if len(aur) > 0 || parser.existsArg("u", "sysupgrade") && len(remoteNames) > 0 { + if len(aur) > 0 || parser.existsArg("u", "sysupgrade") && len(remoteNames) > 0 { fmt.Println(boldCyanFg("::"), boldFg("Querying AUR...")) } - dt , err := getDepTree(requestTargets) + dt, err := getDepTree(requestTargets) if err != nil { return err } @@ -66,9 +66,9 @@ func install(parser *arguments) error { arguments.delArg("y", "refresh") arguments.op = "S" arguments.targets = make(stringSet) - + if parser.existsArg("u", "sysupgrade") { - repoUp, aurUp, err := upgradePkgs(dt) + repoUp, aurUp, err := upgradePkgs(dt) if err != nil { return err } @@ -76,12 +76,11 @@ func install(parser *arguments) error { for pkg := range aurUp { parser.addTarget(pkg) } - + for pkg := range repoUp { arguments.addTarget(pkg) } - //discard stuff thats //not a target and //not an upgrade and @@ -112,7 +111,6 @@ func install(parser *arguments) error { return nil } - if hasAur { printDepCatagories(dc) fmt.Println() @@ -143,12 +141,11 @@ func install(parser *arguments) error { uask := alpm.Question(ask) | alpm.QuestionConflictPkg cmdArgs.globals["ask"] = fmt.Sprint(uask) - askCleanBuilds(dc.Aur, dc.Bases) // if !continueTask("Proceed with download?", "nN") { // return fmt.Errorf("Aborting due to user") - // } + // } err = dowloadPkgBuilds(dc.Aur, dc.Bases) if err != nil { @@ -179,7 +176,7 @@ func install(parser *arguments) error { return err } }*/ - + // if !continueTask("Proceed with install?", "nN") { // return fmt.Errorf("Aborting due to user") // } @@ -188,14 +185,13 @@ func install(parser *arguments) error { //a version bumb for vsc packages //that should not edit the sources so we should be safe to skip //it and parse the srcinfo at the current version - if arguments.existsArg("gendb") { + if arguments.existsArg("gendb") { err = parsesrcinfosFile(dc.Aur, srcinfos, dc.Bases) if err != nil { return err } - - fmt.Println(boldGreenFg(arrow+" GenDB finished. No packages were installed")) + fmt.Println(boldGreenFg(arrow + " GenDB finished. No packages were installed")) return nil } @@ -204,7 +200,6 @@ func install(parser *arguments) error { return err } - err = parsesrcinfosGenerate(dc.Aur, srcinfos, dc.Bases) if err != nil { return err @@ -354,7 +349,6 @@ func parsesrcinfosFile(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, bas str := boldCyanFg("::") + boldFg(" Parsing SRCINFO (%d/%d): %s\n") fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases)) - pkgbuild, err := gopkg.ParseSRCINFO(dir + ".SRCINFO") if err != nil { return fmt.Errorf("%s: %s", pkg.Name, err) @@ -373,7 +367,7 @@ func parsesrcinfosGenerate(pkgs []*rpc.Pkg, srcinfos map[string]*gopkg.PKGBUILD, str := boldCyanFg("::") + boldFg(" Parsing SRCINFO (%d/%d): %s\n") fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases)) - + cmd := exec.Command(config.MakepkgBin, "--printsrcinfo") cmd.Stderr = os.Stderr cmd.Dir = dir @@ -400,7 +394,7 @@ func dowloadPkgBuilds(pkgs []*rpc.Pkg, bases map[string][]*rpc.Pkg) (err error) //todo make pretty str := boldCyanFg("::") + boldFg(" Downloading (%d/%d): %s\n") - fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases)) + fmt.Printf(str, k+1, len(pkgs), formatPkgbase(pkg, bases)) err = downloadAndUnpack(baseURL+pkg.URLPath, config.BuildDir, false) if err != nil { diff --git a/print.go b/print.go index 4bd6521c..4c8f11c2 100644 --- a/print.go +++ b/print.go @@ -109,7 +109,6 @@ func formatPkgbase(pkg *rpc.Pkg, bases map[string][]*rpc.Pkg) string { return str } - // printDownloadsFromRepo prints repository packages to be downloaded func printDepCatagories(dc *depCatagories) { repo := "" @@ -300,7 +299,7 @@ func printNumberOfUpdates() error { return err } fmt.Println(len(aurUp) + len(repoUp)) - + return nil } diff --git a/query.go b/query.go index a8525151..0cc0f892 100644 --- a/query.go +++ b/query.go @@ -394,7 +394,7 @@ func aurInfo(names []string) ([]rpc.Pkg, error) { } for n := 0; n < len(names); n += config.RequestSplitN { - max := min(len(names), n + config.RequestSplitN) + max := min(len(names), n+config.RequestSplitN) wg.Add(1) go makeRequest(n, max) } @@ -429,7 +429,7 @@ func aurInfo(names []string) ([]rpc.Pkg, error) { if len(missing) > 0 { fmt.Print(boldRedFgBlackBg(arrow + " Missing AUR Packages:")) for _, name := range missing { - fmt.Print(" " + boldYellowFgBlackBg(name)) + fmt.Print(" " + boldYellowFgBlackBg(name)) } fmt.Println() } @@ -437,7 +437,7 @@ func aurInfo(names []string) ([]rpc.Pkg, error) { if len(orphans) > 0 { fmt.Print(boldRedFgBlackBg(arrow + " Orphaned AUR Packages:")) for _, name := range orphans { - fmt.Print(" " + boldYellowFgBlackBg(name)) + fmt.Print(" " + boldYellowFgBlackBg(name)) } fmt.Println() } @@ -445,7 +445,7 @@ func aurInfo(names []string) ([]rpc.Pkg, error) { if len(outOfDate) > 0 { fmt.Print(boldRedFgBlackBg(arrow + " Out Of Date AUR Packages:")) for _, name := range outOfDate { - fmt.Print(" " + boldYellowFgBlackBg(name)) + fmt.Print(" " + boldYellowFgBlackBg(name)) } fmt.Println() } diff --git a/upgrade.go b/upgrade.go index 73d3dbaa..ce03328b 100644 --- a/upgrade.go +++ b/upgrade.go @@ -57,27 +57,27 @@ func (u upSlice) Less(i, j int) bool { } func getVersionDiff(oldVersion, newversion string) (left, right string) { - old, errOld := pkgb.NewCompleteVersion(oldVersion) - new, errNew := pkgb.NewCompleteVersion(newversion) - - if errOld != nil { - left = redFg("Invalid Version") - } - if errNew != nil { - right = redFg("Invalid Version") - } + old, errOld := pkgb.NewCompleteVersion(oldVersion) + new, errNew := pkgb.NewCompleteVersion(newversion) - if errOld == nil && errNew == nil { - if old.Version == new.Version { - left = string(old.Version) + "-" + redFg(string(old.Pkgrel)) - right = string(new.Version) + "-" + greenFg(string(new.Pkgrel)) - } else { - left = redFg(string(old.Version)) + "-" + string(old.Pkgrel) - right = boldGreenFg(string(new.Version)) + "-" + string(new.Pkgrel) - } - } + if errOld != nil { + left = redFg("Invalid Version") + } + if errNew != nil { + right = redFg("Invalid Version") + } - return + if errOld == nil && errNew == nil { + if old.Version == new.Version { + left = string(old.Version) + "-" + redFg(string(old.Pkgrel)) + right = string(new.Version) + "-" + greenFg(string(new.Pkgrel)) + } else { + left = redFg(string(old.Version)) + "-" + string(old.Pkgrel) + right = boldGreenFg(string(new.Version)) + "-" + string(new.Pkgrel) + } + } + + return } // Print prints the details of the packages to upgrade. @@ -169,7 +169,7 @@ func upDevel(remote []alpm.Package, packageC chan upgrade, done chan bool) { fmt.Print(yellowFg("Warning: ")) fmt.Printf("%s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), "git") } else { - packageC <- upgrade{e.Package, "devel", pkg.Version() , "commit-" + e.SHA[0:6]} + packageC <- upgrade{e.Package, "devel", pkg.Version(), "commit-" + e.SHA[0:6]} } } else { removeVCSPackage([]string{e.Package}) @@ -216,7 +216,7 @@ func upAUR(remote []alpm.Package, remoteNames []string, dt *depTree) (toUpgrade done <- true }(remote, remoteNames, dt) - + if routineDone == routines { err = nil return @@ -370,7 +370,6 @@ func upgradePkgs(dt *depTree) (stringSet, stringSet, error) { repoNums = removeIntListFromList(excludeRepo, repoNums) } - if len(repoUp) != 0 { repoloop: for i, k := range repoUp { From 4cdcdc30e90f31146e5d3da12a4862ca56607f00 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Wed, 21 Feb 2018 12:16:30 +0000 Subject: [PATCH 18/18] Further formatting tweaks Ask clean builds is now asked early and remembers what you choose when the install finishes. Fixup "there is nothing to do" message. --- install.go | 70 +++++++++++++++++++++--------------------------------- upgrade.go | 1 - 2 files changed, 27 insertions(+), 44 deletions(-) diff --git a/install.go b/install.go index 7733c0c5..45f78ba9 100644 --- a/install.go +++ b/install.go @@ -15,6 +15,7 @@ import ( // Install handles package installs func install(parser *arguments) error { + removeMake := false aur, repo, err := packageSlices(parser.targets.toSlice()) if err != nil { return err @@ -73,6 +74,8 @@ func install(parser *arguments) error { return err } + fmt.Println() + for pkg := range aurUp { parser.addTarget(pkg) } @@ -107,25 +110,13 @@ func install(parser *arguments) error { } if len(dc.Aur) == 0 && len(arguments.targets) == 0 { - fmt.Println("nothing to do ") + fmt.Println("There is nothing to do") return nil } if hasAur { printDepCatagories(dc) fmt.Println() - - if !parser.existsArg("gendb") { - err = checkForConflicts(dc) - if err != nil { - return err - } - } - - if !continueTask("Proceed with install?", "nN") { - return fmt.Errorf("Aborting due to user") - } - } if !parser.existsArg("gendb") && len(arguments.targets) > 0 { @@ -136,16 +127,24 @@ func install(parser *arguments) error { } if hasAur { - //conflicts have been checked so answer y for them - ask, _ := strconv.Atoi(cmdArgs.globals["ask"]) - uask := alpm.Question(ask) | alpm.QuestionConflictPkg - cmdArgs.globals["ask"] = fmt.Sprint(uask) + if !parser.existsArg("gendb") { + err = checkForConflicts(dc) + if err != nil { + return err + } + } + + if len(dc.MakeOnly) > 0 { + if !continueTask("Remove make dependencies after install?", "yY") { + removeMake = true + } + } askCleanBuilds(dc.Aur, dc.Bases) - // if !continueTask("Proceed with download?", "nN") { - // return fmt.Errorf("Aborting due to user") - // } + if !continueTask("Proceed with Download?", "nN") { + return fmt.Errorf("Aborting due to user") + } err = dowloadPkgBuilds(dc.Aur, dc.Bases) if err != nil { @@ -157,29 +156,14 @@ func install(parser *arguments) error { return err } - /*if len(dc.Repo) > 0 { - arguments := parser.copy() - arguments.delArg("u", "sysupgrade") - arguments.delArg("y", "refresh") - arguments.op = "S" - arguments.targets = make(stringSet) - arguments.addArg("needed", "asdeps") - for _, pkg := range dc.Repo { - arguments.addTarget(pkg.Name()) - } + if !continueTask("Proceed with install?", "nN") { + return fmt.Errorf("Aborting due to user") + } - oldConfirm := config.NoConfirm - config.NoConfirm = true - passToPacman(arguments) - config.NoConfirm = oldConfirm - if err != nil { - return err - } - }*/ - - // if !continueTask("Proceed with install?", "nN") { - // return fmt.Errorf("Aborting due to user") - // } + //conflicts have been checked so answer y for them + ask, _ := strconv.Atoi(cmdArgs.globals["ask"]) + uask := alpm.Question(ask) | alpm.QuestionConflictPkg + cmdArgs.globals["ask"] = fmt.Sprint(uask) //this downloads the package build sources but also causes //a version bumb for vsc packages @@ -211,7 +195,7 @@ func install(parser *arguments) error { } if len(dc.MakeOnly) > 0 { - if continueTask("Remove make dependencies?", "yY") { + if !removeMake { return nil } diff --git a/upgrade.go b/upgrade.go index ce03328b..eeafd8d7 100644 --- a/upgrade.go +++ b/upgrade.go @@ -299,7 +299,6 @@ func upgradePkgs(dt *depTree) (stringSet, stringSet, error) { if err != nil { return repoNames, aurNames, err } else if len(aurUp)+len(repoUp) == 0 { - fmt.Println("\nThere is nothing to do") return repoNames, aurNames, err }