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

@@ -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)
 	}

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
 	}
 
+	//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 {
-		fmt.Println(missing)
-		fmt.Println("Could not find all Targets")
+		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 parser.existsArg("u", "sysupgrade") {
+		repoUp, aurUp, err  := upgradePkgs(dt)
 		if err != nil {
-			fmt.Println("Error installing repo packages.")
+			return err
 		}
-	}
-
-	if len(aurs) != 0 {
-		//todo mamakeke pretty
-		fmt.Println(greenFg(arrow), greenFg("Resolving Dependencies"))
 
-		dt, err := getDepTree(aurs)
-		if err != nil {
-			return err
+		for pkg := range aurUp {
+			parser.addTarget(pkg)
+		}
+		
+		for pkg := range repoUp {
+			arguments.addTarget(pkg)
 		}
 
-		if len(dt.Missing) > 0 {
-			fmt.Println(dt.Missing)
-			return fmt.Errorf("Could not find all Deps")
+	
+		//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)
+	}
+
 
-		dc, err := getDepCatagories(aurs, dt)
+	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")

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
 }
 

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,28 +260,8 @@ func packageSlices(toCheck []string) (aur []string, repo []string, missing []str
 		if found {
 			repo = append(repo, pkg)
 		} else {
-			possibleAur = append(possibleAur, 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
-			}
+			aur = append(aur, pkg)
 		}
-		missing = append(missing, pkg)
 	}
 
 	return

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()
+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 err
+		return repoNames, aurNames, err
 	} else if len(aurUp)+len(repoUp) == 0 {
 		fmt.Println("\nThere is nothing to do")
-		return err
+		return repoNames, aurNames, err
 	}
 
-	var repoNums []int
-	var aurNums []int
 	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
 }