From 96f499ff44c40692699f55b9a8e718365de7de28 Mon Sep 17 00:00:00 2001 From: morganamilo Date: Thu, 4 Jan 2018 00:59:57 +0000 Subject: [PATCH] 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 | 13 +++-- cmd.go | 109 +++++++++++++++++++++---------------- install.go | 38 +++++++------ parser.go | 156 +++++++++++++++++++++++++++++++++++------------------ query.go | 7 ++- upgrade.go | 15 ++++-- 6 files changed, 212 insertions(+), 126 deletions(-) diff --git a/clean.go b/clean.go index 99f74ac6..d5d211ed 100644 --- a/clean.go +++ b/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 } diff --git a/cmd.go b/cmd.go index 01fd87c6..d152d52d 100644 --- a/cmd.go +++ b/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) -// - 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 handleYogurt(parser *arguments) (err error) { + options := parser.formatArgs() + targets := parser.formatTargets() + + config.SearchMode = NumberMenu + err = numberMenu(targets, options) return } +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 diff --git a/install.go b/install.go index 9843a9e1..d9ed502c 100644 --- a/install.go +++ b/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 diff --git a/parser.go b/parser.go index dd5cab7f..428aab77 100644 --- a/parser.go +++ b/parser.go @@ -7,35 +7,62 @@ import ( "io" ) -type set map[string]struct{} +type stringSet map[string]struct{} -type argParser struct { - op string - options map[string]string - doubles set //tracks args passed twice such as -yy and -dd - targets set +func (set stringSet) getAny() string { + for v := range set { + return v + } + + //maybe should return error instrad + return "" } -func makeArgParser() *argParser { - return &argParser { +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 stringSet //tracks args passed twice such as -yy and -dd + targets stringSet +} + +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 (praser *argParser) delTarget(target string) { - delete(praser.targets, target) +func (parser *arguments) delTarget(targets ...string) { + for _, target := range targets { + delete(parser.targets, target) + } } -func (parser *argParser) existsDouble(option string) bool { - _, ok := parser.doubles[option] - return ok +//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) formatArgs() (args []string) { +func (parser *arguments) formatTargets() (args []string) { + for target := range parser.targets { + args = append(args, target) + } + + return +} + +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 diff --git a/query.go b/query.go index 1bf90aff..07818d48 100644 --- a/query.go +++ b/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 diff --git a/upgrade.go b/upgrade.go index a1f5f9a5..ff60f149 100644 --- a/upgrade.go +++ b/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 {