yay/cmd.go

559 lines
12 KiB
Go
Raw Normal View History

2017-04-29 17:12:12 +00:00
package main
import (
"bufio"
"encoding/json"
2017-04-29 17:12:12 +00:00
"fmt"
"io"
2017-04-29 17:12:12 +00:00
"os"
"os/exec"
"path/filepath"
2017-04-29 17:12:12 +00:00
"strconv"
"strings"
"time"
2017-04-29 17:12:12 +00:00
)
func usage() {
fmt.Println(`Usage:
yay <operation> [...]
yay <package(s)>
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)]
yay {-G --getpkgbuild} [package(s)]
Permanent configuration options:
--topdown Shows repository's packages first and then aur's
--bottomup Shows aur's packages first and then repository's
--devel Check -git/-svn/-hg development version
--nodevel Disable development version checking
--afterclean Clean package sources after successful build
--noafterclean Disable package sources cleaning after successful build
--timeupdate Check package's modification date and version
--notimeupdate Check only package version change
Yay specific options:
--printconfig Prints current yay configuration
--stats Displays system information
--cleandeps Remove unneeded dependencies
--gendb Generates development package DB used for updating.
If no operation is provided -Y will be assumed
`)
2017-04-29 17:12:12 +00:00
}
func init() {
var configHome string // configHome handles config directory home
var cacheHome string // cacheHome handles cache home
var err error
if 0 == os.Geteuid() {
fmt.Println("Please avoid running yay as root/sudo.")
}
if configHome = os.Getenv("XDG_CONFIG_HOME"); configHome != "" {
if info, err := os.Stat(configHome); err == nil && info.IsDir() {
configHome = configHome + "/yay"
} else {
configHome = os.Getenv("HOME") + "/.config/yay"
}
} else {
configHome = os.Getenv("HOME") + "/.config/yay"
}
if cacheHome = os.Getenv("XDG_CACHE_HOME"); cacheHome != "" {
if info, err := os.Stat(cacheHome); err == nil && info.IsDir() {
cacheHome = cacheHome + "/yay"
} else {
cacheHome = os.Getenv("HOME") + "/.cache/yay"
}
} else {
cacheHome = os.Getenv("HOME") + "/.cache/yay"
}
configFile = configHome + "/config.json"
vcsFile = configHome + "/yay_vcs.json"
completionFile = cacheHome + "/aur_"
////////////////
// yay config //
////////////////
defaultSettings(&config)
if _, err = os.Stat(configFile); os.IsNotExist(err) {
err = os.MkdirAll(filepath.Dir(configFile), 0755)
if err != nil {
fmt.Println("Unable to create config directory:", filepath.Dir(configFile), err)
os.Exit(2)
}
// Save the default config if nothing is found
config.saveConfig()
} else {
2017-12-04 06:24:20 +00:00
cfile, errf := os.OpenFile(configFile, os.O_RDWR|os.O_CREATE, 0644)
if errf != nil {
fmt.Println("Error reading config:", err)
} else {
2017-10-19 05:59:26 +00:00
defer cfile.Close()
decoder := json.NewDecoder(cfile)
err = decoder.Decode(&config)
if err != nil {
fmt.Println("Loading default Settings.\nError reading config:", err)
defaultSettings(&config)
}
}
}
/////////////////
// vcs config //
////////////////
updated = false
2017-10-19 05:59:26 +00:00
vfile, err := os.Open(vcsFile)
if err == nil {
2017-10-19 05:59:26 +00:00
defer vfile.Close()
decoder := json.NewDecoder(vfile)
_ = decoder.Decode(&savedInfo)
}
/////////////////
// alpm config //
/////////////////
alpmConf, err = readAlpmConfig(config.PacmanConf)
if err != nil {
fmt.Println("Unable to read Pacman conf", err)
os.Exit(1)
}
alpmHandle, err = alpmConf.CreateHandle()
if err != nil {
fmt.Println("Unable to CreateHandle", err)
os.Exit(1)
}
}
2017-04-29 17:12:12 +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
func main() {
status := run()
err := alpmHandle.Release()
if err != nil {
fmt.Println(err)
status = 1
}
os.Exit(status)
}
func run() (status int) {
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
var err error
var changedConfig bool
parser := makeArguments();
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
err = parser.parseCommandLine();
if err != nil {
fmt.Println(err)
status = 1
return
2017-04-29 17:12:12 +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
if parser.existsArg("-") {
err = parser.parseStdin();
2017-04-29 17:12:12 +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
if err != nil {
fmt.Println(err)
status = 1
return
2017-10-25 08:16:35 +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
}
changedConfig, err = handleCmd(parser)
if err != nil {
fmt.Println(err)
status = 1
//try continue onward
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
}
if updated {
err = saveVCSInfo()
if err != nil {
fmt.Println(err)
status = 1
2017-04-29 17:12:12 +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
}
2017-04-29 17:12:12 +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
if changedConfig {
err = config.saveConfig()
if err != nil {
fmt.Println(err)
status = 1
2017-04-29 17:12:12 +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
2017-04-29 17:12:12 +00:00
}
return
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
}
2017-04-29 17:12:12 +00:00
func handleCmd(parser *arguments) (changedConfig bool, err error) {
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
var _changedConfig bool
for option, _ := range parser.options {
_changedConfig, err = handleConfig(option)
if err != nil {
return
2017-04-29 17:12:12 +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
if _changedConfig {
changedConfig = true
2017-04-29 17:12:12 +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
}
2017-04-29 17:12:12 +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
switch parser.op {
case "V", "version":
handleVersion(parser)
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":
passToPacman(parser)
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":
passToPacman(parser)
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":
passToPacman(parser)
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":
handleRemove(parser)
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(parser)
case "T", "deptest":
passToPacman(parser)
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":
passToPacman(parser)
case "G", "getpkgbuild":
err = handleGetpkgbuild(parser)
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(parser)
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")
2017-07-24 09:32:11 +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
}
//this function should only set config options
//but currently still uses the switch left over from old code
//eventuall this should be refactored out futher
//my current plan is to have yay specific operations in its own operator
//e.g. yay -Y --gendb
//e.g yay -Yg
func handleConfig(option string) (changedConfig bool, err error) {
switch option {
case "afterclean":
config.CleanAfter = true
case "noafterclean":
config.CleanAfter = false
// case "printconfig":
// fmt.Printf("%#v", config)
// os.Exit(0)
// case "gendb":
// err = createDevelDB()
// if err != nil {
// fmt.Println(err)
// }
// err = saveVCSInfo()
// if err != nil {
// fmt.Println(err)
// }
// os.Exit(0)
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 "devel":
config.Devel = true
case "nodevel":
config.Devel = false
case "timeupdate":
config.TimeUpdate = true
case "notimeupdate":
config.TimeUpdate = false
case "topdown":
config.SortMode = TopDown
// case "complete":
// config.Shell = "sh"
// complete()
// os.Exit(0)
// case "fcomplete":
// config.Shell = fishShell
// complete()
// os.Exit(0)
// case "help":
// usage()
// os.Exit(0)
// case "version":
// fmt.Printf("yay v%s\n", version)
// os.Exit(0)
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 "noconfirm":
config.NoConfirm = true
default:
return
2017-07-19 09:32:32 +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
changedConfig = true
return
}
2017-04-29 17:12:12 +00:00
func handleVersion(parser *arguments) {
fmt.Printf("yay v%s\n", version)
}
func handleYay(parser *arguments) (err error) {
//_, options, targets := parser.formatArgs()
if parser.existsArg("h", "help") {
usage()
} else if parser.existsArg("printconfig") {
fmt.Printf("%#v", config)
} else if parser.existsArg("gendb") {
err = createDevelDB()
if err != nil {
return
}
err = saveVCSInfo()
if err != nil {
return
}
} else if parser.existsArg("complete") {
config.Shell = "sh"
complete()
} else if parser.existsArg("fcomplete") {
config.Shell = "fish"
complete()
} else if parser.existsArg("stats") {
err = localStatistics()
} else if parser.existsArg("cleandeps") {
err = cleanDependencies()
} else {
err = handleYogurt(parser)
}
return
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 handleGetpkgbuild(parser *arguments) (err error) {
for pkg := range parser.targets {
err = getPkgbuild(pkg)
if err != nil {
//we print the error instead of returning it
//seems as we can handle multiple errors without stoping
//theres no easy way arround this right now
fmt.Println(pkg + ":", err)
}
}
return
}
func handleYogurt(parser *arguments) (err error) {
options := parser.formatArgs()
targets := parser.formatTargets()
config.SearchMode = NumberMenu
err = numberMenu(targets, options)
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 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)
}
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
2017-04-29 17:12:12 +00:00
}
func handleRemove(parser *arguments) (err error){
removeVCSPackage(parser.formatTargets())
err = passToPacman(parser)
return
}
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
2017-04-29 17:12:12 +00:00
// NumberMenu presents a CLI for selecting packages to install.
func numberMenu(pkgS []string, flags []string) (err error) {
//func numberMenu(parser *arguments) (err error) {
2017-04-29 17:12:12 +00:00
var num int
aq, err := narrowSearch(pkgS, true)
2017-04-29 17:12:12 +00:00
if err != nil {
fmt.Println("Error during AUR search:", err)
}
numaq := len(aq)
2017-08-04 09:26:53 +00:00
pq, numpq, err := queryRepo(pkgS)
2017-04-29 17:12:12 +00:00
if err != nil {
return
}
if numpq == 0 && numaq == 0 {
return fmt.Errorf("no packages match search")
}
if config.SortMode == BottomUp {
aq.printSearch(numpq)
2017-08-04 09:26:53 +00:00
pq.printSearch()
2017-04-29 17:12:12 +00:00
} else {
pq.printSearch()
aq.printSearch(numpq)
2017-04-29 17:12:12 +00:00
}
2017-05-21 13:49:29 +00:00
fmt.Printf("\x1b[32m%s\x1b[0m\nNumbers: ", "Type numbers to install. Separate each number with a space.")
2017-04-29 17:12:12 +00:00
reader := bufio.NewReader(os.Stdin)
numberBuf, overflow, err := reader.ReadLine()
if err != nil || overflow {
fmt.Println(err)
return
}
numberString := string(numberBuf)
2017-08-04 09:26:53 +00:00
var aurI []string
var repoI []string
2017-04-29 17:12:12 +00:00
result := strings.Fields(numberString)
for _, numS := range result {
num, err = strconv.Atoi(numS)
if err != nil {
continue
}
// Install package
if num > numaq+numpq-1 || num < 0 {
continue
} else if num > numpq-1 {
if config.SortMode == BottomUp {
2017-08-04 09:26:53 +00:00
aurI = append(aurI, aq[numaq+numpq-num-1].Name)
2017-04-29 17:12:12 +00:00
} else {
2017-08-04 09:26:53 +00:00
aurI = append(aurI, aq[num-numpq].Name)
2017-04-29 17:12:12 +00:00
}
} else {
if config.SortMode == BottomUp {
2017-08-04 09:26:53 +00:00
repoI = append(repoI, pq[numpq-num-1].Name())
2017-04-29 17:12:12 +00:00
} else {
2017-08-04 09:26:53 +00:00
repoI = append(repoI, pq[num].Name())
2017-04-29 17:12:12 +00:00
}
}
}
2017-08-04 09:26:53 +00:00
if len(repoI) != 0 {
arguments := makeArguments()
arguments.addArg("S")
arguments.addTarget(repoI...)
err = passToPacman(arguments)
2017-04-29 17:12:12 +00:00
}
2017-08-04 09:26:53 +00:00
if len(aurI) != 0 {
err = aurInstall(aurI, make([]string,0))
2017-04-29 17:12:12 +00:00
}
return err
2017-04-29 17:12:12 +00:00
}
// Complete provides completion info for shells
2017-12-04 06:24:20 +00:00
func complete() error {
path := completionFile + config.Shell + ".cache"
if info, err := os.Stat(path); os.IsNotExist(err) || time.Since(info.ModTime()).Hours() > 48 {
os.MkdirAll(filepath.Dir(completionFile), 0755)
2017-12-04 06:24:20 +00:00
out, errf := os.Create(path)
if errf != nil {
return errf
}
if createAURList(out) != nil {
defer os.Remove(path)
}
2017-12-04 06:24:20 +00:00
erra := createRepoList(out)
out.Close()
2017-12-04 06:24:20 +00:00
return erra
}
in, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
return err
}
defer in.Close()
_, err = io.Copy(os.Stdout, in)
return err
}
// passToPacman outsorces execution to pacman binary without modifications.
func passToPacman(parser *arguments) error {
var cmd *exec.Cmd
args := make([]string, 0)
if parser.needRoot() {
args = append(args, "sudo")
}
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
}
// passToMakepkg outsorces execution to makepkg binary without modifications.
func passToMakepkg(dir string, args ...string) (err error) {
cmd := exec.Command(config.MakepkgBin, args...)
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
cmd.Dir = dir
err = cmd.Run()
if err == nil {
_ = saveVCSInfo()
if config.CleanAfter {
fmt.Println("\x1b[1;32m==> CleanAfter enabled. Deleting source folder.\x1b[0m")
os.RemoveAll(dir)
}
}
return
}