Improvements to install algorithm

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
 }
 
@@ -497,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)
 	}
@@ -602,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 {

dependencies.go

@@ -1,14 +1,13 @@
 package main
 
 import (
-	"strings"
-
 	alpm "github.com/jguer/go-alpm"
 	rpc "github.com/mikkeloscar/aur"
+	"strings"
 )
 
 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),
@@ -119,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)
 
@@ -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,17 +266,17 @@ 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 _, deps := range [2][]string{pkg.Depends, pkg.MakeDepends} {
+		//for each dep and makedep
+		for _, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} {
 			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)
 			}
 		}
 	}

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
 }