fix(parser): squash globals into options

install.go

@@ -177,7 +177,13 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
 
 		parser.Op = "S"
 		parser.DelArg("y", "refresh")
-		parser.Options["ignore"] = arguments.Options["ignore"]
+		if arguments.ExistsArg("ignore") {
+			if parser.ExistsArg("ignore") {
+				parser.Options["ignore"].Args = append(parser.Options["ignore"].Args, arguments.Options["ignore"].Args...)
+			} else {
+				parser.Options["ignore"] = arguments.Options["ignore"]
+			}
+		}
 		return show(passToPacman(parser))
 	}
 

pkg/completion/completion.go

@@ -20,7 +20,7 @@ func Show(alpmHandle *alpm.Handle, aurURL, completionPath string, interval int,
 		return err
 	}
 
-	in, err := os.OpenFile(completionPath, os.O_RDWR|os.O_CREATE, 0644)
+	in, err := os.OpenFile(completionPath, os.O_RDWR|os.O_CREATE, 0o644)
 	if err != nil {
 		return err
 	}
@@ -35,7 +35,7 @@ func Update(alpmHandle *alpm.Handle, aurURL, completionPath string, interval int
 	info, err := os.Stat(completionPath)
 
 	if os.IsNotExist(err) || (interval != -1 && time.Since(info.ModTime()).Hours() >= float64(interval*24)) || force {
-		errd := os.MkdirAll(filepath.Dir(completionPath), 0755)
+		errd := os.MkdirAll(filepath.Dir(completionPath), 0o755)
 		if errd != nil {
 			return errd
 		}

pkg/settings/config.go

@@ -67,7 +67,7 @@ func (config *Configuration) SaveConfig(configPath string) error {
 	if err != nil {
 		return err
 	}
-	in, err := os.OpenFile(configPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	in, err := os.OpenFile(configPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o644)
 	if err != nil {
 		return err
 	}

pkg/settings/parser.go

@@ -2,6 +2,7 @@ package settings
 
 import (
 	"bufio"
+	"fmt"
 	"os"
 	"strconv"
 	"strings"
@@ -12,7 +13,8 @@ import (
 )
 
 type Option struct {
-	Args []string
+	Global bool
+	Args   []string
 }
 
 func (o *Option) Add(arg string) {
@@ -34,28 +36,36 @@ func (o *Option) Set(arg string) {
 	o.Args = []string{arg}
 }
 
+func (o *Option) String() string {
+	return fmt.Sprintf("Global:%v Args:%v", o.Global, o.Args)
+}
+
 // Arguments 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 {
 	Op      string
 	Options map[string]*Option
-	Globals map[string]*Option
 	Targets []string
 }
 
+func (parser *Arguments) String() string {
+	return fmt.Sprintf("Op:%v Options:%+v Targets: %v", parser.Op, parser.Options, parser.Targets)
+}
+
 func MakeArguments() *Arguments {
 	return &Arguments{
 		"",
 		make(map[string]*Option),
-		make(map[string]*Option),
 		make([]string, 0),
 	}
 }
 
 func (parser *Arguments) CopyGlobal() *Arguments {
 	cp := MakeArguments()
-	for k, v := range parser.Globals {
+	for k, v := range parser.Options {
-		cp.Globals[k] = v
+		if v.Global {
+			cp.Options[k] = v
+		}
 	}
 
 	return cp
@@ -70,10 +80,6 @@ func (parser *Arguments) Copy() (cp *Arguments) {
 		cp.Options[k] = v
 	}
 
-	for k, v := range parser.Globals {
-		cp.Globals[k] = v
-	}
-
 	cp.Targets = make([]string, len(parser.Targets))
 	copy(cp.Targets, parser.Targets)
 
@@ -83,7 +89,6 @@ func (parser *Arguments) Copy() (cp *Arguments) {
 func (parser *Arguments) DelArg(options ...string) {
 	for _, option := range options {
 		delete(parser.Options, option)
-		delete(parser.Globals, option)
 	}
 }
 
@@ -161,16 +166,13 @@ func (parser *Arguments) addParam(option, arg string) error {
 		return parser.addOP(option)
 	}
 
+	if parser.Options[option] == nil {
+		parser.Options[option] = &Option{}
+	}
+	parser.Options[option].Add(arg)
+
 	if isGlobal(option) {
-		if parser.Globals[option] == nil {
+		parser.Options[option].Global = true
-			parser.Globals[option] = &Option{}
-		}
-		parser.Globals[option].Add(arg)
-	} else {
-		if parser.Options[option] == nil {
-			parser.Options[option] = &Option{}
-		}
-		parser.Options[option].Add(arg)
 	}
 	return nil
 }
@@ -188,13 +190,7 @@ func (parser *Arguments) AddArg(options ...string) error {
 // Multiple args acts as an OR operator
 func (parser *Arguments) ExistsArg(options ...string) bool {
 	for _, option := range options {
-		_, exists := parser.Options[option]
+		if _, exists := parser.Options[option]; exists {
-		if exists {
-			return true
-		}
-
-		_, exists = parser.Globals[option]
-		if exists {
 			return true
 		}
 	}
@@ -207,11 +203,6 @@ func (parser *Arguments) GetArg(options ...string) (arg string, double, exists b
 		if exists {
 			return value.First(), len(value.Args) >= 2, len(value.Args) >= 1
 		}
-
-		value, exists = parser.Globals[option]
-		if exists {
-			return value.First(), len(value.Args) >= 2, len(value.Args) >= 1
-		}
 	}
 
 	return arg, false, false
@@ -228,17 +219,10 @@ func (parser *Arguments) ClearTargets() {
 // Multiple args acts as an OR operator
 func (parser *Arguments) ExistsDouble(options ...string) bool {
 	for _, option := range options {
-		value, exists := parser.Options[option]
+		if value, exists := parser.Options[option]; exists {
-		if exists {
-			return len(value.Args) >= 2
-		}
-
-		value, exists = parser.Globals[option]
-		if exists {
 			return len(value.Args) >= 2
 		}
 	}
-
 	return false
 }
 
@@ -252,7 +236,7 @@ func (parser *Arguments) FormatArgs() (args []string) {
 	args = append(args, op)
 
 	for option, arg := range parser.Options {
-		if option == "--" {
+		if arg.Global || option == "--" {
 			continue
 		}
 
@@ -265,12 +249,14 @@ func (parser *Arguments) FormatArgs() (args []string) {
 			}
 		}
 	}
-
 	return
 }
 
 func (parser *Arguments) FormatGlobals() (args []string) {
-	for option, arg := range parser.Globals {
+	for option, arg := range parser.Options {
+		if !arg.Global {
+			continue
+		}
 		formattedOption := formatArg(option)
 
 		for _, value := range arg.Args {
@@ -280,7 +266,6 @@ func (parser *Arguments) FormatGlobals() (args []string) {
 			}
 		}
 	}
-
 	return args
 }
 
@@ -831,12 +816,6 @@ func (parser *Arguments) extractYayOptions(config *Configuration) {
 		}
 	}
 
-	for option, value := range parser.Globals {
-		if handleConfig(config, option, value.First()) {
-			parser.DelArg(option)
-		}
-	}
-
 	rpc.AURURL = strings.TrimRight(config.AURURL, "/") + "/rpc.php?"
 	config.AURURL = strings.TrimRight(config.AURURL, "/")
 }

pkg/settings/parser_test.go

@@ -106,7 +106,6 @@ func TestMakeArguments(t *testing.T) {
 	args := MakeArguments()
 	assert.NotNil(t, args)
 	assert.Equal(t, "", args.Op)
-	assert.Empty(t, args.Globals)
 	assert.Empty(t, args.Options)
 	assert.Empty(t, args.Targets)
 }
@@ -115,7 +114,6 @@ func TestArguments_CopyGlobal(t *testing.T) {
 	type fields struct {
 		Op      string
 		Options map[string]*Option
-		Globals map[string]*Option
 		Targets []string
 	}
 	tests := []struct {
@@ -124,19 +122,17 @@ func TestArguments_CopyGlobal(t *testing.T) {
 		want   *Arguments
 	}{
 		{name: "simple", fields: fields{
-			Op:      "Q",
+			Op: "Q",
-			Options: map[string]*Option{"a": {}},
+			Options: map[string]*Option{"a": {}, "arch": {Global: true,
-			Globals: map[string]*Option{"arch": {
 				Args: []string{"x86_x64"},
-			}, "boo": {Args: []string{"a", "b"}},
+			}, "boo": {Global: true, Args: []string{"a", "b"}},
 			},
 			Targets: []string{"a", "b"},
 		}, want: &Arguments{
-			Op:      "",
+			Op: "",
-			Options: map[string]*Option{},
+			Options: map[string]*Option{"arch": {Global: true,
-			Globals: map[string]*Option{"arch": {
 				Args: []string{"x86_x64"},
-			}, "boo": {Args: []string{"a", "b"}},
+			}, "boo": {Global: true, Args: []string{"a", "b"}},
 			},
 			Targets: []string{},
 		}},
@@ -146,14 +142,12 @@ func TestArguments_CopyGlobal(t *testing.T) {
 			parser := &Arguments{
 				Op:      tt.fields.Op,
 				Options: tt.fields.Options,
-				Globals: tt.fields.Globals,
 				Targets: tt.fields.Targets,
 			}
 			got := parser.CopyGlobal()
 			assert.NotEqualValues(t, tt.fields.Options, got.Options)
 			assert.NotEqualValues(t, tt.fields.Targets, got.Targets)
 			assert.NotEqual(t, tt.fields.Op, got.Op)
-			assert.EqualValues(t, tt.fields.Globals, got.Globals)
 			assert.Equal(t, tt.want, got)
 		})
 	}
@@ -163,7 +157,6 @@ func TestArguments_Copy(t *testing.T) {
 	type fields struct {
 		Op      string
 		Options map[string]*Option
-		Globals map[string]*Option
 		Targets []string
 	}
 	tests := []struct {
@@ -172,19 +165,17 @@ func TestArguments_Copy(t *testing.T) {
 		want   *Arguments
 	}{
 		{name: "simple", fields: fields{
-			Op:      "Q",
+			Op: "Q",
-			Options: map[string]*Option{"a": {}},
+			Options: map[string]*Option{"a": {}, "arch": {
-			Globals: map[string]*Option{"arch": {
+				Args: []string{"x86_x64"}, Global: true,
-				Args: []string{"x86_x64"},
+			}, "boo": {Args: []string{"a", "b"}, Global: true},
-			}, "boo": {Args: []string{"a", "b"}},
 			},
 			Targets: []string{"a", "b"},
 		}, want: &Arguments{
-			Op:      "Q",
+			Op: "Q",
-			Options: map[string]*Option{"a": {}},
+			Options: map[string]*Option{"a": {}, "arch": {Global: true,
-			Globals: map[string]*Option{"arch": {
 				Args: []string{"x86_x64"},
-			}, "boo": {Args: []string{"a", "b"}},
+			}, "boo": {Args: []string{"a", "b"}, Global: true},
 			},
 			Targets: []string{"a", "b"},
 		}},
@@ -194,7 +185,6 @@ func TestArguments_Copy(t *testing.T) {
 			parser := &Arguments{
 				Op:      tt.fields.Op,
 				Options: tt.fields.Options,
-				Globals: tt.fields.Globals,
 				Targets: tt.fields.Targets,
 			}
 			got := parser.Copy()
@@ -210,5 +200,4 @@ func TestArguments_DelArg(t *testing.T) {
 	args.addParam("ask", "arg")
 	args.DelArg("arch", "ask")
 	assert.Empty(t, args.Options)
-	assert.Empty(t, args.Globals)
 }

pkg/settings/runtime.go

@@ -79,7 +79,7 @@ func MakeRuntime() (*Runtime, error) {
 
 func initDir(dir string) error {
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		if err = os.MkdirAll(dir, 0755); err != nil {
+		if err = os.MkdirAll(dir, 0o755); err != nil {
 			return errors.New(gotext.Get("failed to create config directory '%s': %s", dir, err))
 		}
 	} else if err != nil {

pkg/text/print.go

@@ -7,9 +7,11 @@ import (
 	"github.com/leonelquinteros/gotext"
 )
 
-const arrow = "==>"
+const (
-const smallArrow = " ->"
+	arrow      = "==>"
-const opSymbol = "::"
+	smallArrow = " ->"
+	opSymbol   = "::"
+)
 
 func OperationInfoln(a ...interface{}) {
 	fmt.Fprint(os.Stdout, append([]interface{}{Bold(cyan(opSymbol + " ")), boldCode}, a...)...)