Reimplement all previously existing operations

This reimplemens all operations yay previously supported:
	'-S' 'Syu' 'Si' ect.

Currently the argument objects are not fully implemented with the code.
Theres alot of funky conversion from
	argument object -> pkg, flags -> argument object
This is to just get back to the functionally we had before (almost).

I have not looked into it yet but alot of the time pacman flags get
passed to makepkg. this cases an error for most commands now because the
new system Passes all flags:
	`yay -Syu` -> flags = '-S' '-y' '-u'
while the old system would have done:
	`yay -Syu` -> op = '-Suy', flags = ''

So extra flags are no longer passed at all currently.

This means:
	'yay -S aic94xx-firmware --noconfirm -b /tmp/pacutilesu2q6hw/tmp-pacman -d'
will no longer error and 'aic94xx-firmware' will be installed but the
database path change will not apply and the dep checking will not be
skipped.

clean.go

@@ -32,7 +32,7 @@ func removeVCSPackage(pkgs []string) {
 }
 
 // CleanDependencies removes all dangling dependencies in system
-func cleanDependencies(pkgs []string) error {
+func cleanDependencies() error {
 	hanging, err := hangingPackages()
 	if err != nil {
 		return err
@@ -49,12 +49,15 @@ func cleanDependencies(pkgs []string) error {
 }
 
 // CleanRemove sends a full removal command to pacman with the pkgName slice
-func cleanRemove(pkgName []string) (err error) {
-	if len(pkgName) == 0 {
+func cleanRemove(pkgNames []string) (err error) {
+	if len(pkgNames) == 0 {
 		return nil
 	}
+	
+	arguments := makeArguments()
+	arguments.addArg("R", "s", "n", "s", "noconfirm")
+	arguments.addTarget(pkgNames...)
 
-	//TODO
-	//err = passToPacman("-Rsnc", pkgName, []string{"--noconfirm"})
+	err = passToPacman(arguments)
 	return err
 }

cmd.go

@@ -158,7 +158,7 @@ func run() (status int) {
 	var err error
 	var changedConfig bool
 	
-	parser := makeArgParser();
+	parser := makeArguments();
 	err = parser.parseCommandLine();
 	
 	if err != nil {
@@ -209,7 +209,7 @@ func run() (status int) {
 }
 
 
-func handleCmd(parser *argParser) (changedConfig bool, err error) {
+func handleCmd(parser *arguments) (changedConfig bool, err error) {
 	var _changedConfig bool
 	
 	for option, _ := range parser.options {
@@ -234,7 +234,7 @@ func handleCmd(parser *argParser) (changedConfig bool, err error) {
 	case "Q", "query":
 		passToPacman(parser)
 	case "R", "remove":
-		passToPacman(parser)
+		handleRemove(parser)
 	case "S", "sync":
 		err = handleSync(parser)
 	case "T", "deptest":
@@ -313,13 +313,13 @@ func handleConfig(option string) (changedConfig bool, err error) {
 	return
 }
 
-func handleVersion(parser *argParser) {
+func handleVersion(parser *arguments) {
 	fmt.Printf("yay v%s\n", version)
 }
 
-func handleYay(parser *argParser) (err error) {
+func handleYay(parser *arguments) (err error) {
 	//_, options, targets := parser.formatArgs()
-	if parser.existsArg("h") || parser.existsArg("help") {
+	if parser.existsArg("h", "help") {
 		usage()
 	} else if parser.existsArg("printconfig") {
 		fmt.Printf("%#v", config)
@@ -341,9 +341,7 @@ func handleYay(parser *argParser) (err error) {
 	} else if parser.existsArg("stats") {
 		err = localStatistics()
 	} else if parser.existsArg("cleandeps") {
-		//TODO
-		//_,_,targets := parser.formatArgs()
-		//err = cleanDependencies(targets)
+		err = cleanDependencies()
 	} else {
 		err = handleYogurt(parser)
 	}
@@ -351,7 +349,7 @@ func handleYay(parser *argParser) (err error) {
 	return
 }
 
-func handleGetpkgbuild(parser *argParser) (err error) {
+func handleGetpkgbuild(parser *arguments) (err error) {
 	for pkg := range parser.targets {
 			err = getPkgbuild(pkg)
 			if err != nil {
@@ -365,45 +363,59 @@ func handleGetpkgbuild(parser *argParser) (err error) {
 	return
 }
 
-func handleYogurt(parser *argParser) (err error) {
-//	TODO
-//	_, options, targets := parser.formatArgs()
-//	
-//	config.SearchMode = NumberMenu
-//	err = numberMenu(targets, options)
-//	
+func handleYogurt(parser *arguments) (err error) {
+	options := parser.formatArgs()
+	targets := parser.formatTargets()
+	
+	config.SearchMode = NumberMenu
+	err = numberMenu(targets, options)
+	
 	return
 }
 
-func handleSync(parser *argParser) (err error) {
-//TODO
-//	if parser.existsArg("y") || parser.existsArg("refresh") {
-//		err = passToPacman(parser)
-//		if err != nil {
-//			return
-//		}
-//	}
-//	
-//	if parser.existsArg("s") {
-//		if parser.existsArg("i") {
-//			config.SearchMode = Detailed
-//		} else {
-//			config.SortMode = Minimal
-//		}
-//		
-//		err = syncSearch(targets)
-//	}
-//	
-//	if len(targets) > 0 {
-//		err = install(targets, options)
-//	}
+func handleSync(parser *arguments) (err error) {
+	targets := parser.formatTargets()
+	options := parser.formatArgs()
+	
+	if parser.existsArg("y", "refresh") {
+		arguments := makeArguments()
+		arguments.addArg("S", "y")
+		err = passToPacman(arguments)
+		if err != nil {
+			return
+		}
+	}
+	
+	if parser.existsArg("s", "search") {
+		if parser.existsArg("q", "quiet") {
+			config.SearchMode = Minimal
+		} else {
+			config.SearchMode = Detailed
+		}
+		
+		err = syncSearch(targets)
+	} else if parser.existsArg("c", "clean") {
+		err = passToPacman(parser)
+	} else if parser.existsArg("u", "sysupgrade") {
+		err = upgradePkgs(make([]string,0))
+	} else if parser.existsArg("i", "info") {
+		err = syncInfo(targets, options)
+	} else if len(parser.targets) > 0 {
+		err = install(parser)
+	}
 	
 	return
 }
 
+func handleRemove(parser *arguments) (err error){
+	removeVCSPackage(parser.formatTargets())
+	err = passToPacman(parser)
+	return
+}
 
 // NumberMenu presents a CLI for selecting packages to install.
 func numberMenu(pkgS []string, flags []string) (err error) {
+//func numberMenu(parser *arguments) (err error) {
 	var num int
 
 	aq, err := narrowSearch(pkgS, true)
@@ -411,6 +423,7 @@ func numberMenu(pkgS []string, flags []string) (err error) {
 		fmt.Println("Error during AUR search:", err)
 	}
 	numaq := len(aq)
+	
 	pq, numpq, err := queryRepo(pkgS)
 	if err != nil {
 		return
@@ -465,12 +478,14 @@ func numberMenu(pkgS []string, flags []string) (err error) {
 	}
 
 	if len(repoI) != 0 {
-		//TODO
-		//err = passToPacman("-S", repoI, flags)
+		arguments := makeArguments()
+		arguments.addArg("S")
+		arguments.addTarget(repoI...)
+		err = passToPacman(arguments)
 	}
 
 	if len(aurI) != 0 {
-		err = aurInstall(aurI, flags)
+		err = aurInstall(aurI, make([]string,0))
 	}
 
 	return err
@@ -507,7 +522,7 @@ func complete() error {
 }
 
 // PassToPacman outsorces execution to pacman binary without modifications.
-func passToPacman(parser *argParser) error {
+func passToPacman(parser *arguments) error {
 	var cmd *exec.Cmd
 	args := make([]string, 0)
 
@@ -517,9 +532,11 @@ func passToPacman(parser *argParser) error {
 
 	args = append(args, "pacman")
 	args = append(args, parser.formatArgs()...)
+	args = append(args, parser.formatTargets()...)
 
 	cmd = exec.Command(args[0], args[1:]...)
 
+
 	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
 	err := cmd.Run()
 	return err

install.go

@@ -10,19 +10,23 @@ import (
 )
 
 // Install handles package installs
-func install(pkgs []string, flags []string) error {
-	aurs, repos, _ := packageSlices(pkgs)
-
+func install(parser *arguments) error {
+	aurs, repos, _ := packageSlices(parser.targets.toSlice())
+
+	arguments := makeArguments()
+	arguments.op = parser.op
+	arguments.options = arguments.options
+	arguments.addTarget(repos...)
+	
 	if len(repos) != 0 {
-//TODO
-//		err := passToPacman("-S", repos, flags)
-//		if err != nil {
-//			fmt.Println("Error installing repo packages.")
-//		}
+		err := passToPacman(arguments)
+		if err != nil {
+			fmt.Println("Error installing repo packages.")
+		}
 	}
 
 	if len(aurs) != 0 {
-		err := aurInstall(aurs, flags)
+		err := aurInstall(aurs, make([]string,0))
 		if err != nil {
 			fmt.Println("Error installing aur packages.")
 		}
@@ -131,19 +135,19 @@ func PkgInstall(a *rpc.Pkg, flags []string) (finalmdeps []string, err error) {
 		}
 	}
 
-	var depArgs []string
+	arguments := makeArguments()
+	arguments.addArg("S", "asdeps")
+	depArgs := arguments.formatArgs()
+	
 	if config.NoConfirm {
-		depArgs = []string{"--asdeps", "--noconfirm"}
-	} else {
-		depArgs = []string{"--asdeps"}
+		arguments.addArg("noconfirm")
 	}
 	// Repo dependencies
 	if len(repoDeps) != 0 {
-//		TODO
-//		errR := passToPacman("-S", repoDeps, depArgs)
-//		if errR != nil {
-//			return finalmdeps, errR
-//		}
+		errR := passToPacman(arguments)
+		if errR != nil {
+			return finalmdeps, errR
+		}
 	}
 
 	// Handle AUR dependencies

parser.go

@@ -7,35 +7,62 @@ import (
 	"io"
 )
 
-type set  map[string]struct{}
+type stringSet  map[string]struct{}
 
-type argParser struct {
+func (set stringSet) getAny() string {
+	for v := range set {
+		return v
+	}
+    
+	//maybe should return error instrad
+	return ""
+}
+
+func (set stringSet) toSlice() []string {
+	slice := make([]string, 0, len(set))
+	
+	for v := range set {
+		slice = append(slice, v)
+	}
+	
+	return slice
+}
+
+func (set stringSet) removeAny() string {
+	v := set.removeAny()
+	delete(set, v)
+	return v
+}
+
+type arguments struct {
 	op string
 	options map[string]string
-	doubles set //tracks args passed twice such as -yy and -dd
-	targets set
+	doubles stringSet //tracks args passed twice such as -yy and -dd
+	targets stringSet
 }
 
-func makeArgParser() *argParser {
-	return &argParser {
+func makeArguments() *arguments {
+	return &arguments {
 		"",
 		make(map[string]string),
-		make(set),
-		make(set),
+		make(stringSet),
+		make(stringSet),
 	}
 }
 
-func (praser *argParser) delArg(option string) {
-	delete(praser.options, option)
-	delete(praser.doubles, option)
+func (parser *arguments) delArg(options ...string) {
+	for _, option := range options {
+		delete(parser.options, option)
+		delete(parser.doubles, option)
+	}
 }
 
-func (parser *argParser) needRoot() bool {
-	if parser.existsArg("h") || parser.existsArg("help") {
+func (parser *arguments) needRoot() bool {
+	if parser.existsArg("h", "help") {
 		return false
 	}
 	
-	if parser.existsArg("p") || parser.existsArg("print") {
+	if parser.existsArg("p", "print") {
 			return false
 	}
 	
@@ -45,7 +72,7 @@ func (parser *argParser) needRoot() bool {
 	case "D", "database":
 		return true
 	case "F", "files":
-		if parser.existsArg("y") || parser.existsArg("refresh") {
+		if parser.existsArg("y", "refresh") {
 			return true
 		}
 		return false
@@ -54,10 +81,10 @@ func (parser *argParser) needRoot() bool {
 	case "R", "remove":
 		return true
 	case "S", "sync":
-		if parser.existsArg("s") || parser.existsArg("search") {
+		if parser.existsArg("s", "search") {
 			return false
 		}
-		if parser.existsArg("l") || parser.existsArg("list") {
+		if parser.existsArg("l", "list") {
 			return false
 		}
 		return true
@@ -76,61 +103,92 @@ func (parser *argParser) needRoot() bool {
 	}
 }
 
-func (praser *argParser) addOP(op string) (err error) {
-	if praser.op != "" {
+func (parser *arguments) addOP(op string) (err error) {
+	if parser.op != "" {
 		err = fmt.Errorf("only one operation may be used at a time")
 		return
 	}
 	
-	praser.op = op
+	parser.op = op
 	return
 }
 
-func (praser *argParser) addParam(option string, arg string) (err error) {
+func (parser *arguments) addParam(option string, arg string) (err error) {
 	if isOp(option) {
-		err = praser.addOP(option)
+		err = parser.addOP(option)
 		return
 	}
 	
-	if praser.existsArg(option) {
-		praser.doubles[option] = struct{}{}
+	if parser.existsArg(option) {
+		parser.doubles[option] = struct{}{}
 	} else {
-		praser.options[option] = arg
+		parser.options[option] = arg
 	}
 	
 	return
 }
 
-func (praser *argParser) addArg(option string) (err error) {
-	err = praser.addParam(option, "")
+func (parser *arguments) addArg(options ...string) (err error) {
+	for _, option := range options {
+		err = parser.addParam(option, "")
+		if err != nil {
+			return
+		}
+	}
+	
 	return
 }
 
-func (praser *argParser) existsArg(option string) (ok bool) {
-	_, ok = praser.options[option]
-	return ok
+//multiple args acts as an OR operator
+func (parser *arguments) existsArg(options ...string) bool {
+	for _, option := range options {
+		_, exists := parser.options[option]
+		if exists {
+			return true
+		}
+	}
+	return false
 }
 
-func (praser *argParser) getArg(option string) (arg string, double bool, exists bool) {
-	arg, exists = praser.options[option]
-	_, double = praser.doubles[option]
+func (parser *arguments) getArg(option string) (arg string, double bool, exists bool) {
+	arg, exists = parser.options[option]
+	_, double = parser.doubles[option]
 	return
 }
 
-func (praser *argParser) addTarget(target string) {
-	praser.targets[target] = struct{}{}
+func (parser *arguments) addTarget(targets ...string) {
+	for _, target := range targets {
+		parser.targets[target] = struct{}{}
+	}
+}
+
+func (parser *arguments) delTarget(targets ...string) {
+	for _, target := range targets {
+		delete(parser.targets, target)
+	}
 }
 
-func (praser *argParser) delTarget(target string) {
-	delete(praser.targets, target)
+//multiple args acts as an OR operator
+func (parser *arguments) existsDouble(options ...string) bool {
+	for _, option := range options {
+		_, exists := parser.doubles[option]
+		if exists {
+			return true
+		}
+	}
+	
+	return false
 }
 
-func (parser *argParser) existsDouble(option string) bool {
-	_, ok := parser.doubles[option]
-	return ok
+func (parser *arguments) formatTargets() (args []string) {
+	for target := range parser.targets {
+		args = append(args, target)
+	}
+	
+	return
 }
 
-func (parser *argParser) formatArgs() (args []string) {
+func (parser *arguments) formatArgs() (args []string) {
 	op := formatArg(parser.op)
 	args = append(args, op)
 	
@@ -147,10 +205,6 @@ func (parser *argParser) formatArgs() (args []string) {
 		}
 	}
 	
-	for target := range parser.targets {
-		args = append(args, target)
-	}
-	
 	return
 	
 }
@@ -256,7 +310,7 @@ func hasParam(arg string) bool {
 
 //parses short hand options such as:
 //-Syu -b/some/path -
-func (parser *argParser) parseShortOption(arg string, param string) (usedNext bool, err error) {
+func (parser *arguments) parseShortOption(arg string, param string) (usedNext bool, err error) {
 	if arg == "-" {
 		err = parser.addArg("-")
 		return
@@ -290,7 +344,7 @@ func (parser *argParser) parseShortOption(arg string, param string) (usedNext bo
 
 //parses full length options such as:
 //--sync --refresh --sysupgrade --dbpath /some/path --
-func (parser *argParser) parseLongOption(arg string, param string) (usedNext bool, err error){
+func (parser *arguments) parseLongOption(arg string, param string) (usedNext bool, err error){
 	if arg == "--" {
 		err = parser.addArg(arg)
 		return
@@ -308,7 +362,7 @@ func (parser *argParser) parseLongOption(arg string, param string) (usedNext boo
 	return
 }
 
-func (parser *argParser) parseStdin() (err error) {
+func (parser *arguments) parseStdin() (err error) {
 	for true {
 		var target string
 		_, err = fmt.Scan(&target)
@@ -327,7 +381,7 @@ func (parser *argParser) parseStdin() (err error) {
 	return
 }
 
-func (parser *argParser)parseCommandLine() (err error) {
+func (parser *arguments)parseCommandLine() (err error) {
 	args := os.Args[1:]
 	usedNext := false
 	

query.go

@@ -169,8 +169,11 @@ func syncInfo(pkgS []string, flags []string) (err error) {
 	}
 
 	if len(repoS) != 0 {
-		//TODO
-		//err = passToPacman("-Si", repoS, flags)
+		arguments := makeArguments()
+		arguments.addArg("S", "i")
+		//arguments.addArg(flags...)
+		arguments.addTarget(repoS...)
+		err = passToPacman(arguments)
 	}
 
 	return

upgrade.go

@@ -332,11 +332,16 @@ func upgradePkgs(flags []string) error {
 			}
 			repoNames = append(repoNames, k.Name)
 		}
-//		TODO
-//		err := passToPacman("-S", repoNames, append(flags, "--noconfirm"))
-//		if err != nil {
-//		fmt.Println("Error upgrading repo packages.")
-//		}
+		
+		arguments := makeArguments()
+		arguments.addArg("-S --noconfirm")
+		arguments.addArg(flags...)
+		arguments.addTarget(repoNames...)
+		
+		err := passToPacman(arguments)
+		if err != nil {
+			fmt.Println("Error upgrading repo packages.")
+		}
 	}
 
 	if len(aurUp) != 0 {