Remove depPool and depOrder code

dep.go

@@ -8,6 +8,11 @@ import (
 	rpc "github.com/mikkeloscar/aur"
 )
 
+type missing struct {
+	Good    stringSet
+	Missing map[string][][]string
+}
+
 type providers struct {
 	lookfor string
 	Pkgs    []*rpc.Pkg

depCheck.go

@@ -1,295 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-
-	alpm "github.com/jguer/go-alpm"
-)
-
-func (dp *depPool) checkInnerConflict(name string, conflict string, conflicts mapStringSet) {
-	for _, pkg := range dp.Aur {
-		if pkg.Name == name {
-			continue
-		}
-
-		if satisfiesAur(conflict, pkg) {
-			conflicts.Add(name, pkg.Name)
-		}
-	}
-
-	for _, pkg := range dp.Repo {
-		if pkg.Name() == name {
-			continue
-		}
-
-		if satisfiesRepo(conflict, pkg) {
-			conflicts.Add(name, pkg.Name())
-		}
-	}
-}
-
-func (dp *depPool) checkForwardConflict(name string, conflict string, conflicts mapStringSet) {
-	dp.LocalDb.PkgCache().ForEach(func(pkg alpm.Package) error {
-		if pkg.Name() == name || dp.hasPackage(pkg.Name()) {
-			return nil
-		}
-
-		if satisfiesRepo(conflict, &pkg) {
-			n := pkg.Name()
-			if n != conflict {
-				n += " (" + conflict + ")"
-			}
-			conflicts.Add(name, n)
-		}
-
-		return nil
-	})
-}
-
-func (dp *depPool) checkReverseConflict(name string, conflict string, conflicts mapStringSet) {
-	for _, pkg := range dp.Aur {
-		if pkg.Name == name {
-			continue
-		}
-
-		if satisfiesAur(conflict, pkg) {
-			if name != conflict {
-				name += " (" + conflict + ")"
-			}
-
-			conflicts.Add(pkg.Name, name)
-		}
-	}
-
-	for _, pkg := range dp.Repo {
-		if pkg.Name() == name {
-			continue
-		}
-
-		if satisfiesRepo(conflict, pkg) {
-			if name != conflict {
-				name += " (" + conflict + ")"
-			}
-
-			conflicts.Add(pkg.Name(), name)
-		}
-	}
-}
-
-func (dp *depPool) checkInnerConflicts(conflicts mapStringSet) {
-	for _, pkg := range dp.Aur {
-		for _, conflict := range pkg.Conflicts {
-			dp.checkInnerConflict(pkg.Name, conflict, conflicts)
-		}
-	}
-
-	for _, pkg := range dp.Repo {
-		pkg.Conflicts().ForEach(func(conflict alpm.Depend) error {
-			dp.checkInnerConflict(pkg.Name(), conflict.String(), conflicts)
-			return nil
-		})
-	}
-}
-
-func (dp *depPool) checkForwardConflicts(conflicts mapStringSet) {
-	for _, pkg := range dp.Aur {
-		for _, conflict := range pkg.Conflicts {
-			dp.checkForwardConflict(pkg.Name, conflict, conflicts)
-		}
-	}
-
-	for _, pkg := range dp.Repo {
-		pkg.Conflicts().ForEach(func(conflict alpm.Depend) error {
-			dp.checkForwardConflict(pkg.Name(), conflict.String(), conflicts)
-			return nil
-		})
-	}
-}
-
-func (dp *depPool) checkReverseConflicts(conflicts mapStringSet) {
-	dp.LocalDb.PkgCache().ForEach(func(pkg alpm.Package) error {
-		if dp.hasPackage(pkg.Name()) {
-			return nil
-		}
-
-		pkg.Conflicts().ForEach(func(conflict alpm.Depend) error {
-			dp.checkReverseConflict(pkg.Name(), conflict.String(), conflicts)
-			return nil
-		})
-
-		return nil
-	})
-}
-
-func (dp *depPool) CheckConflicts() (mapStringSet, error) {
-	var wg sync.WaitGroup
-	innerConflicts := make(mapStringSet)
-	conflicts := make(mapStringSet)
-	wg.Add(2)
-
-	fmt.Println(bold(cyan("::") + bold(" Checking for conflicts...")))
-	go func() {
-		dp.checkForwardConflicts(conflicts)
-		dp.checkReverseConflicts(conflicts)
-		wg.Done()
-	}()
-
-	fmt.Println(bold(cyan("::") + bold(" Checking for inner conflicts...")))
-	go func() {
-		dp.checkInnerConflicts(innerConflicts)
-		wg.Done()
-	}()
-
-	wg.Wait()
-
-	if len(innerConflicts) != 0 {
-		fmt.Println()
-		fmt.Println(bold(red(arrow)), bold("Inner conflicts found:"))
-
-		for name, pkgs := range innerConflicts {
-			str := red(bold(smallArrow)) + " " + name + ":"
-			for pkg := range pkgs {
-				str += " " + cyan(pkg) + ","
-			}
-			str = strings.TrimSuffix(str, ",")
-
-			fmt.Println(str)
-		}
-
-	}
-
-	if len(conflicts) != 0 {
-		fmt.Println()
-		fmt.Println(bold(red(arrow)), bold("Package conflicts found:"))
-
-		for name, pkgs := range conflicts {
-			str := red(bold(smallArrow)) + " Installing " + cyan(name) + " will remove:"
-			for pkg := range pkgs {
-				str += " " + cyan(pkg) + ","
-			}
-			str = strings.TrimSuffix(str, ",")
-
-			fmt.Println(str)
-		}
-
-	}
-
-	// Add the inner conflicts to the conflicts
-	// These are used to decide what to pass --ask to (if set) or don't pass --noconfirm to
-	// As we have no idea what the order is yet we add every inner conflict to the slice
-	for name, pkgs := range innerConflicts {
-		conflicts[name] = make(stringSet)
-		for pkg := range pkgs {
-			conflicts[pkg] = make(stringSet)
-		}
-	}
-
-	if len(conflicts) > 0 {
-		if !config.UseAsk {
-			if config.NoConfirm {
-				return nil, fmt.Errorf("Package conflicts can not be resolved with noconfirm, aborting")
-			}
-
-			fmt.Println()
-			fmt.Println(bold(red(arrow)), bold("Conflicting packages will have to be confirmed manually"))
-			fmt.Println()
-		}
-	}
-
-	return conflicts, nil
-}
-
-type missing struct {
-	Good    stringSet
-	Missing map[string][][]string
-}
-
-func (dp *depPool) _checkMissing(dep string, stack []string, missing *missing) {
-	if missing.Good.get(dep) {
-		return
-	}
-
-	if trees, ok := missing.Missing[dep]; ok {
-		for _, tree := range trees {
-			if stringSliceEqual(tree, stack) {
-				return
-			}
-		}
-		missing.Missing[dep] = append(missing.Missing[dep], stack)
-		return
-	}
-
-	aurPkg := dp.findSatisfierAur(dep)
-	if aurPkg != nil {
-		missing.Good.set(dep)
-		for _, deps := range [3][]string{aurPkg.Depends, aurPkg.MakeDepends, aurPkg.CheckDepends} {
-			for _, aurDep := range deps {
-				if _, err := dp.LocalDb.PkgCache().FindSatisfier(aurDep); err == nil {
-					missing.Good.set(aurDep)
-					continue
-				}
-
-				dp._checkMissing(aurDep, append(stack, aurPkg.Name), missing)
-			}
-		}
-
-		return
-	}
-
-	repoPkg := dp.findSatisfierRepo(dep)
-	if repoPkg != nil {
-		missing.Good.set(dep)
-		repoPkg.Depends().ForEach(func(repoDep alpm.Depend) error {
-			if _, err := dp.LocalDb.PkgCache().FindSatisfier(repoDep.String()); err == nil {
-				missing.Good.set(repoDep.String())
-				return nil
-			}
-
-			dp._checkMissing(repoDep.String(), append(stack, repoPkg.Name()), missing)
-			return nil
-		})
-
-		return
-	}
-
-	missing.Missing[dep] = [][]string{stack}
-}
-
-func (dp *depPool) CheckMissing() error {
-	missing := &missing{
-		make(stringSet),
-		make(map[string][][]string),
-	}
-
-	for _, target := range dp.Targets {
-		dp._checkMissing(target.DepString(), make([]string, 0), missing)
-	}
-
-	if len(missing.Missing) == 0 {
-		return nil
-	}
-
-	fmt.Println(bold(red(arrow+" Error: ")) + "Could not find all required packages:")
-	for dep, trees := range missing.Missing {
-		for _, tree := range trees {
-
-			fmt.Print("    ", cyan(dep))
-
-			if len(tree) == 0 {
-				fmt.Print(" (Target")
-			} else {
-				fmt.Print(" (Wanted by: ")
-				for n := 0; n < len(tree)-1; n++ {
-					fmt.Print(cyan(tree[n]), " -> ")
-				}
-				fmt.Print(cyan(tree[len(tree)-1]))
-			}
-
-			fmt.Println(")")
-		}
-	}
-
-	return fmt.Errorf("")
-}

depOrder.go

@@ -1,121 +0,0 @@
-package main
-
-import (
-	alpm "github.com/jguer/go-alpm"
-	rpc "github.com/mikkeloscar/aur"
-)
-
-type depOrder struct {
-	Aur     []Base
-	Repo    []*alpm.Package
-	Runtime stringSet
-}
-
-func makeDepOrder() *depOrder {
-	return &depOrder{
-		make([]Base, 0),
-		make([]*alpm.Package, 0),
-		make(stringSet),
-	}
-}
-
-func getDepOrder(dp *depPool) *depOrder {
-	do := makeDepOrder()
-
-	for _, target := range dp.Targets {
-		dep := target.DepString()
-		aurPkg := dp.Aur[dep]
-		if aurPkg != nil && pkgSatisfies(aurPkg.Name, aurPkg.Version, dep) {
-			do.orderPkgAur(aurPkg, dp, true)
-		}
-
-		aurPkg = dp.findSatisfierAur(dep)
-		if aurPkg != nil {
-			do.orderPkgAur(aurPkg, dp, true)
-		}
-
-		repoPkg := dp.findSatisfierRepo(dep)
-		if repoPkg != nil {
-			do.orderPkgRepo(repoPkg, dp, true)
-		}
-	}
-
-	return do
-}
-
-func (do *depOrder) orderPkgAur(pkg *rpc.Pkg, dp *depPool, runtime bool) {
-	if runtime {
-		do.Runtime.set(pkg.Name)
-	}
-	delete(dp.Aur, pkg.Name)
-
-	for i, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} {
-		for _, dep := range deps {
-			aurPkg := dp.findSatisfierAur(dep)
-			if aurPkg != nil {
-				do.orderPkgAur(aurPkg, dp, runtime && i == 0)
-			}
-
-			repoPkg := dp.findSatisfierRepo(dep)
-			if repoPkg != nil {
-				do.orderPkgRepo(repoPkg, dp, runtime && i == 0)
-			}
-		}
-	}
-
-	for i, base := range do.Aur {
-		if base.Pkgbase() == pkg.PackageBase {
-			do.Aur[i] = append(base, pkg)
-			return
-		}
-	}
-
-	do.Aur = append(do.Aur, Base{pkg})
-}
-
-func (do *depOrder) orderPkgRepo(pkg *alpm.Package, dp *depPool, runtime bool) {
-	if runtime {
-		do.Runtime.set(pkg.Name())
-	}
-	delete(dp.Repo, pkg.Name())
-
-	pkg.Depends().ForEach(func(dep alpm.Depend) (err error) {
-		repoPkg := dp.findSatisfierRepo(dep.String())
-		if repoPkg != nil {
-			do.orderPkgRepo(repoPkg, dp, runtime)
-		}
-
-		return nil
-	})
-
-	do.Repo = append(do.Repo, pkg)
-}
-
-func (do *depOrder) HasMake() bool {
-	lenAur := 0
-	for _, base := range do.Aur {
-		lenAur += len(base)
-	}
-
-	return len(do.Runtime) != lenAur+len(do.Repo)
-}
-
-func (do *depOrder) getMake() []string {
-	makeOnly := make([]string, 0, len(do.Aur)+len(do.Repo)-len(do.Runtime))
-
-	for _, base := range do.Aur {
-		for _, pkg := range base {
-			if !do.Runtime.get(pkg.Name) {
-				makeOnly = append(makeOnly, pkg.Name)
-			}
-		}
-	}
-
-	for _, pkg := range do.Repo {
-		if !do.Runtime.get(pkg.Name()) {
-			makeOnly = append(makeOnly, pkg.Name())
-		}
-	}
-
-	return makeOnly
-}

depPool.go

@@ -1,446 +0,0 @@
-package main
-
-import (
-	"sort"
-	"strings"
-	"sync"
-
-	alpm "github.com/jguer/go-alpm"
-	rpc "github.com/mikkeloscar/aur"
-)
-
-type depPool struct {
-	Targets  []target
-	Explicit stringSet
-	Repo     map[string]*alpm.Package
-	Aur      map[string]*rpc.Pkg
-	AurCache map[string]*rpc.Pkg
-	Groups   []string
-	LocalDb  *alpm.Db
-	SyncDb   alpm.DbList
-	Warnings *aurWarnings
-}
-
-func makeDepPool() (*depPool, error) {
-	localDb, err := alpmHandle.LocalDb()
-	if err != nil {
-		return nil, err
-	}
-	syncDb, err := alpmHandle.SyncDbs()
-	if err != nil {
-		return nil, err
-	}
-
-	dp := &depPool{
-		make([]target, 0),
-		make(stringSet),
-		make(map[string]*alpm.Package),
-		make(map[string]*rpc.Pkg),
-		make(map[string]*rpc.Pkg),
-		make([]string, 0),
-		localDb,
-		syncDb,
-		nil,
-	}
-
-	return dp, nil
-}
-
-// Includes db/ prefixes and group installs
-func (dp *depPool) ResolveTargets(pkgs []string) error {
-	// RPC requests are slow
-	// Combine as many AUR package requests as possible into a single RPC
-	// call
-	aurTargets := make(stringSet)
-
-	pkgs = removeInvalidTargets(pkgs)
-
-	for _, pkg := range pkgs {
-		var err error
-		target := toTarget(pkg)
-
-		// skip targets already satisfied
-		// even if the user enters db/pkg and aur/pkg the latter will
-		// still get skipped even if it's from a different database to
-		// the one specified
-		// this is how pacman behaves
-		if dp.hasPackage(target.DepString()) {
-			continue
-		}
-
-		var foundPkg *alpm.Package
-		var singleDb *alpm.Db
-
-		// aur/ prefix means we only check the aur
-		if target.Db == "aur" || mode == ModeAUR {
-			dp.Targets = append(dp.Targets, target)
-			aurTargets.set(target.DepString())
-			continue
-		}
-
-		// If there'ss a different priefix only look in that repo
-		if target.Db != "" {
-			singleDb, err = alpmHandle.SyncDbByName(target.Db)
-			if err != nil {
-				return err
-			}
-			foundPkg, err = singleDb.PkgCache().FindSatisfier(target.DepString())
-			//otherwise find it in any repo
-		} else {
-			foundPkg, err = dp.SyncDb.FindSatisfier(target.DepString())
-		}
-
-		if err == nil {
-			dp.Targets = append(dp.Targets, target)
-			dp.Explicit.set(foundPkg.Name())
-			dp.ResolveRepoDependency(foundPkg)
-			continue
-		} else {
-			//check for groups
-			//currently we don't resolve the packages in a group
-			//only check if the group exists
-			//would be better to check the groups from singleDb if
-			//the user specified a db but there's no easy way to do
-			//it without making alpm_lists so don't bother for now
-			//db/group is probably a rare use case
-			group, err := dp.SyncDb.PkgCachebyGroup(target.Name)
-			if err == nil {
-				dp.Groups = append(dp.Groups, target.String())
-				group.ForEach(func(pkg alpm.Package) error {
-					dp.Explicit.set(pkg.Name())
-					return nil
-				})
-				continue
-			}
-		}
-
-		//if there was no db prefix check the aur
-		if target.Db == "" {
-			aurTargets.set(target.DepString())
-		}
-
-		dp.Targets = append(dp.Targets, target)
-	}
-
-	if len(aurTargets) > 0 && (mode == ModeAny || mode == ModeAUR) {
-		return dp.resolveAURPackages(aurTargets, true)
-	}
-
-	return nil
-}
-
-// Pseudo provides finder.
-// Try to find provides by performing a search of the package name
-// This effectively performs -Ss on each package
-// then runs -Si on each result to cache the information.
-//
-// For example if you were to -S yay then yay -Ss would give:
-// yay-git yay-bin yay realyog pacui pacui-git ruby-yard
-// These packages will all be added to the cache in case they are needed later
-// Ofcouse only the first three packages provide yay, the rest are just false
-// positives.
-//
-// This method increases dependency resolve time
-func (dp *depPool) findProvides(pkgs stringSet) error {
-	var mux sync.Mutex
-	var wg sync.WaitGroup
-
-	doSearch := func(pkg string) {
-		defer wg.Done()
-		var err error
-		var results []rpc.Pkg
-
-		// Hack for a bigger search result, if the user wants
-		// java-envronment we can search for just java instead and get
-		// more hits.
-		words := strings.Split(pkg, "-")
-
-		for i := range words {
-			results, err = rpc.SearchByNameDesc(strings.Join(words[:i+1], "-"))
-			if err == nil {
-				break
-			}
-		}
-
-		if err != nil {
-			return
-		}
-
-		for _, result := range results {
-			mux.Lock()
-			if _, ok := dp.AurCache[result.Name]; !ok {
-				pkgs.set(result.Name)
-			}
-			mux.Unlock()
-		}
-	}
-
-	for pkg := range pkgs {
-		if _, err := dp.LocalDb.PkgByName(pkg); err == nil {
-			continue
-		}
-		wg.Add(1)
-		go doSearch(pkg)
-	}
-
-	wg.Wait()
-
-	return nil
-}
-
-func (dp *depPool) cacheAURPackages(_pkgs stringSet) error {
-	pkgs := _pkgs.copy()
-	query := make([]string, 0)
-
-	for pkg := range pkgs {
-		if _, ok := dp.AurCache[pkg]; ok {
-			pkgs.remove(pkg)
-		}
-	}
-
-	if len(pkgs) == 0 {
-		return nil
-	}
-
-	if config.Provides {
-		err := dp.findProvides(pkgs)
-		if err != nil {
-			return err
-		}
-	}
-
-	for pkg := range pkgs {
-		if _, ok := dp.AurCache[pkg]; !ok {
-			name, _, _ := splitDep(pkg)
-			query = append(query, name)
-		}
-	}
-
-	info, err := aurInfo(query, dp.Warnings)
-	if err != nil {
-		return err
-	}
-
-	for _, pkg := range info {
-		// Dump everything in cache just in case we need it later
-		dp.AurCache[pkg.Name] = pkg
-	}
-
-	return nil
-}
-
-func (dp *depPool) resolveAURPackages(pkgs stringSet, explicit bool) error {
-	newPackages := make(stringSet)
-	newAURPackages := make(stringSet)
-
-	err := dp.cacheAURPackages(pkgs)
-	if err != nil {
-		return err
-	}
-
-	if len(pkgs) == 0 {
-		return nil
-	}
-
-	for name := range pkgs {
-		_, ok := dp.Aur[name]
-		if ok {
-			continue
-		}
-
-		pkg := dp.findSatisfierAurCache(name)
-		if pkg == nil {
-			continue
-		}
-
-		if explicit {
-			dp.Explicit.set(pkg.Name)
-		}
-		dp.Aur[pkg.Name] = pkg
-
-		for _, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} {
-			for _, dep := range deps {
-				newPackages.set(dep)
-			}
-		}
-	}
-
-	for dep := range newPackages {
-		if dp.hasSatisfier(dep) {
-			continue
-		}
-
-		_, isInstalled := dp.LocalDb.PkgCache().FindSatisfier(dep) //has satisfier installed: skip
-		hm := hideMenus
-		hideMenus = isInstalled == nil
-		repoPkg, inRepos := dp.SyncDb.FindSatisfier(dep) //has satisfier in repo: fetch it
-		hideMenus = hm
-		if isInstalled == nil && (config.ReBuild != "tree" || inRepos == nil) {
-			continue
-		}
-
-		if inRepos == nil {
-			dp.ResolveRepoDependency(repoPkg)
-			continue
-		}
-
-		//assume it's in the aur
-		//ditch the versioning because the RPC can't handle it
-		newAURPackages.set(dep)
-
-	}
-
-	err = dp.resolveAURPackages(newAURPackages, false)
-	return err
-}
-
-func (dp *depPool) ResolveRepoDependency(pkg *alpm.Package) {
-	dp.Repo[pkg.Name()] = pkg
-
-	pkg.Depends().ForEach(func(dep alpm.Depend) (err error) {
-		//have satisfier in dep tree: skip
-		if dp.hasSatisfier(dep.String()) {
-			return
-		}
-
-		//has satisfier installed: skip
-		_, isInstalled := dp.LocalDb.PkgCache().FindSatisfier(dep.String())
-		if isInstalled == nil {
-			return
-		}
-
-		//has satisfier in repo: fetch it
-		repoPkg, inRepos := dp.SyncDb.FindSatisfier(dep.String())
-		if inRepos != nil {
-			return
-		}
-
-		dp.ResolveRepoDependency(repoPkg)
-
-		return nil
-	})
-}
-
-func getDepPool(pkgs []string, warnings *aurWarnings) (*depPool, error) {
-	dp, err := makeDepPool()
-	if err != nil {
-		return nil, err
-	}
-
-	dp.Warnings = warnings
-	err = dp.ResolveTargets(pkgs)
-
-	return dp, err
-}
-
-func (dp *depPool) findSatisfierAur(dep string) *rpc.Pkg {
-	for _, pkg := range dp.Aur {
-		if satisfiesAur(dep, pkg) {
-			return pkg
-		}
-	}
-
-	return nil
-}
-
-// This is mostly used to promote packages from the cache
-// to the Install list
-// Provide a pacman style provider menu if there's more than one candidate
-// This acts slightly differently from Pacman, It will give
-// a menu even if a package with a matching name exists. I believe this
-// method is better because most of the time you are choosing between
-// foo and foo-git.
-// Using Pacman's ways trying to install foo would never give you
-// a menu.
-// TODO: maybe intermix repo providers in the menu
-func (dp *depPool) findSatisfierAurCache(dep string) *rpc.Pkg {
-	depName, _, _ := splitDep(dep)
-	seen := make(stringSet)
-	providers := makeProviders(depName)
-
-	if _, err := dp.LocalDb.PkgByName(depName); err == nil {
-		if pkg, ok := dp.AurCache[dep]; ok && pkgSatisfies(pkg.Name, pkg.Version, dep) {
-			return pkg
-		}
-
-	}
-
-	if cmdArgs.op == "Y" || cmdArgs.op == "yay" {
-		for _, pkg := range dp.AurCache {
-			if pkgSatisfies(pkg.Name, pkg.Version, dep) {
-				for _, target := range dp.Targets {
-					if target.Name == pkg.Name {
-						return pkg
-					}
-				}
-			}
-		}
-	}
-
-	for _, pkg := range dp.AurCache {
-		if seen.get(pkg.Name) {
-			continue
-		}
-
-		if pkgSatisfies(pkg.Name, pkg.Version, dep) {
-			providers.Pkgs = append(providers.Pkgs, pkg)
-			seen.set(pkg.Name)
-			continue
-		}
-
-		for _, provide := range pkg.Provides {
-			if provideSatisfies(provide, dep) {
-				providers.Pkgs = append(providers.Pkgs, pkg)
-				seen.set(pkg.Name)
-				continue
-			}
-		}
-	}
-
-	if providers.Len() == 1 {
-		return providers.Pkgs[0]
-	}
-
-	if providers.Len() > 1 {
-		sort.Sort(providers)
-		return providerMenu(dep, providers)
-	}
-
-	return nil
-}
-
-func (dp *depPool) findSatisfierRepo(dep string) *alpm.Package {
-	for _, pkg := range dp.Repo {
-		if satisfiesRepo(dep, pkg) {
-			return pkg
-		}
-	}
-
-	return nil
-}
-
-func (dp *depPool) hasSatisfier(dep string) bool {
-	return dp.findSatisfierRepo(dep) != nil || dp.findSatisfierAur(dep) != nil
-}
-
-func (dp *depPool) hasPackage(name string) bool {
-	for _, pkg := range dp.Repo {
-		if pkg.Name() == name {
-			return true
-		}
-	}
-
-	for _, pkg := range dp.Aur {
-		if pkg.Name == name {
-			return true
-		}
-	}
-
-	for _, pkg := range dp.Groups {
-		if pkg == name {
-			return true
-		}
-	}
-
-	return false
-}

print.go

@@ -189,76 +189,6 @@ func (u upSlice) print() {
 	}
 }
 
-// printDownloadsFromRepo prints repository packages to be downloaded
-func (do *depOrder) Print() {
-	repo := ""
-	repoMake := ""
-	aur := ""
-	aurMake := ""
-
-	repoLen := 0
-	repoMakeLen := 0
-	aurLen := 0
-	aurMakeLen := 0
-
-	for _, pkg := range do.Repo {
-		if do.Runtime.get(pkg.Name()) {
-			repo += "  " + pkg.Name() + "-" + pkg.Version()
-			repoLen++
-		} else {
-			repoMake += "  " + pkg.Name() + "-" + pkg.Version()
-			repoMakeLen++
-		}
-	}
-
-	for _, base := range do.Aur {
-		pkg := base.Pkgbase()
-		pkgStr := "  " + pkg + "-" + base[0].Version
-		pkgStrMake := pkgStr
-
-		push := false
-		pushMake := false
-
-		if len(base) > 1 || pkg != base[0].Name {
-			pkgStr += " ("
-			pkgStrMake += " ("
-
-			for _, split := range base {
-				if do.Runtime.get(split.Name) {
-					pkgStr += split.Name + " "
-					aurLen++
-					push = true
-				} else {
-					pkgStrMake += split.Name + " "
-					aurMakeLen++
-					pushMake = true
-				}
-			}
-
-			pkgStr = pkgStr[:len(pkgStr)-1] + ")"
-			pkgStrMake = pkgStrMake[:len(pkgStrMake)-1] + ")"
-		} else if do.Runtime.get(base[0].Name) {
-			aurLen++
-			push = true
-		} else {
-			aurMakeLen++
-			pushMake = true
-		}
-
-		if push {
-			aur += pkgStr
-		}
-		if pushMake {
-			aurMake += pkgStrMake
-		}
-	}
-
-	printDownloads("Repo", repoLen, repo)
-	printDownloads("Repo Make", repoMakeLen, repoMake)
-	printDownloads("Aur", aurLen, aur)
-	printDownloads("Aur Make", aurMakeLen, aurMake)
-}
-
 func printDownloads(repoName string, length int, packages string) {
 	if length < 1 {
 		return