yay/cmd.go

460 lines
14 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
2019-04-23 15:53:20 +00:00
alpm "github.com/Jguer/go-alpm"
"github.com/leonelquinteros/gotext"
"github.com/Jguer/yay/v10/pkg/completion"
"github.com/Jguer/yay/v10/pkg/intrange"
"github.com/Jguer/yay/v10/pkg/news"
"github.com/Jguer/yay/v10/pkg/settings"
"github.com/Jguer/yay/v10/pkg/text"
2017-04-29 17:12:12 +00:00
)
2020-07-05 00:45:23 +00:00
var cmdArgs = settings.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)]
If no arguments are provided 'yay -Syu' will be performed
2020-01-30 13:03:10 +00:00
If no operation is provided -Y will be assumed
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
2019-10-21 14:02:38 +00:00
--absdir <dir> Directory used to store downloads from the ABS
--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
--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
2020-03-05 14:30:43 +00:00
--completioninterval <n> Time in days to refresh completion cache
2018-06-04 18:16:43 +00:00
--sortby <field> Sort AUR results by a specific field during search
2019-10-21 14:02:38 +00:00
--searchby <field> Search for packages using a specified field
--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
--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
2019-10-21 14:02:38 +00:00
--batchinstall Build multiple AUR packages then install them together
--nobatchinstall Build and install each AUR package one by one
2019-03-19 21:10:58 +00:00
--sudo <file> sudo command to use
--sudoflags <flags> Pass arguments to sudo
--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:
2020-01-30 13:03:10 +00:00
-f --force Force download for existing ABS packages`)
2017-04-29 17:12:12 +00:00
}
func handleCmd() error {
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("h", "help") {
return handleHelp()
}
if config.SudoLoop && cmdArgs.NeedRoot(config.Runtime) {
sudoLoopBackground()
2018-02-13 18:20:15 +00:00
}
2020-07-05 00:45:23 +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()
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
case "D", "database":
return 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":
return 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":
return 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":
return 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":
return 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":
return 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":
return show(passToPacman(cmdArgs))
case "G", "getpkgbuild":
return handleGetpkgbuild()
case "P", "show":
return 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":
return handleYay()
}
2018-01-14 17:12:51 +00:00
return fmt.Errorf(gotext.Get("unhandled operation"))
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 handleQuery() error {
2020-07-05 00:45:23 +00:00
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 {
2020-07-05 00:45:23 +00:00
if cmdArgs.Op == "Y" || cmdArgs.Op == "yay" {
usage()
return nil
}
return show(passToPacman(cmdArgs))
}
func handleVersion() {
fmt.Printf("yay v%s - libalpm v%s\n", yayVersion, alpm.Version())
}
func handlePrint() (err error) {
switch {
2020-07-05 00:45:23 +00:00
case cmdArgs.ExistsArg("d", "defaultconfig"):
tmpConfig := defaultSettings()
tmpConfig.ExpandEnv()
fmt.Printf("%v", tmpConfig)
2020-07-05 00:45:23 +00:00
case cmdArgs.ExistsArg("g", "currentconfig"):
fmt.Printf("%v", config)
2020-07-05 00:45:23 +00:00
case cmdArgs.ExistsArg("n", "numberupgrades"):
err = printNumberOfUpdates()
2020-07-05 00:45:23 +00:00
case cmdArgs.ExistsArg("u", "upgrades"):
err = printUpdateList(cmdArgs)
2020-07-05 00:45:23 +00:00
case cmdArgs.ExistsArg("w", "news"):
double := cmdArgs.ExistsDouble("w", "news")
quiet := cmdArgs.ExistsArg("q", "quiet")
err = news.PrintNewsFeed(alpmHandle, config.SortMode, double, quiet)
2020-07-05 00:45:23 +00:00
case cmdArgs.ExistsDouble("c", "complete"):
err = completion.Show(alpmHandle, config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, true)
2020-07-05 00:45:23 +00:00
case cmdArgs.ExistsArg("c", "complete"):
err = completion.Show(alpmHandle, config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false)
2020-07-05 00:45:23 +00:00
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 {
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("gendb") {
2020-07-05 01:26:00 +00:00
return createDevelDB(config.Runtime.VCSPath)
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsDouble("c") {
2018-07-31 08:42:17 +00:00
return cleanDependencies(true)
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("c", "clean") {
2018-07-31 08:42:17 +00:00
return cleanDependencies(false)
}
2020-07-05 00:45:23 +00:00
if len(cmdArgs.Targets) > 0 {
2018-07-31 08:42:17 +00:00
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 {
2020-07-05 00:45:23 +00:00
return getPkgbuilds(cmdArgs.Targets)
}
2018-07-31 08:42:17 +00:00
func handleYogurt() error {
config.SearchMode = numberMenu
2020-07-05 00:45:23 +00:00
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 {
2020-07-05 00:45:23 +00:00
targets := cmdArgs.Targets
2018-01-14 17:12:51 +00:00
2020-07-05 00:45:23 +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)
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("p", "print", "print-format") {
2018-07-31 08:42:17 +00:00
return show(passToPacman(cmdArgs))
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("c", "clean") {
2018-07-31 08:42:17 +00:00
return syncClean(cmdArgs)
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("l", "list") {
return syncList(cmdArgs)
2018-07-31 08:42:17 +00:00
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("g", "groups") {
2018-07-31 08:42:17 +00:00
return show(passToPacman(cmdArgs))
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("i", "info") {
2018-07-31 08:42:17 +00:00
return syncInfo(targets)
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("u", "sysupgrade") {
2018-07-31 08:42:17 +00:00
return install(cmdArgs)
}
2020-07-05 00:45:23 +00:00
if len(cmdArgs.Targets) > 0 {
2018-07-31 08:42:17 +00:00
return install(cmdArgs)
}
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("y", "refresh") {
2018-07-31 08:42:17 +00:00
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 {
err := show(passToPacman(cmdArgs))
if err == nil {
2020-07-05 00:45:23 +00:00
removeVCSPackage(cmdArgs.Targets)
}
return err
2017-04-29 17:12:12 +00:00
}
// NumberMenu presents a CLI for selecting packages to install.
func displayNumberMenu(pkgS []string) 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)
2020-07-05 00:45:23 +00:00
if config.Runtime.Mode == settings.ModeAUR || config.Runtime.Mode == settings.ModeAny {
2018-06-04 19:36:10 +00:00
aq, aurErr = narrowSearch(pkgS, true)
lenaq = len(aq)
}
2020-07-05 00:45:23 +00:00
if config.Runtime.Mode == settings.ModeRepo || config.Runtime.Mode == settings.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 repoErr
2018-06-04 19:36:10 +00:00
}
2017-04-29 17:12:12 +00:00
}
2018-06-04 19:36:10 +00:00
if lenpq == 0 && lenaq == 0 {
return fmt.Errorf(gotext.Get("no packages match search"))
2017-04-29 17:12:12 +00:00
}
switch config.SortMode {
case settings.TopDown:
2020-07-05 00:45:23 +00:00
if config.Runtime.Mode == settings.ModeRepo || config.Runtime.Mode == settings.ModeAny {
2018-06-04 19:36:10 +00:00
pq.printSearch()
}
2020-07-05 00:45:23 +00:00
if config.Runtime.Mode == settings.ModeAUR || config.Runtime.Mode == settings.ModeAny {
aq.printSearch(lenpq + 1)
2018-06-04 19:36:10 +00:00
}
case settings.BottomUp:
2020-07-05 00:45:23 +00:00
if config.Runtime.Mode == settings.ModeAUR || config.Runtime.Mode == settings.ModeAny {
2018-06-04 19:36:10 +00:00
aq.printSearch(lenpq + 1)
}
2020-07-05 00:45:23 +00:00
if config.Runtime.Mode == settings.ModeRepo || config.Runtime.Mode == settings.ModeAny {
pq.printSearch()
}
default:
return fmt.Errorf(gotext.Get("invalid sort mode. Fix with yay -Y --bottomup --save"))
2017-04-29 17:12:12 +00:00
}
2018-04-03 05:49:41 +00:00
if aurErr != nil {
text.Errorln(gotext.Get("Error during AUR search: %s\n", aurErr))
text.Warnln(gotext.Get("Showing repo packages only"))
2018-04-03 05:49:41 +00:00
}
text.Infoln(gotext.Get("Packages to install (eg: 1 2 3, 1-3 or ^4)"))
text.Info()
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(gotext.Get("input too long"))
2018-03-09 05:25:05 +00:00
}
include, exclude, _, otherExclude := intrange.ParseNumberMenu(string(numberBuf))
2020-07-05 00:45:23 +00:00
arguments := cmdArgs.CopyGlobal()
2018-03-09 05:25:05 +00:00
isInclude := len(exclude) == 0 && len(otherExclude) == 0
2018-06-04 19:36:10 +00:00
for i, pkg := range pq {
var target int
switch config.SortMode {
case settings.TopDown:
2018-03-09 05:25:05 +00:00
target = i + 1
case settings.BottomUp:
target = len(pq) - i
default:
return fmt.Errorf(gotext.Get("invalid sort mode. Fix with yay -Y --bottomup --save"))
2017-04-29 17:12:12 +00:00
}
if (isInclude && include.Get(target)) || (!isInclude && !exclude.Get(target)) {
2020-07-05 00:45:23 +00:00
arguments.AddTarget(pkg.DB().Name() + "/" + pkg.Name())
2017-04-29 17:12:12 +00:00
}
}
for i := range aq {
var target int
switch config.SortMode {
case settings.TopDown:
2018-06-04 19:36:10 +00:00
target = i + 1 + len(pq)
case settings.BottomUp:
target = len(aq) - i + len(pq)
default:
return fmt.Errorf(gotext.Get("invalid sort mode. Fix with yay -Y --bottomup --save"))
2018-03-09 05:25:05 +00:00
}
if (isInclude && include.Get(target)) || (!isInclude && !exclude.Get(target)) {
2020-07-05 00:45:23 +00:00
arguments.AddTarget("aur/" + aq[i].Name)
}
}
2020-07-05 00:45:23 +00:00
if len(arguments.Targets) == 0 {
2020-05-08 16:13:51 +00:00
fmt.Println(gotext.Get(" there is nothing to do"))
2018-07-30 13:14:16 +00:00
return nil
}
if config.SudoLoop {
sudoLoopBackground()
}
2018-03-09 05:25:05 +00:00
return install(arguments)
2017-04-29 17:12:12 +00:00
}
2020-07-05 00:45:23 +00:00
func syncList(parser *settings.Arguments) error {
aur := false
2020-07-05 00:45:23 +00:00
for i := len(parser.Targets) - 1; i >= 0; i-- {
if parser.Targets[i] == "aur" && (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeAUR) {
parser.Targets = append(parser.Targets[:i], parser.Targets[i+1:]...)
aur = true
}
}
2020-07-05 00:45:23 +00:00
if (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.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()
2020-07-05 00:45:23 +00:00
if cmdArgs.ExistsArg("q", "quiet") {
fmt.Println(name)
} else {
fmt.Printf("%s %s %s", magenta("aur"), bold(name), bold(green(gotext.Get("unknown-version"))))
2019-02-14 20:44:39 +00:00
if localDB.Pkg(name) != nil {
fmt.Print(bold(blue(gotext.Get(" [Installed]"))))
}
fmt.Println()
}
}
}
2020-07-05 00:45:23 +00:00
if (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeRepo) && (len(parser.Targets) != 0 || !aur) {
return show(passToPacman(parser))
}
return nil
}