sharpetronics/yay
1
0
Fork 0
mirror of https://github.com/Jguer/yay.git synced 2025-10-04 00:03:11 -04:00
Code Issues Projects Releases Wiki Activity

Reimplement all previously existing operations

Browse Source 
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.
This commit is contained in:
morganamilo 2018-01-04 00:59:57 +00:00
parent 3084f91ba7
commit 96f499ff44
No known key found for this signature in database
GPG Key ID: 6FE9E7996B0B082E
6 changed files with 212 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
clean.go
View File

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

109
cmd.go
View File

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

38
install.go
View File

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

156
parser.go
View File

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

7
query.go
View File

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

15
upgrade.go
View File

@ -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 {