yay/parser.go

915 lines
17 KiB
Go
Raw Normal View History

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
package main
import (
"bufio"
"bytes"
2018-05-10 19:08:16 +00:00
"html"
2018-01-19 14:51:18 +00:00
"os"
"strconv"
2018-01-19 14:51:18 +00:00
"strings"
"github.com/leonelquinteros/gotext"
rpc "github.com/mikkeloscar/aur"
"github.com/pkg/errors"
"github.com/Jguer/yay/v9/pkg/stringset"
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
)
// Parses command line arguments in a way we can interact with programmatically but
// also in a way that can easily be passed to pacman later on.
type arguments struct {
2018-01-19 14:51:18 +00:00
op string
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
options map[string]string
globals map[string]string
doubles stringset.StringSet // Tracks args passed twice such as -yy and -dd
targets []string
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 makeArguments() *arguments {
2018-01-19 14:51:18 +00:00
return &arguments{
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
"",
make(map[string]string),
make(map[string]string),
make(stringset.StringSet),
make([]string, 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
}
}
func (parser *arguments) copyGlobal() (cp *arguments) {
cp = makeArguments()
for k, v := range parser.globals {
cp.globals[k] = v
}
return
}
func (parser *arguments) copy() (cp *arguments) {
cp = makeArguments()
2018-01-19 14:51:18 +00:00
cp.op = parser.op
2018-01-19 14:51:18 +00:00
for k, v := range parser.options {
cp.options[k] = v
}
2018-01-19 14:51:18 +00:00
for k, v := range parser.globals {
cp.globals[k] = v
}
2018-01-19 14:51:18 +00:00
cp.targets = make([]string, len(parser.targets))
copy(cp.targets, parser.targets)
2018-01-19 14:51:18 +00:00
for k, v := range parser.doubles {
cp.doubles[k] = v
}
2018-01-19 14:51:18 +00:00
return
}
func (parser *arguments) delArg(options ...string) {
for _, option := range options {
delete(parser.options, option)
delete(parser.globals, option)
delete(parser.doubles, option)
}
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 (parser *arguments) needRoot() bool {
if parser.existsArg("h", "help") {
return false
}
2018-01-19 14:51:18 +00:00
switch parser.op {
case "D", "database":
if parser.existsArg("k", "check") {
return false
}
return true
case "F", "files":
if parser.existsArg("y", "refresh") {
return true
}
return false
case "Q", "query":
2018-07-02 12:15:57 +00:00
if parser.existsArg("k", "check") {
return true
}
return false
case "R", "remove":
2019-05-18 04:26:22 +00:00
if parser.existsArg("p", "print", "print-format") {
return false
}
return true
case "S", "sync":
if parser.existsArg("y", "refresh") {
return true
}
if parser.existsArg("p", "print", "print-format") {
return false
}
if parser.existsArg("s", "search") {
return false
}
if parser.existsArg("l", "list") {
return false
}
if parser.existsArg("g", "groups") {
return false
}
if parser.existsArg("i", "info") {
return false
}
if parser.existsArg("c", "clean") && mode == modeAUR {
2018-07-24 01:49:45 +00:00
return false
}
return true
case "U", "upgrade":
return true
default:
return false
}
}
func (parser *arguments) addOP(op string) (err error) {
if parser.op != "" {
err = errors.New(gotext.Get("only one operation may be used at a time"))
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
}
2018-01-19 14:51:18 +00:00
parser.op = 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
return
}
func (parser *arguments) addParam(option, arg string) (err error) {
if !isArg(option) {
return errors.New(gotext.Get("invalid option '%s'", option))
}
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 isOp(option) {
err = parser.addOP(option)
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
}
2018-01-19 14:51:18 +00:00
switch {
case parser.existsArg(option):
parser.doubles[option] = struct{}{}
case isGlobal(option):
parser.globals[option] = arg
default:
parser.options[option] = arg
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-01-19 14:51:18 +00:00
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
return
}
func (parser *arguments) addArg(options ...string) (err error) {
for _, option := range options {
err = parser.addParam(option, "")
if err != nil {
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
return
}
// Multiple args acts as an OR operator
func (parser *arguments) existsArg(options ...string) bool {
for _, option := range options {
_, exists := parser.options[option]
if exists {
return true
}
2018-01-19 14:51:18 +00:00
_, exists = parser.globals[option]
if exists {
return true
}
}
return false
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 (parser *arguments) getArg(options ...string) (arg string, double, exists bool) {
existCount := 0
for _, option := range options {
2018-04-27 01:43:10 +00:00
var value string
value, exists = parser.options[option]
if exists {
2018-04-27 01:43:10 +00:00
arg = value
existCount++
_, exists = parser.doubles[option]
if exists {
existCount++
}
}
2018-04-27 01:43:10 +00:00
value, exists = parser.globals[option]
2018-01-19 14:51:18 +00:00
if exists {
2018-04-27 01:43:10 +00:00
arg = value
existCount++
_, exists = parser.doubles[option]
if exists {
existCount++
}
}
}
2018-01-19 14:51:18 +00:00
double = existCount >= 2
exists = existCount >= 1
return arg, double, exists
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 (parser *arguments) addTarget(targets ...string) {
parser.targets = append(parser.targets, targets...)
}
func (parser *arguments) clearTargets() {
parser.targets = make([]string, 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
}
// Multiple args acts as an OR operator
func (parser *arguments) existsDouble(options ...string) bool {
for _, option := range options {
_, exists := parser.doubles[option]
if exists {
return true
}
}
2018-01-19 14:51:18 +00:00
return false
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 (parser *arguments) formatArgs() (args []string) {
var op string
if parser.op != "" {
op = formatArg(parser.op)
}
args = append(args, op)
2018-01-19 14:51:18 +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
for option, arg := range parser.options {
2018-02-20 17:03:50 +00:00
if option == "--" {
continue
}
2018-05-12 16:16:48 +00:00
formattedOption := formatArg(option)
args = append(args, formattedOption)
2018-01-19 14:51:18 +00:00
if hasParam(option) {
args = append(args, arg)
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-01-19 14:51:18 +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.existsDouble(option) {
2018-05-12 16:16:48 +00:00
args = append(args, formattedOption)
}
}
2018-01-19 14:51:18 +00:00
return
}
func (parser *arguments) formatGlobals() (args []string) {
for option, arg := range parser.globals {
2018-05-12 16:16:48 +00:00
formattedOption := formatArg(option)
args = append(args, formattedOption)
2018-01-19 14:51:18 +00:00
if hasParam(option) {
args = append(args, arg)
}
2018-01-19 14:51:18 +00:00
if parser.existsDouble(option) {
2018-05-12 16:16:48 +00:00
args = append(args, formattedOption)
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-01-19 14:51:18 +00:00
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
return
}
func formatArg(arg string) string {
if len(arg) > 1 {
arg = "--" + arg
} else {
arg = "-" + arg
}
2018-01-19 14:51:18 +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 arg
}
func isArg(arg string) bool {
switch arg {
2018-08-02 15:51:33 +00:00
case "-", "--":
case "ask":
case "D", "database":
case "Q", "query":
case "R", "remove":
case "S", "sync":
case "T", "deptest":
case "U", "upgrade":
case "F", "files":
case "V", "version":
case "h", "help":
case "Y", "yay":
case "P", "show":
case "G", "getpkgbuild":
case "b", "dbpath":
case "r", "root":
case "v", "verbose":
case "arch":
case "cachedir":
case "color":
case "config":
case "debug":
case "gpgdir":
case "hookdir":
case "logfile":
case "noconfirm":
case "confirm":
case "disable-download-timeout":
case "sysroot":
case "d", "nodeps":
2018-09-23 21:08:45 +00:00
case "assume-installed":
case "dbonly":
case "absdir":
case "noprogressbar":
case "noscriptlet":
case "p", "print":
case "print-format":
case "asdeps":
case "asexplicit":
case "ignore":
case "ignoregroup":
case "needed":
case "overwrite":
case "f", "force":
case "c", "changelog":
case "deps":
case "e", "explicit":
case "g", "groups":
case "i", "info":
case "k", "check":
case "l", "list":
case "m", "foreign":
case "n", "native":
case "o", "owns":
case "file":
case "q", "quiet":
case "s", "search":
case "t", "unrequired":
case "u", "upgrades":
case "cascade":
case "nosave":
case "recursive":
case "unneeded":
case "clean":
case "sysupgrade":
case "w", "downloadonly":
case "y", "refresh":
case "x", "regex":
case "machinereadable":
// yay options
2018-08-19 04:05:16 +00:00
case "aururl":
case "save":
case "afterclean", "cleanafter":
case "noafterclean", "nocleanafter":
case "devel":
case "nodevel":
case "timeupdate":
case "notimeupdate":
case "topdown":
case "bottomup":
case "completioninterval":
case "sortby":
case "searchby":
case "redownload":
case "redownloadall":
case "noredownload":
case "rebuild":
case "rebuildall":
case "rebuildtree":
case "norebuild":
case "batchinstall":
case "nobatchinstall":
case "answerclean":
case "noanswerclean":
case "answerdiff":
case "noanswerdiff":
case "answeredit":
case "noansweredit":
case "answerupgrade":
case "noanswerupgrade":
case "gpgflags":
case "mflags":
case "gitflags":
case "builddir":
case "editor":
case "editorflags":
case "makepkg":
case "makepkgconf":
case "nomakepkgconf":
case "pacman":
case "git":
case "gpg":
2019-03-19 21:10:58 +00:00
case "sudo":
case "sudoflags":
case "requestsplitn":
case "sudoloop":
case "nosudoloop":
case "provides":
case "noprovides":
case "pgpfetch":
case "nopgpfetch":
case "upgrademenu":
case "noupgrademenu":
case "cleanmenu":
case "nocleanmenu":
case "diffmenu":
case "nodiffmenu":
case "editmenu":
case "noeditmenu":
case "useask":
case "nouseask":
case "combinedupgrade":
case "nocombinedupgrade":
case "a", "aur":
case "repo":
case "removemake":
case "noremovemake":
case "askremovemake":
case "complete":
case "stats":
case "news":
case "gendb":
case "currentconfig":
default:
return false
}
return true
}
func handleConfig(option, value string) bool {
switch option {
2018-08-19 04:05:16 +00:00
case "aururl":
config.AURURL = value
case "save":
shouldSaveConfig = true
case "afterclean", "cleanafter":
config.CleanAfter = true
case "noafterclean", "nocleanafter":
config.CleanAfter = false
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 "bottomup":
config.SortMode = bottomUp
case "completioninterval":
n, err := strconv.Atoi(value)
if err == nil {
config.CompletionInterval = n
}
case "sortby":
config.SortBy = value
case "searchby":
config.SearchBy = value
case "noconfirm":
config.NoConfirm = true
case "config":
config.PacmanConf = value
case "redownload":
config.ReDownload = "yes"
case "redownloadall":
config.ReDownload = "all"
case "noredownload":
config.ReDownload = "no"
case "rebuild":
config.ReBuild = "yes"
case "rebuildall":
config.ReBuild = "all"
case "rebuildtree":
config.ReBuild = "tree"
case "norebuild":
config.ReBuild = "no"
case "batchinstall":
config.BatchInstall = true
case "nobatchinstall":
config.BatchInstall = false
case "answerclean":
config.AnswerClean = value
case "noanswerclean":
config.AnswerClean = ""
case "answerdiff":
config.AnswerDiff = value
case "noanswerdiff":
config.AnswerDiff = ""
case "answeredit":
config.AnswerEdit = value
case "noansweredit":
config.AnswerEdit = ""
case "answerupgrade":
config.AnswerUpgrade = value
case "noanswerupgrade":
config.AnswerUpgrade = ""
case "gpgflags":
config.GpgFlags = value
case "mflags":
config.MFlags = value
case "gitflags":
config.GitFlags = value
case "builddir":
config.BuildDir = value
case "absdir":
config.ABSDir = value
case "editor":
config.Editor = value
case "editorflags":
config.EditorFlags = value
case "makepkg":
config.MakepkgBin = value
case "makepkgconf":
config.MakepkgConf = value
case "nomakepkgconf":
config.MakepkgConf = ""
case "pacman":
config.PacmanBin = value
case "git":
config.GitBin = value
case "gpg":
config.GpgBin = value
2019-03-19 21:10:58 +00:00
case "sudo":
config.SudoBin = value
case "sudoflags":
config.SudoFlags = value
case "requestsplitn":
n, err := strconv.Atoi(value)
if err == nil && n > 0 {
config.RequestSplitN = n
}
case "sudoloop":
config.SudoLoop = true
case "nosudoloop":
config.SudoLoop = false
case "provides":
config.Provides = true
case "noprovides":
config.Provides = false
case "pgpfetch":
config.PGPFetch = true
case "nopgpfetch":
config.PGPFetch = false
case "upgrademenu":
config.UpgradeMenu = true
case "noupgrademenu":
config.UpgradeMenu = false
case "cleanmenu":
config.CleanMenu = true
case "nocleanmenu":
config.CleanMenu = false
case "diffmenu":
config.DiffMenu = true
case "nodiffmenu":
config.DiffMenu = false
case "editmenu":
config.EditMenu = true
case "noeditmenu":
config.EditMenu = false
case "useask":
config.UseAsk = true
case "nouseask":
config.UseAsk = false
case "combinedupgrade":
config.CombinedUpgrade = true
case "nocombinedupgrade":
config.CombinedUpgrade = false
case "a", "aur":
mode = modeAUR
case "repo":
mode = modeRepo
case "removemake":
config.RemoveMake = "yes"
case "noremovemake":
config.RemoveMake = "no"
case "askremovemake":
config.RemoveMake = "ask"
default:
return false
}
return true
}
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 isOp(op string) bool {
switch op {
case "V", "version":
case "D", "database":
case "F", "files":
case "Q", "query":
case "R", "remove":
case "S", "sync":
case "T", "deptest":
case "U", "upgrade":
// yay specific
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":
case "P", "show":
case "G", "getpkgbuild":
default:
return false
}
return true
}
func isGlobal(op string) bool {
switch op {
case "b", "dbpath":
case "r", "root":
case "v", "verbose":
case "arch":
case "cachedir":
case "color":
case "config":
case "debug":
case "gpgdir":
case "hookdir":
case "logfile":
case "noconfirm":
case "confirm":
default:
return false
}
return true
}
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 hasParam(arg string) bool {
switch arg {
case "dbpath", "b":
case "root", "r":
case "sysroot":
case "config":
case "ignore":
case "assume-installed":
case "overwrite":
case "ask":
case "cachedir":
case "hookdir":
case "logfile":
case "ignoregroup":
case "arch":
case "print-format":
case "gpgdir":
case "color":
// yay params
2018-08-19 04:05:16 +00:00
case "aururl":
case "mflags":
case "gpgflags":
case "gitflags":
case "builddir":
case "absdir":
case "editor":
case "editorflags":
case "makepkg":
2018-07-17 23:53:53 +00:00
case "makepkgconf":
case "pacman":
case "git":
case "gpg":
2019-03-19 21:10:58 +00:00
case "sudo":
case "sudoflags":
case "requestsplitn":
case "answerclean":
case "answerdiff":
case "answeredit":
case "answerupgrade":
case "completioninterval":
case "sortby":
case "searchby":
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:
return false
}
return true
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
}
// Parses short hand options such as:
// -Syu -b/some/path -
func (parser *arguments) parseShortOption(arg, param string) (usedNext 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
if arg == "-" {
err = parser.addArg("-")
return
}
2018-01-19 14:51:18 +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
arg = arg[1:]
2018-01-19 14:51:18 +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
for k, _char := range arg {
char := string(_char)
2018-01-19 14:51:18 +00:00
2018-08-02 13:43:54 +00:00
if hasParam(char) {
if k < len(arg)-1 {
err = parser.addParam(char, arg[k+1:])
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
} else {
usedNext = true
err = parser.addParam(char, param)
}
2018-01-19 14:51:18 +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
break
} else {
err = parser.addArg(char)
2018-01-19 14:51:18 +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 {
return
}
}
}
return
}
// Parses full length options such as:
// --sync --refresh --sysupgrade --dbpath /some/path --
func (parser *arguments) parseLongOption(arg, param string) (usedNext 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
if arg == "--" {
err = parser.addArg(arg)
return
}
2018-01-19 14:51:18 +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
arg = arg[2:]
2018-01-19 14:51:18 +00:00
switch split := strings.SplitN(arg, "=", 2); {
case len(split) == 2:
2018-08-08 15:03:39 +00:00
err = parser.addParam(split[0], split[1])
case hasParam(arg):
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.addParam(arg, param)
usedNext = true
default:
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.addArg(arg)
}
2018-01-19 14:51:18 +00:00
Foundation for re writing the argument parsing system Currently the foundation for a new fuller argument parsing has been implemented in parser.go. Most of the parsing is now done through the argParser object instead of seperate arrays for options and packages. The rest of the code still expects the old system so I have left most of the operations unimplemented for now until I redo it with the new system. Currently only '-S' and number menu have any functionality for testing purposes. This new system parses arguments fully instead of just looking for predefined strings such as: '-Sqi' '-Siq'. This allows: '-Syu', '-S -y -u', '--sync -y -u' to all be parsed as the same. This system tries to be as similar to pacman as possible, eventually aming to fully wrap pacman, allowing yay to be used instead of pacman in all instances. The current implementation is not as strict as pacman when checking arguments. If you pass --someinvalidflag to yay then yay will simply ignore it. The flag should still be passed to pacman which should then cause an error. Although operations '-S' '-R' '-U' ect. are checked to make sure you can not try to use two operations at once. conflicting flags such as: '--quiet' and '--info' will not raise an error and which options gains precedence is depend on the implementation. Another minor issue which is worth noting is. Due to the way double arguments are parsed: '-dd' '-cc' '--deps --deps' if you pass the long version and the short version: '-d --deps' yay will not realize its a double argument. Meanwhile pacman will reconise it when yay calls pacman. Currently there are a few things that need to be done before this new system can be fuly released: Reimplement all operations to use to new parsing system so that the new system is at least as functional as the old one Strip yay specific flags before passing them to pacman Move parts of config into the argument system and only use config for options that are meant to be saved to disk Move yay specific operations into its own operator '-Y' Update documentation to show the altered syntax
2017-12-31 15:18:12 +00:00
return
}
func (parser *arguments) parseStdin() error {
scanner := bufio.NewScanner(os.Stdin)
scanner.Split(bufio.ScanLines)
2018-01-19 14:51:18 +00:00
for scanner.Scan() {
parser.addTarget(scanner.Text())
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 os.Stdin.Close()
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 (parser *arguments) parseCommandLine() 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
args := os.Args[1:]
usedNext := false
2018-01-19 14:51:18 +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 len(args) < 1 {
if _, err := parser.parseShortOption("-Syu", ""); err != nil {
return err
}
} else {
for k, arg := range args {
var nextArg string
2018-01-19 14:51:18 +00:00
if usedNext {
usedNext = false
continue
}
2018-01-19 14:51:18 +00:00
if k+1 < len(args) {
nextArg = args[k+1]
}
2018-01-19 14:51:18 +00:00
var err error
switch {
case parser.existsArg("--"):
parser.addTarget(arg)
case strings.HasPrefix(arg, "--"):
usedNext, err = parser.parseLongOption(arg, nextArg)
case strings.HasPrefix(arg, "-"):
usedNext, err = parser.parseShortOption(arg, nextArg)
default:
parser.addTarget(arg)
}
2018-01-19 14:51:18 +00:00
if err != nil {
return err
}
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-01-19 14:51:18 +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.op == "" {
parser.op = "Y"
}
2018-01-19 14:51:18 +00:00
if parser.existsArg("-") {
if err := parser.parseStdin(); err != nil {
return err
}
parser.delArg("-")
file, err := os.Open("/dev/tty")
if err != nil {
return err
}
os.Stdin = file
}
2018-01-19 14:51:18 +00:00
cmdArgs.extractYayOptions()
return nil
2018-01-19 14:51:18 +00:00
}
func (parser *arguments) extractYayOptions() {
for option, value := range parser.options {
if handleConfig(option, value) {
parser.delArg(option)
}
}
for option, value := range parser.globals {
if handleConfig(option, value) {
parser.delArg(option)
}
}
rpc.AURURL = strings.TrimRight(config.AURURL, "/") + "/rpc.php?"
config.AURURL = strings.TrimRight(config.AURURL, "/")
}
// Crude html parsing, good enough for the arch news
// This is only displayed in the terminal so there should be no security
// concerns
func parseNews(str string) string {
var buffer bytes.Buffer
var tagBuffer bytes.Buffer
var escapeBuffer bytes.Buffer
inTag := false
inEscape := false
for _, char := range str {
if inTag {
if char == '>' {
inTag = false
switch tagBuffer.String() {
case "code":
buffer.WriteString(cyanCode)
case "/code":
buffer.WriteString(resetCode)
case "/p":
buffer.WriteRune('\n')
}
continue
}
tagBuffer.WriteRune(char)
continue
}
if inEscape {
if char == ';' {
inEscape = false
2018-05-07 05:26:29 +00:00
escapeBuffer.WriteRune(char)
s := html.UnescapeString(escapeBuffer.String())
buffer.WriteString(s)
continue
}
escapeBuffer.WriteRune(char)
continue
}
if char == '<' {
inTag = true
tagBuffer.Reset()
continue
}
if char == '&' {
inEscape = true
escapeBuffer.Reset()
2018-05-07 05:26:29 +00:00
escapeBuffer.WriteRune(char)
continue
}
buffer.WriteRune(char)
}
buffer.WriteString(resetCode)
return buffer.String()
}