yay/cmd.go

437 lines
12 KiB
Go
Raw Normal View History

2017-04-29 17:12:12 +00:00
package main
import (
"bufio"
"fmt"
"net/http"
2017-04-29 17:12:12 +00:00
"os"
2018-07-28 02:45:04 +00:00
alpm "github.com/jguer/go-alpm"
2017-04-29 17:12:12 +00:00
)
var cmdArgs = makeArguments()
2017-04-29 17:12:12 +00:00
func usage() {
fmt.Println(`Usage:
yay
yay <operation> [...]
yay <package(s)>
2018-01-14 17:12:51 +00:00
operations:
yay {-h --help}
yay {-V --version}
yay {-D --database} <options> <package(s)>
yay {-F --files} [options] [package(s)]
yay {-Q --query} [options] [package(s)]
yay {-R --remove} [options] <package(s)>
yay {-S --sync} [options] [package(s)]
yay {-T --deptest} [options] [package(s)]
yay {-U --upgrade} [options] <file(s)>
New operations:
yay {-Y --yay} [options] [package(s)]
2018-08-02 21:01:41 +00:00
yay {-P --show} [options]
yay {-G --getpkgbuild} [package(s)]
2018-06-04 18:16:43 +00:00
New options:
--repo Assume targets are from the repositories
-a --aur Assume targets are from the AUR
Permanent configuration options:
--save Causes the following options to be saved back to the
config file when used
2018-03-07 22:37:44 +00:00
2018-08-29 19:37:25 +00:00
--aururl <url> Set an alternative AUR URL
2019-02-03 01:36:46 +00:00
--builddir <dir> Directory used to download and run PKGBUILDS
--editor <file> Editor to use when editing PKGBUILDs
--editorflags <flags> Pass arguments to editor
--makepkg <file> makepkg command to use
--mflags <flags> Pass arguments to makepkg
--pacman <file> pacman command to use
--tar <file> bsdtar command to use
--git <file> git command to use
--gitflags <flags> Pass arguments to git
--gpg <file> gpg command to use
--gpgflags <flags> Pass arguments to gpg
--config <file> pacman.conf file to use
2018-07-28 12:40:07 +00:00
--makepkgconf <file> makepkg.conf file to use
--nomakepkgconf Use the default makepkg.conf
--requestsplitn <n> Max amount of packages to query per AUR request
2018-07-28 12:40:07 +00:00
--completioninterval <n> Time in days to to refresh completion cache
2018-06-04 18:16:43 +00:00
--sortby <field> Sort AUR results by a specific field during search
--answerclean <a> Set a predetermined answer for the clean build menu
2018-06-12 18:27:19 +00:00
--answerdiff <a> Set a predetermined answer for the diff menu
--answeredit <a> Set a predetermined answer for the edit pkgbuild menu
--answerupgrade <a> Set a predetermined answer for the upgrade menu
--noanswerclean Unset the answer for the clean build menu
2018-06-11 18:38:53 +00:00
--noanswerdiff Unset the answer for the edit diff menu
--noansweredit Unset the answer for the edit pkgbuild menu
--noanswerupgrade Unset the answer for the upgrade menu
2018-06-11 18:38:53 +00:00
--cleanmenu Give the option to clean build PKGBUILDS
--diffmenu Give the option to show diffs for build files
--editmenu Give the option to edit/view PKGBUILDS
2018-06-11 19:09:29 +00:00
--upgrademenu Show a detailed list of updates with the option to skip any
2018-06-11 18:38:53 +00:00
--nocleanmenu Don't clean build PKGBUILDS
--nodiffmenu Don't show diffs for build files
--noeditmenu Don't edit/view PKGBUILDS
2018-06-11 19:09:29 +00:00
--noupgrademenu Don't show the upgrade menu
2018-07-28 12:40:07 +00:00
--askremovemake Ask to remove makedepends after install
--removemake Remove makedepends after install
--noremovemake Don't remove makedepends after install
--cleanafter Remove package sources after successful install
--nocleanafter Do not remove package sources after successful build
--bottomup Shows AUR's packages first and then repository's
--topdown Shows repository's packages first and then AUR's
--devel Check development packages during sysupgrade
--nodevel Do not check development packages
--gitclone Use git clone for PKGBUILD retrieval
--nogitclone Never use git clone for PKGBUILD retrieval
--rebuild Always build target packages
--rebuildall Always build all AUR packages
--norebuild Skip package build if in cache and up to date
--rebuildtree Always build all AUR packages even if installed
--redownload Always download pkgbuilds of targets
--noredownload Skip pkgbuild download if in cache and up to date
--redownloadall Always download pkgbuilds of all AUR packages
2019-02-03 01:36:46 +00:00
--provides Look for matching providers when searching for packages
2018-06-04 18:16:43 +00:00
--noprovides Just look for packages by pkgname
--pgpfetch Prompt to import PGP keys from PKGBUILDs
--nopgpfetch Don't prompt to import PGP keys
--useask Automatically resolve conflicts using pacman's ask flag
--nouseask Confirm conflicts manually during the install
--combinedupgrade Refresh then perform the repo and AUR upgrade together
--nocombinedupgrade Perform the repo upgrade and AUR upgrade separately
--sudoloop Loop sudo calls in the background to avoid timeout
--nosudoloop Do not loop sudo calls in the background
2018-04-23 00:42:58 +00:00
--timeupdate Check packages' AUR page for changes during sysupgrade
--notimeupdate Do not check packages' AUR page for changes
show specific options:
-c --complete Used for completions
-d --defaultconfig Print default yay configuration
2018-08-02 21:01:41 +00:00
-g --currentconfig Print current yay configuration
-s --stats Display system package statistics
2018-05-06 01:31:09 +00:00
-w --news Print arch news
yay specific options:
-c --clean Remove unneeded dependencies
--gendb Generates development package DB used for updating
getpkgbuild specific options:
-f --force Force download for existing tar packages
If no arguments are provided 'yay -Syu' will be performed
2018-02-27 03:41:39 +00:00
If no operation is provided -Y will be assumed`)
2017-04-29 17:12:12 +00:00
}
func handleCmd() (err error) {
if cmdArgs.existsArg("h", "help") {
err = handleHelp()
return
}
if config.SudoLoop && cmdArgs.needRoot() {
sudoLoopBackground()
2018-02-13 18:20:15 +00:00
}
switch cmdArgs.op {
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "V", "version":
handleVersion()
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "D", "database":
err = show(passToPacman(cmdArgs))
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "F", "files":
err = show(passToPacman(cmdArgs))
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "Q", "query":
err = handleQuery()
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "R", "remove":
err = handleRemove()
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "S", "sync":
err = handleSync()
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "T", "deptest":
err = show(passToPacman(cmdArgs))
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "U", "upgrade":
err = show(passToPacman(cmdArgs))
case "G", "getpkgbuild":
err = handleGetpkgbuild()
case "P", "show":
err = handlePrint()
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
case "Y", "--yay":
err = handleYay()
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
default:
//this means we allowed an op but not implement it
//if this happens it an error in the code and not the usage
err = fmt.Errorf("unhandled operation")
}
2018-01-14 17:12:51 +00:00
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
return
}
func handleQuery() error {
if cmdArgs.existsArg("u", "upgrades") {
2018-07-31 08:42:17 +00:00
return printUpdateList(cmdArgs)
}
2018-07-31 08:42:17 +00:00
return show(passToPacman(cmdArgs))
}
func handleHelp() error {
if cmdArgs.op == "Y" || cmdArgs.op == "yay" {
usage()
return nil
}
return show(passToPacman(cmdArgs))
}
func handleVersion() {
2018-07-28 02:45:04 +00:00
fmt.Printf("yay v%s - libalpm v%s\n", version, alpm.Version())
}
func handlePrint() (err error) {
switch {
case cmdArgs.existsArg("d", "defaultconfig"):
tmpConfig := defaultSettings()
2018-08-31 20:19:40 +00:00
tmpConfig.expandEnv()
fmt.Printf("%v", tmpConfig)
case cmdArgs.existsArg("g", "currentconfig"):
fmt.Printf("%v", config)
case cmdArgs.existsArg("n", "numberupgrades"):
err = printNumberOfUpdates()
case cmdArgs.existsArg("u", "upgrades"):
err = printUpdateList(cmdArgs)
2018-05-06 00:26:03 +00:00
case cmdArgs.existsArg("w", "news"):
err = printNewsFeed()
case cmdArgs.existsDouble("c", "complete"):
complete(true)
case cmdArgs.existsArg("c", "complete"):
complete(false)
case cmdArgs.existsArg("s", "stats"):
err = localStatistics()
default:
2018-02-13 18:20:15 +00:00
err = nil
}
2018-02-13 18:20:15 +00:00
return err
}
2018-07-31 08:42:17 +00:00
func handleYay() error {
//_, options, targets := cmdArgs.formatArgs()
if cmdArgs.existsArg("gendb") {
2018-07-31 08:42:17 +00:00
return createDevelDB()
}
2018-07-31 08:42:17 +00:00
if cmdArgs.existsDouble("c") {
return cleanDependencies(true)
}
if cmdArgs.existsArg("c", "clean") {
return cleanDependencies(false)
}
if len(cmdArgs.targets) > 0 {
return handleYogurt()
}
return nil
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
}
2018-07-31 08:42:17 +00:00
func handleGetpkgbuild() error {
return getPkgbuilds(cmdArgs.targets)
}
2018-07-31 08:42:17 +00:00
func handleYogurt() error {
config.SearchMode = numberMenu
return displayNumberMenu(cmdArgs.targets)
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
}
func handleSync() error {
targets := cmdArgs.targets
2018-01-14 17:12:51 +00:00
if cmdArgs.existsArg("s", "search") {
if cmdArgs.existsArg("q", "quiet") {
config.SearchMode = minimal
} else {
config.SearchMode = detailed
}
2018-07-31 08:42:17 +00:00
return syncSearch(targets)
}
2018-07-31 08:42:17 +00:00
if cmdArgs.existsArg("p", "print", "print-format") {
return show(passToPacman(cmdArgs))
}
if cmdArgs.existsArg("c", "clean") {
return syncClean(cmdArgs)
}
if cmdArgs.existsArg("l", "list") {
return syncList(cmdArgs)
2018-07-31 08:42:17 +00:00
}
if cmdArgs.existsArg("g", "groups") {
return show(passToPacman(cmdArgs))
}
if cmdArgs.existsArg("i", "info") {
return syncInfo(targets)
}
if cmdArgs.existsArg("u", "sysupgrade") {
return install(cmdArgs)
}
if len(cmdArgs.targets) > 0 {
return install(cmdArgs)
}
if cmdArgs.existsArg("y", "refresh") {
return show(passToPacman(cmdArgs))
}
return nil
2017-04-29 17:12:12 +00:00
}
2018-07-31 08:42:17 +00:00
func handleRemove() error {
removeVCSPackage(cmdArgs.targets)
2018-07-31 08:42:17 +00:00
return show(passToPacman(cmdArgs))
2017-04-29 17:12:12 +00:00
}
// NumberMenu presents a CLI for selecting packages to install.
func displayNumberMenu(pkgS []string) (err error) {
2018-07-31 08:42:17 +00:00
var (
aurErr, repoErr error
aq aurQuery
pq repoQuery
lenaq, lenpq int
)
2018-06-04 19:36:10 +00:00
pkgS = removeInvalidTargets(pkgS)
if mode == modeAUR || mode == modeAny {
2018-06-04 19:36:10 +00:00
aq, aurErr = narrowSearch(pkgS, true)
lenaq = len(aq)
}
if mode == modeRepo || mode == modeAny {
2018-07-31 00:56:41 +00:00
pq, repoErr = queryRepo(pkgS)
lenpq = len(pq)
2018-06-04 19:36:10 +00:00
if repoErr != nil {
return err
}
2017-04-29 17:12:12 +00:00
}
2018-06-04 19:36:10 +00:00
if lenpq == 0 && lenaq == 0 {
return fmt.Errorf("No packages match search")
2017-04-29 17:12:12 +00:00
}
if config.SortMode == bottomUp {
if mode == modeAUR || mode == modeAny {
2018-06-04 19:36:10 +00:00
aq.printSearch(lenpq + 1)
}
if mode == modeRepo || mode == modeAny {
2018-06-04 19:36:10 +00:00
pq.printSearch()
}
2017-04-29 17:12:12 +00:00
} else {
if mode == modeRepo || mode == modeAny {
2018-06-04 19:36:10 +00:00
pq.printSearch()
}
if mode == modeAUR || mode == modeAny {
2018-06-04 19:36:10 +00:00
aq.printSearch(lenpq + 1)
}
2017-04-29 17:12:12 +00:00
}
2018-04-03 05:49:41 +00:00
if aurErr != nil {
fmt.Fprintf(os.Stderr, "Error during AUR search: %s\n", aurErr)
fmt.Fprintln(os.Stderr, "Showing repo packages only")
2018-04-03 05:49:41 +00:00
}
fmt.Println(bold(green(arrow + " Packages to install (eg: 1 2 3, 1-3 or ^4)")))
fmt.Print(bold(green(arrow + " ")))
2018-03-09 05:25:05 +00:00
2017-04-29 17:12:12 +00:00
reader := bufio.NewReader(os.Stdin)
2018-03-09 05:25:05 +00:00
2018-07-31 08:42:17 +00:00
numberBuf, overflow, err := reader.ReadLine()
2018-03-09 05:25:05 +00:00
if err != nil {
return err
2017-04-29 17:12:12 +00:00
}
2018-03-09 05:25:05 +00:00
if overflow {
return fmt.Errorf("Input too long")
}
include, exclude, _, otherExclude := parseNumberMenu(string(numberBuf))
arguments := makeArguments()
isInclude := len(exclude) == 0 && len(otherExclude) == 0
2018-06-04 19:36:10 +00:00
for i, pkg := range pq {
target := len(pq) - i
if config.SortMode == topDown {
2018-03-09 05:25:05 +00:00
target = i + 1
2017-04-29 17:12:12 +00:00
}
2018-07-31 08:42:17 +00:00
if (isInclude && include.get(target)) || (!isInclude && !exclude.get(target)) {
arguments.addTarget(pkg.DB().Name() + "/" + pkg.Name())
2017-04-29 17:12:12 +00:00
}
}
2018-06-04 19:36:10 +00:00
for i, pkg := range aq {
target := len(aq) - i + len(pq)
if config.SortMode == topDown {
2018-06-04 19:36:10 +00:00
target = i + 1 + len(pq)
2018-03-09 05:25:05 +00:00
}
2018-07-31 08:42:17 +00:00
if (isInclude && include.get(target)) || (!isInclude && !exclude.get(target)) {
arguments.addTarget("aur/" + pkg.Name)
}
}
if len(arguments.targets) == 0 {
2018-07-30 13:14:16 +00:00
fmt.Println("There is nothing to do")
return nil
}
if config.SudoLoop {
sudoLoopBackground()
}
2018-03-09 05:25:05 +00:00
New install algorithm I have replaced the old install and dependancy algorithms with a new design that attemps to be more pacaur like. Mostly in minimizing user input. Ask every thing first then do everything with no need for more user input. It is not yet fully complete but is finished enough so that it works, should not fail in most cases and provides a base for more contributors to help address the existing problems. The new install chain is as follows: Source info about the provided targets Fetch a list of all dependancies needed to install targets I put alot of effort into fetching the dependancy tree while making the least amount of aur requests as possible. I'm actually very happy with how it turned out and yay wil now resolve dependancies noticably faster than pacaur when there are many aur dependancies. Install repo targets by passing to pacman Print dependancy tree and ask to confirm Ask to clean build if directory already exists Download all pkgbuilds Ask to edit all pkgbuilds Ask to continue with the install Download the sources for each packagebuild Build and install every package using -s to get repo deps and -i to install Ask to remove make dependancies There are still a lot of things that need to be done for a fully working system. Here are the problems I found with this system, either new or existing: Formating I am not so good at formatting myself, I thought best to leave it until last so I could get feedback on how it should look and help implementing it. Dependancy tree The dependancy tree is usually correct although I have noticed times where it doesnt detect all the dependancies that it should. I have only noticed this when there are circular dependancies so i think this might be the cause. It's not a big deal currently because makepkg -i installed repo deps for us which handles the repo deps for us and will get the correct ones. So yay might not list all the dependancies. but they will get installed so I consider this a visual bug. I have yet to see any circular dependancies in the AUR so I can not say what will happend but I#m guessing that it will break. Versioned packages/dependencies Targets and dependancies with version constriants such as 'linux>=4.1' will not be checked on the aur side of things but will be checked on the repo side. Ignorepkg/Ignoregroup Currently I do not handle this in any way but it shouldn't be too hard to implement. Conflict checking This is not currently implemented either Split Paclages Split packages are not Handles properly. If we only specify one package so install from a split package makepkg -i ends up installing them all anyway. If we specify more than one (n) package it will actually build the package base n times and reinstall every split package n times. Makepkg To get things working I decided to keep using the makepkg -i method. I plan to eventually replace this with a pacman -U based method. This should allow passing args such as --dbpath and --config to aur packages aswell as help solve some problems such as the split packages. Clean build I plan to improve the clean build choice to be a little more smart and instead of check if the directory exists, check if the package is already build and if so skip the build all together.
2018-01-17 21:48:23 +00:00
err = install(arguments)
2017-04-29 17:12:12 +00:00
return err
2017-04-29 17:12:12 +00:00
}
func syncList(parser *arguments) error {
aur := false
for i := len(parser.targets) - 1; i >= 0; i-- {
if parser.targets[i] == "aur" && (mode == modeAny || mode == modeAUR) {
parser.targets = append(parser.targets[:i], parser.targets[i+1:]...)
aur = true
}
}
if (mode == modeAny || mode == modeAUR) && (len(parser.targets) == 0 || aur) {
2019-02-04 16:56:02 +00:00
localDB, err := alpmHandle.LocalDB()
if err != nil {
return err
}
resp, err := http.Get(config.AURURL + "/packages.gz")
if err != nil {
return err
}
defer resp.Body.Close()
scanner := bufio.NewScanner(resp.Body)
scanner.Scan()
for scanner.Scan() {
name := scanner.Text()
if cmdArgs.existsArg("q", "quiet") {
fmt.Println(name)
} else {
fmt.Printf("%s %s %s", magenta("aur"), bold(name), bold(green("unknown-version")))
2019-02-04 16:56:02 +00:00
if _, err := localDB.Pkg(name); err == nil {
fmt.Print(bold(blue(" [Installed]")))
}
fmt.Println()
}
}
}
if (mode == modeAny || mode == modeRepo) && (len(parser.targets) != 0 || !aur) {
return show(passToPacman(parser))
}
return nil
}