From 09fa75e141bf0b621c1a12389bb1c0808651ec4b Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 19 May 2020 14:49:13 -0500
Subject: [PATCH 01/26] implement gh alias set

---
 cmd/gh/main.go                  |  10 ++
 command/alias.go                |  98 +++++++++++++++++
 command/alias_test.go           | 179 ++++++++++++++++++++++++++++++++
 command/root.go                 |  35 +++++++
 internal/config/alias_config.go |  69 ++++++++++++
 internal/config/config_type.go  |  39 +++++++
 6 files changed, 430 insertions(+)
 create mode 100644 command/alias.go
 create mode 100644 command/alias_test.go
 create mode 100644 internal/config/alias_config.go

diff --git a/cmd/gh/main.go b/cmd/gh/main.go
index 98916523e..d7d29c7fb 100644
--- a/cmd/gh/main.go
+++ b/cmd/gh/main.go
@@ -30,6 +30,16 @@ func main() {
 
 	hasDebug := os.Getenv("DEBUG") != ""
 
+	stderr := utils.NewColorable(os.Stderr)
+
+	expandedArgs, err := command.ExpandAlias(os.Args)
+	if err != nil {
+		fmt.Fprintf(stderr, "failed to process aliases:  %s\n", err)
+		os.Exit(2)
+	}
+
+	command.RootCmd.SetArgs(expandedArgs)
+
 	if cmd, err := command.RootCmd.ExecuteC(); err != nil {
 		printError(os.Stderr, err, cmd, hasDebug)
 		os.Exit(1)
diff --git a/command/alias.go b/command/alias.go
new file mode 100644
index 000000000..2e2c5f3e4
--- /dev/null
+++ b/command/alias.go
@@ -0,0 +1,98 @@
+package command
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/cli/cli/utils"
+	"github.com/google/shlex"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	RootCmd.AddCommand(aliasCmd)
+	aliasCmd.AddCommand(aliasSetCmd)
+}
+
+var aliasCmd = &cobra.Command{
+	Use:   "alias",
+	Short: "Create shortcuts for gh commands",
+	Long:  `TODO`,
+}
+
+var aliasSetCmd = &cobra.Command{
+	Use: "set <alias> <expansion>",
+	// TODO HACK: even when inside of a single-quoted string, cobra was noticing and parsing any flags
+	// used in an alias expansion string argument. Since this command needs no flags, I disabled their
+	// parsing. If we ever want to add flags to alias set we'll have to figure this out. I haven't
+	// checked if this is fixed in a new cobra.
+	DisableFlagParsing: true,
+	Short:              "Create a shortcut for a gh command",
+	Long: `gh alias set <alias> <expansion>
+
+This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.
+
+Examples:
+
+	gh alias set pv 'pr view'
+	# gh pv -w 123 -> gh pr view -w 123.
+
+	gh alias set bugs 'issue list --label="bugs"'
+	# gh bugs -> gh issue list --label="bugs".
+
+	gh alias set epicsBy 'issue list --author="$1" --label="epic"'
+	# gh epicsBy vilmibm -> gh issue list --author="$1" --label="epic"
+`,
+	Args: cobra.MinimumNArgs(2),
+	RunE: aliasSet,
+}
+
+func aliasSet(cmd *cobra.Command, args []string) error {
+	ctx := contextForCommand(cmd)
+	cfg, err := ctx.Config()
+	if err != nil {
+		return err
+	}
+
+	aliasCfg, err := cfg.Aliases()
+	if err != nil {
+		return err
+	}
+
+	alias := args[0]
+	expansion := processArgs(args[1:])
+
+	out := colorableOut(cmd)
+	fmt.Fprintf(out, "- Adding alias for %s: %s\n", utils.Bold(alias), utils.Bold(expansion))
+
+	if aliasCfg.Exists(alias) {
+		return fmt.Errorf("alias %s already exists", alias)
+	}
+
+	if !validCommand(expansion) {
+		return fmt.Errorf("could not create alias: %s does not correspond to a gh command", utils.Bold(expansion))
+	}
+
+	err = aliasCfg.Add(alias, expansion)
+	if err != nil {
+		return fmt.Errorf("could not create alias: %s", err)
+	}
+
+	fmt.Fprintf(out, "%s Added alias.\n", utils.Green("✓"))
+
+	return nil
+}
+
+func validCommand(expansion string) bool {
+	split, _ := shlex.Split(expansion)
+	cmd, _, err := RootCmd.Traverse(split)
+	return err == nil && cmd != RootCmd
+}
+
+func processArgs(args []string) string {
+	if len(args) == 1 {
+		return args[0]
+	}
+
+	return strings.Join(args, " ")
+}
diff --git a/command/alias_test.go b/command/alias_test.go
new file mode 100644
index 000000000..3fc821b4f
--- /dev/null
+++ b/command/alias_test.go
@@ -0,0 +1,179 @@
+package command
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/cli/cli/internal/config"
+	"github.com/cli/cli/test"
+)
+
+func TestAliasSet_existing_alias(t *testing.T) {
+	cfg := `---
+hosts:
+  github.com:
+    user: OWNER
+    oauth_token: token123
+aliases:
+  co: pr checkout
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	_, err := RunCommand("alias set co pr checkout")
+
+	if err == nil {
+		t.Fatal("expected error")
+	}
+
+	eq(t, err.Error(), "alias co already exists")
+}
+
+func TestAliasSet_arg_processing(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+	cases := []struct {
+		Cmd                string
+		ExpectedOutputLine string
+		ExpectedConfigLine string
+	}{
+		{"alias set co pr checkout", "- Adding alias for co: pr checkout", "co: pr checkout"},
+
+		{`alias set il "issue list"`, "- Adding alias for il: issue list", "il: issue list"},
+
+		{`alias set iz 'issue list'`, "- Adding alias for iz: issue list", "iz: issue list"},
+
+		{`alias set iy issue list --author=\$1 --label=\$2`,
+			`- Adding alias for iy: issue list --author=\$1 --label=\$2`,
+			`iy: issue list --author=\$1 --label=\$2`},
+
+		{`alias set ii 'issue list --author="$1" --label="$2"'`,
+			`- Adding alias for ii: issue list --author="\$1" --label="\$2"`,
+			`ii: issue list --author="\$1" --label="\$2"`},
+
+		{`alias set ix issue list --author='$1' --label='$2'`,
+			`- Adding alias for ix: issue list --author=\$1 --label=\$2`,
+			`ix: issue list --author=\$1 --label=\$2`},
+	}
+
+	var buf *bytes.Buffer
+	for _, c := range cases {
+		buf = bytes.NewBufferString("")
+		defer config.StubWriteConfig(buf)()
+		output, err := RunCommand(c.Cmd)
+		if err != nil {
+			t.Fatalf("got unexpected error running %s: %s", c.Cmd, err)
+		}
+
+		test.ExpectLines(t, output.String(), c.ExpectedOutputLine)
+		test.ExpectLines(t, buf.String(), c.ExpectedConfigLine)
+	}
+}
+
+func TestAliasSet_init_alias_cfg(t *testing.T) {
+	cfg := `---
+hosts:
+  github.com:
+    user: OWNER
+    oauth_token: token123
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	buf := bytes.NewBufferString("")
+	defer config.StubWriteConfig(buf)()
+
+	output, err := RunCommand("alias set diff pr diff")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	expected := `hosts:
+    github.com:
+        user: OWNER
+        oauth_token: token123
+aliases:
+    diff: pr diff
+`
+
+	test.ExpectLines(t, output.String(), "Adding alias for diff: pr diff", "Added alias.")
+	eq(t, buf.String(), expected)
+}
+
+func TestAliasSet_existing_aliases(t *testing.T) {
+	cfg := `---
+hosts:
+  github.com:
+    user: OWNER
+    oauth_token: token123
+aliases:
+    foo: bar
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	buf := bytes.NewBufferString("")
+	defer config.StubWriteConfig(buf)()
+
+	output, err := RunCommand("alias set view pr view")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	expected := `hosts:
+    github.com:
+        user: OWNER
+        oauth_token: token123
+aliases:
+    foo: bar
+    view: pr view
+`
+
+	test.ExpectLines(t, output.String(), "Adding alias for view: pr view", "Added alias.")
+	eq(t, buf.String(), expected)
+
+}
+
+func TestExpandAlias(t *testing.T) {
+	cfg := `---
+hosts:
+  github.com:
+    user: OWNER
+    oauth_token: token123
+aliases:
+  co: pr checkout
+  il: issue list --author="$1" --label="$2"
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+	for _, c := range []struct {
+		Args         string
+		ExpectedArgs []string
+		Err          string
+	}{
+		{"gh co", []string{"pr", "checkout"}, ""},
+		{"gh il", nil, `not enough arguments for alias: issue list --author="$1" --label="$2"`},
+		{"gh il vilmibm", nil, `not enough arguments for alias: issue list --author="vilmibm" --label="$2"`},
+		{"gh il vilmibm epic", []string{"issue", "list", `--author=vilmibm`, `--label=epic`}, ""},
+		{"gh pr status", []string{"pr", "status"}, ""},
+		{"gh dne", []string{"dne"}, ""},
+		{"gh", []string{}, ""},
+	} {
+		out, err := ExpandAlias(strings.Split(c.Args, " "))
+		if err == nil && c.Err != "" {
+			t.Errorf("expected error %s for %s", c.Err, c.Args)
+			continue
+		}
+
+		if err != nil {
+			eq(t, err.Error(), c.Err)
+			continue
+		}
+
+		eq(t, out, c.ExpectedArgs)
+	}
+}
+
+func TestAliasSet_invalid_command(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+	_, err := RunCommand("alias set co pe checkout")
+	if err == nil {
+		t.Fatal("expected error")
+	}
+
+	eq(t, err.Error(), "could not create alias: pe checkout does not correspond to a gh command")
+}
diff --git a/command/root.go b/command/root.go
index 208c7814d..908685d12 100644
--- a/command/root.go
+++ b/command/root.go
@@ -18,6 +18,7 @@ import (
 	"github.com/cli/cli/pkg/cmdutil"
 	"github.com/cli/cli/pkg/iostreams"
 	"github.com/cli/cli/utils"
+	"github.com/google/shlex"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -462,3 +463,37 @@ func determineEditor(cmd *cobra.Command) (string, error) {
 
 	return editorCommand, nil
 }
+
+func ExpandAlias(args []string) ([]string, error) {
+	// TODO i don't love that context is being init'd twice. My reading of the code is that it is
+	// idempotent and okay but I don't know if that's ok to depend on.
+	if len(args) == 1 {
+		// the command is lacking a subcommand
+		return []string{}, nil
+	}
+
+	ctx := initContext()
+	cfg, err := ctx.Config()
+	if err != nil {
+		return []string{}, err
+	}
+	aliases, err := cfg.Aliases()
+	if err != nil {
+		return []string{}, err
+	}
+
+	if aliases.Exists(args[1]) {
+		expansion := aliases.Get(args[1])
+		if strings.Contains(expansion, "$") {
+			for i, a := range args[2:] {
+				expansion = strings.Replace(expansion, fmt.Sprintf("$%d", i+1), a, 1)
+			}
+			if strings.Contains(expansion, "$") {
+				return []string{}, fmt.Errorf("not enough arguments for alias: %s", expansion)
+			}
+		}
+		return shlex.Split(expansion)
+	}
+
+	return args[1:], nil
+}
diff --git a/internal/config/alias_config.go b/internal/config/alias_config.go
new file mode 100644
index 000000000..ab576b8dd
--- /dev/null
+++ b/internal/config/alias_config.go
@@ -0,0 +1,69 @@
+package config
+
+import (
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+)
+
+type AliasConfig struct {
+	ConfigMap
+	Parent Config
+}
+
+// TODO at what point should the alias top level be added? Lazily on first write, I think;
+// but then we aren't initializing the default aliases that we want. also want to ensure that we
+// don't re-add the default aliases if people delete them.
+//
+// I think I'm not going to worry about it for now; config setup will add the aliases and existing
+// users can take some step later on to add them if they want them. we'll otherwise lazily create
+// the aliases: section on first write.
+
+func (a *AliasConfig) Exists(alias string) bool {
+	if a.Empty() {
+		return false
+	}
+	value, _ := a.GetStringValue(alias)
+
+	return value != ""
+}
+
+func (a *AliasConfig) Get(alias string) string {
+	value, _ := a.GetStringValue(alias)
+
+	return value
+}
+
+func (a *AliasConfig) Add(alias, expansion string) error {
+	if a.Root == nil {
+		// then we don't actually have an aliases stanza in the config yet.
+		keyNode := &yaml.Node{
+			Kind:  yaml.ScalarNode,
+			Value: "aliases",
+		}
+		valueNode := &yaml.Node{
+			Kind:  yaml.MappingNode,
+			Value: "",
+		}
+
+		a.Root = valueNode
+		a.Parent.Root().Content = append(a.Parent.Root().Content, keyNode, valueNode)
+	}
+
+	err := a.SetStringValue(alias, expansion)
+	if err != nil {
+		return fmt.Errorf("failed to update config: %w", err)
+	}
+
+	err = a.Parent.Write()
+	if err != nil {
+		return fmt.Errorf("failed to write config: %w", err)
+	}
+
+	return nil
+}
+
+func (a *AliasConfig) Delete(alias string) error {
+	// TODO when we get to gh alias delete
+	return nil
+}
diff --git a/internal/config/config_type.go b/internal/config/config_type.go
index e37c3e884..ddcd13401 100644
--- a/internal/config/config_type.go
+++ b/internal/config/config_type.go
@@ -12,9 +12,11 @@ const defaultGitProtocol = "https"
 
 // This interface describes interacting with some persistent configuration for gh.
 type Config interface {
+	Root() *yaml.Node
 	Hosts() ([]*HostConfig, error)
 	Get(string, string) (string, error)
 	Set(string, string, string) error
+	Aliases() (*AliasConfig, error)
 	Write() error
 }
 
@@ -34,6 +36,10 @@ type ConfigMap struct {
 	Root *yaml.Node
 }
 
+func (cm *ConfigMap) Empty() bool {
+	return cm.Root == nil || len(cm.Root.Content) == 0
+}
+
 func (cm *ConfigMap) GetStringValue(key string) (string, error) {
 	_, valueNode, err := cm.FindEntry(key)
 	if err != nil {
@@ -96,6 +102,10 @@ type fileConfig struct {
 	hosts        []*HostConfig
 }
 
+func (c *fileConfig) Root() *yaml.Node {
+	return c.ConfigMap.Root
+}
+
 func (c *fileConfig) Get(hostname, key string) (string, error) {
 	if hostname != "" {
 		hostCfg, err := c.configForHost(hostname)
@@ -167,6 +177,35 @@ func (c *fileConfig) Write() error {
 	return WriteConfigFile(ConfigFile(), marshalled)
 }
 
+func (c *fileConfig) Aliases() (*AliasConfig, error) {
+	_, aliasesEntry, err := c.FindEntry("aliases")
+	var nfe *NotFoundError
+	if err != nil && errors.As(err, &nfe) {
+		// TODO does this make sense at all? want to simulate existing but empty key.
+		return &AliasConfig{Parent: c}, nil
+	}
+
+	aliasConfig, err := c.parseAliasConfig(aliasesEntry)
+	if err != nil {
+		return nil, err
+	}
+
+	return aliasConfig, nil
+}
+
+func (c *fileConfig) parseAliasConfig(aliasesEntry *yaml.Node) (*AliasConfig, error) {
+	if aliasesEntry.Kind != yaml.MappingNode {
+		return nil, errors.New("expected aliases to be a map")
+	}
+
+	aliasConfig := AliasConfig{
+		Parent:    c,
+		ConfigMap: ConfigMap{Root: aliasesEntry},
+	}
+
+	return &aliasConfig, nil
+}
+
 func (c *fileConfig) Hosts() ([]*HostConfig, error) {
 	if len(c.hosts) > 0 {
 		return c.hosts, nil

From 7ed2e4774fe9c8d20946e5c0b6325db8ce6265f4 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 11:01:18 -0500
Subject: [PATCH 02/26] docs

---
 command/alias.go | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/command/alias.go b/command/alias.go
index 2e2c5f3e4..5b3c27720 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -17,7 +17,6 @@ func init() {
 var aliasCmd = &cobra.Command{
 	Use:   "alias",
 	Short: "Create shortcuts for gh commands",
-	Long:  `TODO`,
 }
 
 var aliasSetCmd = &cobra.Command{
@@ -30,10 +29,8 @@ var aliasSetCmd = &cobra.Command{
 	Short:              "Create a shortcut for a gh command",
 	Long: `gh alias set <alias> <expansion>
 
-This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.
-
-Examples:
-
+This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.`,
+	Example: `
 	gh alias set pv 'pr view'
 	# gh pv -w 123 -> gh pr view -w 123.
 

From 125f338686a821f6208d943bd593dd06858fdb0d Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 14:15:32 -0500
Subject: [PATCH 03/26] doc

---
 command/alias.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/command/alias.go b/command/alias.go
index 5b3c27720..7fdd7a5cf 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -27,8 +27,7 @@ var aliasSetCmd = &cobra.Command{
 	// checked if this is fixed in a new cobra.
 	DisableFlagParsing: true,
 	Short:              "Create a shortcut for a gh command",
-	Long: `gh alias set <alias> <expansion>
-
+	Long: `
 This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.`,
 	Example: `
 	gh alias set pv 'pr view'

From f84707b5b1bfbc0543b1b4da181440daadd98f49 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 14:41:02 -0500
Subject: [PATCH 04/26] args length check; needs test

---
 command/root.go | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/command/root.go b/command/root.go
index 908685d12..7ed0fc7de 100644
--- a/command/root.go
+++ b/command/root.go
@@ -465,21 +465,20 @@ func determineEditor(cmd *cobra.Command) (string, error) {
 }
 
 func ExpandAlias(args []string) ([]string, error) {
-	// TODO i don't love that context is being init'd twice. My reading of the code is that it is
-	// idempotent and okay but I don't know if that's ok to depend on.
-	if len(args) == 1 {
+	empty := []string{}
+	if len(args) < 2 {
 		// the command is lacking a subcommand
-		return []string{}, nil
+		return empty, nil
 	}
 
 	ctx := initContext()
 	cfg, err := ctx.Config()
 	if err != nil {
-		return []string{}, err
+		return empty, err
 	}
 	aliases, err := cfg.Aliases()
 	if err != nil {
-		return []string{}, err
+		return empty, err
 	}
 
 	if aliases.Exists(args[1]) {
@@ -489,7 +488,7 @@ func ExpandAlias(args []string) ([]string, error) {
 				expansion = strings.Replace(expansion, fmt.Sprintf("$%d", i+1), a, 1)
 			}
 			if strings.Contains(expansion, "$") {
-				return []string{}, fmt.Errorf("not enough arguments for alias: %s", expansion)
+				return empty, fmt.Errorf("not enough arguments for alias: %s", expansion)
 			}
 		}
 		return shlex.Split(expansion)

From 5fde67110e12ad96d8f507dfb4e9f5456e60f1e1 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 15:00:25 -0500
Subject: [PATCH 05/26] 0 args tst

---
 command/alias_test.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/command/alias_test.go b/command/alias_test.go
index 3fc821b4f..3e1660d85 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -152,8 +152,15 @@ aliases:
 		{"gh pr status", []string{"pr", "status"}, ""},
 		{"gh dne", []string{"dne"}, ""},
 		{"gh", []string{}, ""},
+		{"", []string{}, ""},
 	} {
-		out, err := ExpandAlias(strings.Split(c.Args, " "))
+		args := []string{}
+		if c.Args != "" {
+			args = strings.Split(c.Args, " ")
+		}
+
+		out, err := ExpandAlias(args)
+
 		if err == nil && c.Err != "" {
 			t.Errorf("expected error %s for %s", c.Err, c.Args)
 			continue

From bace3276340c3276a534a2d74fe6d3a07da175e6 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 15:36:07 -0500
Subject: [PATCH 06/26] pass rest of args through

---
 command/alias_test.go |  1 +
 command/root.go       | 14 ++++++++------
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/command/alias_test.go b/command/alias_test.go
index 3e1660d85..3932d6af3 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -148,6 +148,7 @@ aliases:
 		{"gh co", []string{"pr", "checkout"}, ""},
 		{"gh il", nil, `not enough arguments for alias: issue list --author="$1" --label="$2"`},
 		{"gh il vilmibm", nil, `not enough arguments for alias: issue list --author="vilmibm" --label="$2"`},
+		{"gh co 123", []string{"pr", "checkout", "123"}, ""},
 		{"gh il vilmibm epic", []string{"issue", "list", `--author=vilmibm`, `--label=epic`}, ""},
 		{"gh pr status", []string{"pr", "status"}, ""},
 		{"gh dne", []string{"dne"}, ""},
diff --git a/command/root.go b/command/root.go
index 7ed0fc7de..1fe790a40 100644
--- a/command/root.go
+++ b/command/root.go
@@ -483,13 +483,15 @@ func ExpandAlias(args []string) ([]string, error) {
 
 	if aliases.Exists(args[1]) {
 		expansion := aliases.Get(args[1])
+		for i, a := range args[2:] {
+			if !strings.Contains(expansion, "$") {
+				expansion += " " + a
+			} else {
+				expansion = strings.ReplaceAll(expansion, fmt.Sprintf("$%d", i+1), a)
+			}
+		}
 		if strings.Contains(expansion, "$") {
-			for i, a := range args[2:] {
-				expansion = strings.Replace(expansion, fmt.Sprintf("$%d", i+1), a, 1)
-			}
-			if strings.Contains(expansion, "$") {
-				return empty, fmt.Errorf("not enough arguments for alias: %s", expansion)
-			}
+			return empty, fmt.Errorf("not enough arguments for alias: %s", expansion)
 		}
 		return shlex.Split(expansion)
 	}

From e37b517211d6c817d3fc7f6be3ad9e37a0ef2d52 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 15:59:28 -0500
Subject: [PATCH 07/26] better placeholder handling

---
 command/alias.go      | 7 +++++++
 command/alias_test.go | 3 +++
 command/root.go       | 3 ++-
 3 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/command/alias.go b/command/alias.go
index 7fdd7a5cf..3448f7b24 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -9,6 +9,13 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// TODO
+// - [ ] DEBUG support
+// - [ ] prevent overriding existing gh command
+// - [ ] allow overwriting alias
+// - [ ] forward extra arguments
+// - [ ] allow duplication of placeholder
+
 func init() {
 	RootCmd.AddCommand(aliasCmd)
 	aliasCmd.AddCommand(aliasSetCmd)
diff --git a/command/alias_test.go b/command/alias_test.go
index 3932d6af3..1e152ca89 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -138,6 +138,7 @@ hosts:
 aliases:
   co: pr checkout
   il: issue list --author="$1" --label="$2"
+  ia: issue list --author="$1" --assignee="$1"
 `
 	initBlankContext(cfg, "OWNER/REPO", "trunk")
 	for _, c := range []struct {
@@ -150,6 +151,8 @@ aliases:
 		{"gh il vilmibm", nil, `not enough arguments for alias: issue list --author="vilmibm" --label="$2"`},
 		{"gh co 123", []string{"pr", "checkout", "123"}, ""},
 		{"gh il vilmibm epic", []string{"issue", "list", `--author=vilmibm`, `--label=epic`}, ""},
+		{"gh ia vilmibm", []string{"issue", "list", `--author=vilmibm`, `--assignee=vilmibm`}, ""},
+		{"gh ia $coolmoney$", []string{"issue", "list", `--author=$coolmoney$`, `--assignee=$coolmoney$`}, ""},
 		{"gh pr status", []string{"pr", "status"}, ""},
 		{"gh dne", []string{"dne"}, ""},
 		{"gh", []string{}, ""},
diff --git a/command/root.go b/command/root.go
index 1fe790a40..1e09651d2 100644
--- a/command/root.go
+++ b/command/root.go
@@ -490,7 +490,8 @@ func ExpandAlias(args []string) ([]string, error) {
 				expansion = strings.ReplaceAll(expansion, fmt.Sprintf("$%d", i+1), a)
 			}
 		}
-		if strings.Contains(expansion, "$") {
+		lingeringRE := regexp.MustCompile(`\$\d`)
+		if lingeringRE.MatchString(expansion) {
 			return empty, fmt.Errorf("not enough arguments for alias: %s", expansion)
 		}
 		return shlex.Split(expansion)

From 3552e72f7c3f0bd9ea08107871b11756471cc3c5 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 16:22:27 -0500
Subject: [PATCH 08/26] allow overwriting aliases

---
 command/alias.go      | 23 +++++++++++++++--------
 command/alias_test.go |  8 ++++----
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/command/alias.go b/command/alias.go
index 3448f7b24..12cfe4ace 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -12,9 +12,9 @@ import (
 // TODO
 // - [ ] DEBUG support
 // - [ ] prevent overriding existing gh command
-// - [ ] allow overwriting alias
-// - [ ] forward extra arguments
-// - [ ] allow duplication of placeholder
+// - [x] allow overwriting alias
+// - [x] forward extra arguments
+// - [x] allow duplication of placeholder
 
 func init() {
 	RootCmd.AddCommand(aliasCmd)
@@ -68,20 +68,27 @@ func aliasSet(cmd *cobra.Command, args []string) error {
 	out := colorableOut(cmd)
 	fmt.Fprintf(out, "- Adding alias for %s: %s\n", utils.Bold(alias), utils.Bold(expansion))
 
-	if aliasCfg.Exists(alias) {
-		return fmt.Errorf("alias %s already exists", alias)
-	}
-
 	if !validCommand(expansion) {
 		return fmt.Errorf("could not create alias: %s does not correspond to a gh command", utils.Bold(expansion))
 	}
 
+	successMsg := fmt.Sprintf("%s Added alias.", utils.Green("✓"))
+
+	if aliasCfg.Exists(alias) {
+		successMsg = fmt.Sprintf("%s Changed alias %s from %s to %s",
+			utils.Green("✓"),
+			utils.Bold(alias),
+			utils.Bold(aliasCfg.Get(alias)),
+			utils.Bold(expansion),
+		)
+	}
+
 	err = aliasCfg.Add(alias, expansion)
 	if err != nil {
 		return fmt.Errorf("could not create alias: %s", err)
 	}
 
-	fmt.Fprintf(out, "%s Added alias.\n", utils.Green("✓"))
+	fmt.Fprintln(out, successMsg)
 
 	return nil
 }
diff --git a/command/alias_test.go b/command/alias_test.go
index 1e152ca89..f222e185b 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -20,13 +20,13 @@ aliases:
 `
 	initBlankContext(cfg, "OWNER/REPO", "trunk")
 
-	_, err := RunCommand("alias set co pr checkout")
+	output, err := RunCommand("alias set co pr checkout -Rcool/repo")
 
-	if err == nil {
-		t.Fatal("expected error")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
 	}
 
-	eq(t, err.Error(), "alias co already exists")
+	test.ExpectLines(t, output.String(), "Changed alias co from pr checkout to pr checkout -Rcool/repo")
 }
 
 func TestAliasSet_arg_processing(t *testing.T) {

From 24e97a460ffb2f8c39ff50ce54f52ee3ceaa4050 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 16:28:23 -0500
Subject: [PATCH 09/26] prevent overriding gh commands

---
 command/alias.go      |  6 +++++-
 command/alias_test.go | 11 +++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/command/alias.go b/command/alias.go
index 12cfe4ace..5c7ef405a 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -11,7 +11,7 @@ import (
 
 // TODO
 // - [ ] DEBUG support
-// - [ ] prevent overriding existing gh command
+// - [x] prevent overriding existing gh command
 // - [x] allow overwriting alias
 // - [x] forward extra arguments
 // - [x] allow duplication of placeholder
@@ -68,6 +68,10 @@ func aliasSet(cmd *cobra.Command, args []string) error {
 	out := colorableOut(cmd)
 	fmt.Fprintf(out, "- Adding alias for %s: %s\n", utils.Bold(alias), utils.Bold(expansion))
 
+	if validCommand(alias) {
+		return fmt.Errorf("could not create alias: %q is already a gh command", alias)
+	}
+
 	if !validCommand(expansion) {
 		return fmt.Errorf("could not create alias: %s does not correspond to a gh command", utils.Bold(expansion))
 	}
diff --git a/command/alias_test.go b/command/alias_test.go
index f222e185b..62af996ca 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -9,6 +9,17 @@ import (
 	"github.com/cli/cli/test"
 )
 
+func TestAliasSet_gh_command(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+
+	_, err := RunCommand("alias set pr pr status")
+	if err == nil {
+		t.Fatal("expected error")
+	}
+
+	eq(t, err.Error(), `could not create alias: "pr" is already a gh command`)
+}
+
 func TestAliasSet_existing_alias(t *testing.T) {
 	cfg := `---
 hosts:

From ad7c48424319ccf35c499cff89e06bd3e51e8b80 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 16:29:11 -0500
Subject: [PATCH 10/26] TODO

---
 command/alias.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/command/alias.go b/command/alias.go
index 5c7ef405a..f3a09603c 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -11,6 +11,7 @@ import (
 
 // TODO
 // - [ ] DEBUG support
+// - [ ] give our commands precedence
 // - [x] prevent overriding existing gh command
 // - [x] allow overwriting alias
 // - [x] forward extra arguments

From db741a0284d5eba41b35a24daf1d809c5cd0e541 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 16:40:18 -0500
Subject: [PATCH 11/26] oops

---
 command/alias_test.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/command/alias_test.go b/command/alias_test.go
index 62af996ca..1b0fc35ff 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -12,6 +12,9 @@ import (
 func TestAliasSet_gh_command(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "trunk")
 
+	buf := bytes.NewBufferString("")
+	defer config.StubWriteConfig(buf)()
+
 	_, err := RunCommand("alias set pr pr status")
 	if err == nil {
 		t.Fatal("expected error")
@@ -31,6 +34,8 @@ aliases:
 `
 	initBlankContext(cfg, "OWNER/REPO", "trunk")
 
+	buf := bytes.NewBufferString("")
+	defer config.StubWriteConfig(buf)()
 	output, err := RunCommand("alias set co pr checkout -Rcool/repo")
 
 	if err != nil {

From 2627c5bb74e387503ea4ad49cd63bfd19de5c596 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 16:45:29 -0500
Subject: [PATCH 12/26] only process aliases when non-existent command passed

---
 cmd/gh/main.go   | 16 ++++++++++++----
 command/alias.go |  2 +-
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/cmd/gh/main.go b/cmd/gh/main.go
index d7d29c7fb..b4ddcb302 100644
--- a/cmd/gh/main.go
+++ b/cmd/gh/main.go
@@ -32,10 +32,18 @@ func main() {
 
 	stderr := utils.NewColorable(os.Stderr)
 
-	expandedArgs, err := command.ExpandAlias(os.Args)
-	if err != nil {
-		fmt.Fprintf(stderr, "failed to process aliases:  %s\n", err)
-		os.Exit(2)
+	expandedArgs := []string{}
+	if len(os.Args) > 0 {
+		expandedArgs = os.Args[1:]
+	}
+
+	cmd, _, err := command.RootCmd.Traverse(expandedArgs)
+	if err != nil || cmd == command.RootCmd {
+		expandedArgs, err = command.ExpandAlias(os.Args)
+		if err != nil {
+			fmt.Fprintf(stderr, "failed to process aliases:  %s\n", err)
+			os.Exit(2)
+		}
 	}
 
 	command.RootCmd.SetArgs(expandedArgs)
diff --git a/command/alias.go b/command/alias.go
index f3a09603c..541422b58 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -11,7 +11,7 @@ import (
 
 // TODO
 // - [ ] DEBUG support
-// - [ ] give our commands precedence
+// - [x] give our commands precedence
 // - [x] prevent overriding existing gh command
 // - [x] allow overwriting alias
 // - [x] forward extra arguments

From 9c4bf00703fdee3461f3b622b4378f4b08524848 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 16:50:13 -0500
Subject: [PATCH 13/26] todo

---
 command/alias.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/command/alias.go b/command/alias.go
index 541422b58..7cec65650 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -11,6 +11,7 @@ import (
 
 // TODO
 // - [ ] DEBUG support
+// - [ ] blank aliases stanza
 // - [x] give our commands precedence
 // - [x] prevent overriding existing gh command
 // - [x] allow overwriting alias

From 7b4c0c57b8a4111a71de23b63edf927e77da785f Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 17:51:50 -0500
Subject: [PATCH 14/26] WIP: handle empty aliases key

---
 internal/config/alias_config.go | 44 +++++++++++++++++++++++----------
 internal/config/config_type.go  | 30 +++++++++++++++++++++-
 2 files changed, 60 insertions(+), 14 deletions(-)

diff --git a/internal/config/alias_config.go b/internal/config/alias_config.go
index ab576b8dd..59e6a24c5 100644
--- a/internal/config/alias_config.go
+++ b/internal/config/alias_config.go
@@ -1,6 +1,7 @@
 package config
 
 import (
+	"errors"
 	"fmt"
 
 	"gopkg.in/yaml.v3"
@@ -11,14 +12,6 @@ type AliasConfig struct {
 	Parent Config
 }
 
-// TODO at what point should the alias top level be added? Lazily on first write, I think;
-// but then we aren't initializing the default aliases that we want. also want to ensure that we
-// don't re-add the default aliases if people delete them.
-//
-// I think I'm not going to worry about it for now; config setup will add the aliases and existing
-// users can take some step later on to add them if they want them. we'll otherwise lazily create
-// the aliases: section on first write.
-
 func (a *AliasConfig) Exists(alias string) bool {
 	if a.Empty() {
 		return false
@@ -36,10 +29,13 @@ func (a *AliasConfig) Get(alias string) string {
 
 func (a *AliasConfig) Add(alias, expansion string) error {
 	if a.Root == nil {
-		// then we don't actually have an aliases stanza in the config yet.
-		keyNode := &yaml.Node{
-			Kind:  yaml.ScalarNode,
-			Value: "aliases",
+		// TODO awful hack bad type conversion i'm sorry
+		entry, err := a.Parent.(*fileConfig).FindEntryPrime("aliases")
+
+		var notFound *NotFoundError
+
+		if err != nil && !errors.As(err, &notFound) {
+			return err
 		}
 		valueNode := &yaml.Node{
 			Kind:  yaml.MappingNode,
@@ -47,7 +43,29 @@ func (a *AliasConfig) Add(alias, expansion string) error {
 		}
 
 		a.Root = valueNode
-		a.Parent.Root().Content = append(a.Parent.Root().Content, keyNode, valueNode)
+		if errors.As(err, &notFound) {
+			// No aliases: key; just append new aliases key and empty map to end
+			keyNode := &yaml.Node{
+				Kind:  yaml.ScalarNode,
+				Value: "aliases",
+			}
+			a.Parent.Root().Content = append(a.Parent.Root().Content, keyNode, valueNode)
+		} else {
+			// Empty aliases; inject new value node after existing aliases key
+			newContent := []*yaml.Node{}
+			for i := 0; i < len(a.Parent.Root().Content); i++ {
+				node := a.Parent.Root().Content[i]
+				if i == entry.Index {
+				}
+				if i == entry.Index {
+					newContent = append(newContent, entry.KeyNode, valueNode)
+					i++
+				} else {
+					newContent = append(newContent, a.Parent.Root().Content[i])
+				}
+			}
+			a.Parent.Root().Content = newContent
+		}
 	}
 
 	err := a.SetStringValue(alias, expansion)
diff --git a/internal/config/config_type.go b/internal/config/config_type.go
index ddcd13401..ca8d23a29 100644
--- a/internal/config/config_type.go
+++ b/internal/config/config_type.go
@@ -73,6 +73,32 @@ func (cm *ConfigMap) SetStringValue(key, value string) error {
 	return nil
 }
 
+type ConfigEntry struct {
+	KeyNode   *yaml.Node
+	ValueNode *yaml.Node
+	Index     int
+}
+
+func (cm *ConfigMap) FindEntryPrime(key string) (ce *ConfigEntry, err error) {
+	err = nil
+
+	ce = &ConfigEntry{}
+
+	topLevelKeys := cm.Root.Content
+	for i, v := range topLevelKeys {
+		if v.Value == key {
+			ce.KeyNode = v
+			ce.Index = i
+			if i+1 < len(topLevelKeys) {
+				ce.ValueNode = topLevelKeys[i+1]
+			}
+			return
+		}
+	}
+
+	return ce, &NotFoundError{errors.New("not found")}
+}
+
 func (cm *ConfigMap) FindEntry(key string) (keyNode, valueNode *yaml.Node, err error) {
 	err = nil
 
@@ -195,7 +221,9 @@ func (c *fileConfig) Aliases() (*AliasConfig, error) {
 
 func (c *fileConfig) parseAliasConfig(aliasesEntry *yaml.Node) (*AliasConfig, error) {
 	if aliasesEntry.Kind != yaml.MappingNode {
-		return nil, errors.New("expected aliases to be a map")
+		return &AliasConfig{
+			Parent: c,
+		}, nil
 	}
 
 	aliasConfig := AliasConfig{

From 37761c97fa27c07d233a5e5250be519c44806e3e Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 20:57:59 -0500
Subject: [PATCH 15/26] partial cleanup

---
 command/alias_test.go           | 23 +++++++++++++++++++++++
 internal/config/alias_config.go |  5 +----
 internal/config/config_type.go  | 33 ++++++++++-----------------------
 3 files changed, 34 insertions(+), 27 deletions(-)

diff --git a/command/alias_test.go b/command/alias_test.go
index 1b0fc35ff..ad8ca33d6 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -23,6 +23,29 @@ func TestAliasSet_gh_command(t *testing.T) {
 	eq(t, err.Error(), `could not create alias: "pr" is already a gh command`)
 }
 
+func TestAliasSet_empty_aliases(t *testing.T) {
+	cfg := `---
+aliases:
+hosts:
+  github.com:
+    user: OWNER
+    oauth_token: token123
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	buf := bytes.NewBufferString("")
+	defer config.StubWriteConfig(buf)()
+	output, err := RunCommand("alias set co pr checkout -Rcool/repo")
+
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "TODO")
+
+	// TODO
+}
+
 func TestAliasSet_existing_alias(t *testing.T) {
 	cfg := `---
 hosts:
diff --git a/internal/config/alias_config.go b/internal/config/alias_config.go
index 59e6a24c5..bbeaba75c 100644
--- a/internal/config/alias_config.go
+++ b/internal/config/alias_config.go
@@ -30,7 +30,7 @@ func (a *AliasConfig) Get(alias string) string {
 func (a *AliasConfig) Add(alias, expansion string) error {
 	if a.Root == nil {
 		// TODO awful hack bad type conversion i'm sorry
-		entry, err := a.Parent.(*fileConfig).FindEntryPrime("aliases")
+		entry, err := a.Parent.(*fileConfig).FindEntry("aliases")
 
 		var notFound *NotFoundError
 
@@ -54,9 +54,6 @@ func (a *AliasConfig) Add(alias, expansion string) error {
 			// Empty aliases; inject new value node after existing aliases key
 			newContent := []*yaml.Node{}
 			for i := 0; i < len(a.Parent.Root().Content); i++ {
-				node := a.Parent.Root().Content[i]
-				if i == entry.Index {
-				}
 				if i == entry.Index {
 					newContent = append(newContent, entry.KeyNode, valueNode)
 					i++
diff --git a/internal/config/config_type.go b/internal/config/config_type.go
index ca8d23a29..55bba7d5b 100644
--- a/internal/config/config_type.go
+++ b/internal/config/config_type.go
@@ -41,18 +41,20 @@ func (cm *ConfigMap) Empty() bool {
 }
 
 func (cm *ConfigMap) GetStringValue(key string) (string, error) {
-	_, valueNode, err := cm.FindEntry(key)
+	entry, err := cm.FindEntry(key)
 	if err != nil {
 		return "", err
 	}
-	return valueNode.Value, nil
+	return entry.ValueNode.Value, nil
 }
 
 func (cm *ConfigMap) SetStringValue(key, value string) error {
-	_, valueNode, err := cm.FindEntry(key)
+	entry, err := cm.FindEntry(key)
 
 	var notFound *NotFoundError
 
+	valueNode := entry.ValueNode
+
 	if err != nil && errors.As(err, &notFound) {
 		keyNode := &yaml.Node{
 			Kind:  yaml.ScalarNode,
@@ -79,7 +81,7 @@ type ConfigEntry struct {
 	Index     int
 }
 
-func (cm *ConfigMap) FindEntryPrime(key string) (ce *ConfigEntry, err error) {
+func (cm *ConfigMap) FindEntry(key string) (ce *ConfigEntry, err error) {
 	err = nil
 
 	ce = &ConfigEntry{}
@@ -99,21 +101,6 @@ func (cm *ConfigMap) FindEntryPrime(key string) (ce *ConfigEntry, err error) {
 	return ce, &NotFoundError{errors.New("not found")}
 }
 
-func (cm *ConfigMap) FindEntry(key string) (keyNode, valueNode *yaml.Node, err error) {
-	err = nil
-
-	topLevelKeys := cm.Root.Content
-	for i, v := range topLevelKeys {
-		if v.Value == key && i+1 < len(topLevelKeys) {
-			keyNode = v
-			valueNode = topLevelKeys[i+1]
-			return
-		}
-	}
-
-	return nil, nil, &NotFoundError{errors.New("not found")}
-}
-
 func NewConfig(root *yaml.Node) Config {
 	return &fileConfig{
 		ConfigMap:    ConfigMap{Root: root.Content[0]},
@@ -204,14 +191,14 @@ func (c *fileConfig) Write() error {
 }
 
 func (c *fileConfig) Aliases() (*AliasConfig, error) {
-	_, aliasesEntry, err := c.FindEntry("aliases")
+	entry, err := c.FindEntry("aliases")
 	var nfe *NotFoundError
 	if err != nil && errors.As(err, &nfe) {
 		// TODO does this make sense at all? want to simulate existing but empty key.
 		return &AliasConfig{Parent: c}, nil
 	}
 
-	aliasConfig, err := c.parseAliasConfig(aliasesEntry)
+	aliasConfig, err := c.parseAliasConfig(entry.ValueNode)
 	if err != nil {
 		return nil, err
 	}
@@ -239,12 +226,12 @@ func (c *fileConfig) Hosts() ([]*HostConfig, error) {
 		return c.hosts, nil
 	}
 
-	_, hostsEntry, err := c.FindEntry("hosts")
+	entry, err := c.FindEntry("hosts")
 	if err != nil {
 		return nil, fmt.Errorf("could not find hosts config: %w", err)
 	}
 
-	hostConfigs, err := c.parseHosts(hostsEntry)
+	hostConfigs, err := c.parseHosts(entry.ValueNode)
 	if err != nil {
 		return nil, fmt.Errorf("could not parse hosts config: %w", err)
 	}

From 3b4b244ab06e1e204e4ba5142bfb22c7f3ff0d03 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 23:17:46 -0500
Subject: [PATCH 16/26] test for empty aliases key

---
 command/alias_test.go | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/command/alias_test.go b/command/alias_test.go
index ad8ca33d6..8cb618b3b 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -35,15 +35,22 @@ hosts:
 
 	buf := bytes.NewBufferString("")
 	defer config.StubWriteConfig(buf)()
-	output, err := RunCommand("alias set co pr checkout -Rcool/repo")
+	output, err := RunCommand("alias set co pr checkout")
 
 	if err != nil {
 		t.Fatalf("unexpected error: %s", err)
 	}
 
-	test.ExpectLines(t, output.String(), "TODO")
+	test.ExpectLines(t, output.String(), "Added alias")
 
-	// TODO
+	expected := `aliases:
+    co: pr checkout
+hosts:
+    github.com:
+        user: OWNER
+        oauth_token: token123
+`
+	eq(t, buf.String(), expected)
 }
 
 func TestAliasSet_existing_alias(t *testing.T) {

From 52a02a7a4bd6144a8d1089e49957b3e8bfbb57fc Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 23:23:45 -0500
Subject: [PATCH 17/26] todo

---
 command/alias.go                | 2 +-
 internal/config/alias_config.go | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/command/alias.go b/command/alias.go
index 7cec65650..15295c160 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -11,7 +11,7 @@ import (
 
 // TODO
 // - [ ] DEBUG support
-// - [ ] blank aliases stanza
+// - [x] blank aliases stanza
 // - [x] give our commands precedence
 // - [x] prevent overriding existing gh command
 // - [x] allow overwriting alias
diff --git a/internal/config/alias_config.go b/internal/config/alias_config.go
index bbeaba75c..23499f229 100644
--- a/internal/config/alias_config.go
+++ b/internal/config/alias_config.go
@@ -29,7 +29,8 @@ func (a *AliasConfig) Get(alias string) string {
 
 func (a *AliasConfig) Add(alias, expansion string) error {
 	if a.Root == nil {
-		// TODO awful hack bad type conversion i'm sorry
+		// TODO awful hack bad type conversion i'm sorry. this is to support an empty aliases key and
+		// ought to be generalized into ConfigMap or fileConfig (via Config interface) itself.
 		entry, err := a.Parent.(*fileConfig).FindEntry("aliases")
 
 		var notFound *NotFoundError

From 8773a997ee4b17d9bb7cfb3f44f92dbce531ec01 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 23:28:26 -0500
Subject: [PATCH 18/26] support DEBUG when expanding aliases

---
 cmd/gh/main.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/cmd/gh/main.go b/cmd/gh/main.go
index b4ddcb302..6391842d4 100644
--- a/cmd/gh/main.go
+++ b/cmd/gh/main.go
@@ -39,11 +39,15 @@ func main() {
 
 	cmd, _, err := command.RootCmd.Traverse(expandedArgs)
 	if err != nil || cmd == command.RootCmd {
+		originalArgs := expandedArgs
 		expandedArgs, err = command.ExpandAlias(os.Args)
 		if err != nil {
 			fmt.Fprintf(stderr, "failed to process aliases:  %s\n", err)
 			os.Exit(2)
 		}
+		if hasDebug {
+			fmt.Fprintf(stderr, "%v -> %v\n", originalArgs, expandedArgs)
+		}
 	}
 
 	command.RootCmd.SetArgs(expandedArgs)

From 4804c8bc77e4db528d2b9887fc6daf8f942ea41e Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 27 May 2020 23:28:41 -0500
Subject: [PATCH 19/26] odot

---
 command/alias.go | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/command/alias.go b/command/alias.go
index 15295c160..7834ea597 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -9,15 +9,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// TODO
-// - [ ] DEBUG support
-// - [x] blank aliases stanza
-// - [x] give our commands precedence
-// - [x] prevent overriding existing gh command
-// - [x] allow overwriting alias
-// - [x] forward extra arguments
-// - [x] allow duplication of placeholder
-
 func init() {
 	RootCmd.AddCommand(aliasCmd)
 	aliasCmd.AddCommand(aliasSetCmd)

From 54183f4c6e30c70fa34715982c505d3e143e5eda Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Mon, 1 Jun 2020 16:24:58 -0500
Subject: [PATCH 20/26] remove a gross type hack

---
 internal/config/alias_config.go | 41 ----------------------
 internal/config/config_type.go  | 61 +++++++++++++++++++++++----------
 2 files changed, 42 insertions(+), 60 deletions(-)

diff --git a/internal/config/alias_config.go b/internal/config/alias_config.go
index 23499f229..434b74f20 100644
--- a/internal/config/alias_config.go
+++ b/internal/config/alias_config.go
@@ -1,10 +1,7 @@
 package config
 
 import (
-	"errors"
 	"fmt"
-
-	"gopkg.in/yaml.v3"
 )
 
 type AliasConfig struct {
@@ -28,44 +25,6 @@ func (a *AliasConfig) Get(alias string) string {
 }
 
 func (a *AliasConfig) Add(alias, expansion string) error {
-	if a.Root == nil {
-		// TODO awful hack bad type conversion i'm sorry. this is to support an empty aliases key and
-		// ought to be generalized into ConfigMap or fileConfig (via Config interface) itself.
-		entry, err := a.Parent.(*fileConfig).FindEntry("aliases")
-
-		var notFound *NotFoundError
-
-		if err != nil && !errors.As(err, &notFound) {
-			return err
-		}
-		valueNode := &yaml.Node{
-			Kind:  yaml.MappingNode,
-			Value: "",
-		}
-
-		a.Root = valueNode
-		if errors.As(err, &notFound) {
-			// No aliases: key; just append new aliases key and empty map to end
-			keyNode := &yaml.Node{
-				Kind:  yaml.ScalarNode,
-				Value: "aliases",
-			}
-			a.Parent.Root().Content = append(a.Parent.Root().Content, keyNode, valueNode)
-		} else {
-			// Empty aliases; inject new value node after existing aliases key
-			newContent := []*yaml.Node{}
-			for i := 0; i < len(a.Parent.Root().Content); i++ {
-				if i == entry.Index {
-					newContent = append(newContent, entry.KeyNode, valueNode)
-					i++
-				} else {
-					newContent = append(newContent, a.Parent.Root().Content[i])
-				}
-			}
-			a.Parent.Root().Content = newContent
-		}
-	}
-
 	err := a.SetStringValue(alias, expansion)
 	if err != nil {
 		return fmt.Errorf("failed to update config: %w", err)
diff --git a/internal/config/config_type.go b/internal/config/config_type.go
index 55bba7d5b..39765bd8a 100644
--- a/internal/config/config_type.go
+++ b/internal/config/config_type.go
@@ -191,34 +191,57 @@ func (c *fileConfig) Write() error {
 }
 
 func (c *fileConfig) Aliases() (*AliasConfig, error) {
+	// The complexity here is for dealing with either a missing or empty aliases key. It's something
+	// we'll likely want for other config sections at some point.
 	entry, err := c.FindEntry("aliases")
 	var nfe *NotFoundError
-	if err != nil && errors.As(err, &nfe) {
-		// TODO does this make sense at all? want to simulate existing but empty key.
-		return &AliasConfig{Parent: c}, nil
-	}
-
-	aliasConfig, err := c.parseAliasConfig(entry.ValueNode)
-	if err != nil {
+	notFound := errors.As(err, &nfe)
+	if err != nil && !notFound {
 		return nil, err
 	}
 
-	return aliasConfig, nil
-}
+	toInsert := []*yaml.Node{}
 
-func (c *fileConfig) parseAliasConfig(aliasesEntry *yaml.Node) (*AliasConfig, error) {
-	if aliasesEntry.Kind != yaml.MappingNode {
-		return &AliasConfig{
-			Parent: c,
-		}, nil
+	keyNode := entry.KeyNode
+	valueNode := entry.ValueNode
+
+	if keyNode == nil {
+		keyNode = &yaml.Node{
+			Kind:  yaml.ScalarNode,
+			Value: "aliases",
+		}
+		toInsert = append(toInsert, keyNode)
 	}
 
-	aliasConfig := AliasConfig{
+	if valueNode == nil || valueNode.Kind != yaml.MappingNode {
+		valueNode = &yaml.Node{
+			Kind:  yaml.MappingNode,
+			Value: "",
+		}
+		toInsert = append(toInsert, valueNode)
+	}
+
+	if len(toInsert) > 0 {
+		newContent := []*yaml.Node{}
+		if notFound {
+			newContent = append(c.Root().Content, keyNode, valueNode)
+		} else {
+			for i := 0; i < len(c.Root().Content); i++ {
+				if i == entry.Index {
+					newContent = append(newContent, keyNode, valueNode)
+					i++
+				} else {
+					newContent = append(newContent, c.Root().Content[i])
+				}
+			}
+		}
+		c.Root().Content = newContent
+	}
+
+	return &AliasConfig{
 		Parent:    c,
-		ConfigMap: ConfigMap{Root: aliasesEntry},
-	}
-
-	return &aliasConfig, nil
+		ConfigMap: ConfigMap{Root: valueNode},
+	}, nil
 }
 
 func (c *fileConfig) Hosts() ([]*HostConfig, error) {

From 51196265cc36148e110dc31cc32cdd3d32260d05 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 2 Jun 2020 13:48:19 -0500
Subject: [PATCH 21/26] update note

---
 command/alias.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/command/alias.go b/command/alias.go
index 7834ea597..63e122bf4 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -21,10 +21,10 @@ var aliasCmd = &cobra.Command{
 
 var aliasSetCmd = &cobra.Command{
 	Use: "set <alias> <expansion>",
-	// TODO HACK: even when inside of a single-quoted string, cobra was noticing and parsing any flags
+	// NB: Even when inside of a single-quoted string, cobra was noticing and parsing any flags
 	// used in an alias expansion string argument. Since this command needs no flags, I disabled their
-	// parsing. If we ever want to add flags to alias set we'll have to figure this out. I haven't
-	// checked if this is fixed in a new cobra.
+	// parsing. If we ever want to add flags to alias set we'll have to figure this out. I tested on
+	// linux in various shells against cobra 1.0; others on macos did /not/ see the same behavior.
 	DisableFlagParsing: true,
 	Short:              "Create a shortcut for a gh command",
 	Long: `

From 1b844d2cc0011bfae76bcc24c9e92e760901f9d5 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 2 Jun 2020 13:50:19 -0500
Subject: [PATCH 22/26] not needed in public interface

---
 internal/config/config_type.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/internal/config/config_type.go b/internal/config/config_type.go
index 39765bd8a..8d2c77b9b 100644
--- a/internal/config/config_type.go
+++ b/internal/config/config_type.go
@@ -12,7 +12,6 @@ const defaultGitProtocol = "https"
 
 // This interface describes interacting with some persistent configuration for gh.
 type Config interface {
-	Root() *yaml.Node
 	Hosts() ([]*HostConfig, error)
 	Get(string, string) (string, error)
 	Set(string, string, string) error

From c960e568f8f05f7bfc8e53b28cf2438e53a5c905 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 2 Jun 2020 13:52:42 -0500
Subject: [PATCH 23/26] w h i t e s p a c e

---
 command/alias.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/command/alias.go b/command/alias.go
index 63e122bf4..1e8470fea 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -27,8 +27,7 @@ var aliasSetCmd = &cobra.Command{
 	// linux in various shells against cobra 1.0; others on macos did /not/ see the same behavior.
 	DisableFlagParsing: true,
 	Short:              "Create a shortcut for a gh command",
-	Long: `
-This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.`,
+	Long: `This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.`,
 	Example: `
 	gh alias set pv 'pr view'
 	# gh pv -w 123 -> gh pr view -w 123.

From a3a6f2502441bbab2013fb86ad969d8ba582e0f4 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 2 Jun 2020 16:07:24 -0500
Subject: [PATCH 24/26] do not use string concatenation for extra args

---
 command/alias_test.go |  1 +
 command/root.go       | 13 +++++++++++--
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/command/alias_test.go b/command/alias_test.go
index 8cb618b3b..d5276e461 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -200,6 +200,7 @@ aliases:
 		{"gh ia vilmibm", []string{"issue", "list", `--author=vilmibm`, `--assignee=vilmibm`}, ""},
 		{"gh ia $coolmoney$", []string{"issue", "list", `--author=$coolmoney$`, `--assignee=$coolmoney$`}, ""},
 		{"gh pr status", []string{"pr", "status"}, ""},
+		{"gh il vilmibm epic -R vilmibm/testing", []string{"issue", "list", "--author=vilmibm", "--label=epic", "-R", "vilmibm/testing"}, ""},
 		{"gh dne", []string{"dne"}, ""},
 		{"gh", []string{}, ""},
 		{"", []string{}, ""},
diff --git a/command/root.go b/command/root.go
index 1e09651d2..6c1f39c66 100644
--- a/command/root.go
+++ b/command/root.go
@@ -482,10 +482,11 @@ func ExpandAlias(args []string) ([]string, error) {
 	}
 
 	if aliases.Exists(args[1]) {
+		extraArgs  := []string{}
 		expansion := aliases.Get(args[1])
 		for i, a := range args[2:] {
 			if !strings.Contains(expansion, "$") {
-				expansion += " " + a
+				extraArgs = append(extraArgs, a)
 			} else {
 				expansion = strings.ReplaceAll(expansion, fmt.Sprintf("$%d", i+1), a)
 			}
@@ -494,7 +495,15 @@ func ExpandAlias(args []string) ([]string, error) {
 		if lingeringRE.MatchString(expansion) {
 			return empty, fmt.Errorf("not enough arguments for alias: %s", expansion)
 		}
-		return shlex.Split(expansion)
+
+		newArgs, err := shlex.Split(expansion)
+		if err != nil {
+			return nil, err
+		}
+
+		newArgs = append(newArgs, extraArgs...)
+
+		return newArgs, nil
 	}
 
 	return args[1:], nil

From 6defbbf73f101dc623ae37f49a14f1c6b88aa9ed Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 3 Jun 2020 15:00:49 -0500
Subject: [PATCH 25/26] finally properly handle quoted arguments to alias set

---
 command/alias.go      | 36 +++++++++++++++++++++++-------------
 command/alias_test.go | 21 +++++++++++++++++++--
 2 files changed, 42 insertions(+), 15 deletions(-)

diff --git a/command/alias.go b/command/alias.go
index 1e8470fea..839c8047e 100644
--- a/command/alias.go
+++ b/command/alias.go
@@ -27,7 +27,7 @@ var aliasSetCmd = &cobra.Command{
 	// linux in various shells against cobra 1.0; others on macos did /not/ see the same behavior.
 	DisableFlagParsing: true,
 	Short:              "Create a shortcut for a gh command",
-	Long: `This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.`,
+	Long:               `This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.`,
 	Example: `
 	gh alias set pv 'pr view'
 	# gh pv -w 123 -> gh pr view -w 123.
@@ -57,15 +57,17 @@ func aliasSet(cmd *cobra.Command, args []string) error {
 	alias := args[0]
 	expansion := processArgs(args[1:])
 
-	out := colorableOut(cmd)
-	fmt.Fprintf(out, "- Adding alias for %s: %s\n", utils.Bold(alias), utils.Bold(expansion))
+	expansionStr := strings.Join(expansion, " ")
 
-	if validCommand(alias) {
+	out := colorableOut(cmd)
+	fmt.Fprintf(out, "- Adding alias for %s: %s\n", utils.Bold(alias), utils.Bold(expansionStr))
+
+	if validCommand([]string{alias}) {
 		return fmt.Errorf("could not create alias: %q is already a gh command", alias)
 	}
 
 	if !validCommand(expansion) {
-		return fmt.Errorf("could not create alias: %s does not correspond to a gh command", utils.Bold(expansion))
+		return fmt.Errorf("could not create alias: %s does not correspond to a gh command", utils.Bold(expansionStr))
 	}
 
 	successMsg := fmt.Sprintf("%s Added alias.", utils.Green("✓"))
@@ -75,11 +77,11 @@ func aliasSet(cmd *cobra.Command, args []string) error {
 			utils.Green("✓"),
 			utils.Bold(alias),
 			utils.Bold(aliasCfg.Get(alias)),
-			utils.Bold(expansion),
+			utils.Bold(expansionStr),
 		)
 	}
 
-	err = aliasCfg.Add(alias, expansion)
+	err = aliasCfg.Add(alias, expansionStr)
 	if err != nil {
 		return fmt.Errorf("could not create alias: %s", err)
 	}
@@ -89,16 +91,24 @@ func aliasSet(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
-func validCommand(expansion string) bool {
-	split, _ := shlex.Split(expansion)
-	cmd, _, err := RootCmd.Traverse(split)
+func validCommand(expansion []string) bool {
+	cmd, _, err := RootCmd.Traverse(expansion)
 	return err == nil && cmd != RootCmd
 }
 
-func processArgs(args []string) string {
+func processArgs(args []string) []string {
 	if len(args) == 1 {
-		return args[0]
+		split, _ := shlex.Split(args[0])
+		return split
 	}
 
-	return strings.Join(args, " ")
+	newArgs := []string{}
+	for _, a := range args {
+		if !strings.HasPrefix(a, "-") && strings.Contains(a, " ") {
+			a = fmt.Sprintf("%q", a)
+		}
+		newArgs = append(newArgs, a)
+	}
+
+	return newArgs
 }
diff --git a/command/alias_test.go b/command/alias_test.go
index d5276e461..09e0c7bc5 100644
--- a/command/alias_test.go
+++ b/command/alias_test.go
@@ -75,6 +75,23 @@ aliases:
 	test.ExpectLines(t, output.String(), "Changed alias co from pr checkout to pr checkout -Rcool/repo")
 }
 
+func TestAliasSet_space_args(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+
+	buf := bytes.NewBufferString("")
+	defer config.StubWriteConfig(buf)()
+
+	output, err := RunCommand(`alias set il issue list -l 'cool story'`)
+
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), `Adding alias for il: issue list -l "cool story"`)
+
+	test.ExpectLines(t, buf.String(), `il: issue list -l "cool story"`)
+}
+
 func TestAliasSet_arg_processing(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "trunk")
 	cases := []struct {
@@ -93,8 +110,8 @@ func TestAliasSet_arg_processing(t *testing.T) {
 			`iy: issue list --author=\$1 --label=\$2`},
 
 		{`alias set ii 'issue list --author="$1" --label="$2"'`,
-			`- Adding alias for ii: issue list --author="\$1" --label="\$2"`,
-			`ii: issue list --author="\$1" --label="\$2"`},
+			`- Adding alias for ii: issue list --author=\$1 --label=\$2`,
+			`ii: issue list --author=\$1 --label=\$2`},
 
 		{`alias set ix issue list --author='$1' --label='$2'`,
 			`- Adding alias for ix: issue list --author=\$1 --label=\$2`,

From 7014145a81107c43f1c2d24af2e24bbfe8b55984 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 3 Jun 2020 15:05:44 -0500
Subject: [PATCH 26/26] linter appeasement

---
 command/root.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/command/root.go b/command/root.go
index 6c1f39c66..0055a2716 100644
--- a/command/root.go
+++ b/command/root.go
@@ -482,7 +482,7 @@ func ExpandAlias(args []string) ([]string, error) {
 	}
 
 	if aliases.Exists(args[1]) {
-		extraArgs  := []string{}
+		extraArgs := []string{}
 		expansion := aliases.Get(args[1])
 		for i, a := range args[2:] {
 			if !strings.Contains(expansion, "$") {