feature: add support for installing completions at package build time

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [Unreleased]
 
+* Add `aws-sso-cli completion --source` flag to generate completion script and
+  print to stdout. #779
+
 ## [v1.14.3] - 2024-01-15
 
 ### Bugs

cmd/aws-sso/completions_cmd.go

@@ -27,6 +27,7 @@ import (
 )
 
 type CompleteCmd struct {
+	Source         bool   `kong:"help='Print out completions for sourcing in the active shell',xor='action'"`
 	Install        bool   `kong:"short='I',help='Install shell completions',xor='action'"`
 	Uninstall      bool   `kong:"short='U',help='Uninstall shell completions',xor='action'"`
 	UninstallPre19 bool   `kong:"help='Uninstall pre-v1.9 shell completion integration',xor='action',xor='shell,script'"`
@@ -37,7 +38,10 @@ type CompleteCmd struct {
 func (cc *CompleteCmd) Run(ctx *RunContext) error {
 	var err error
 
-	if ctx.Cli.Completions.Install {
+	if ctx.Cli.Completions.Source {
+		err = helper.NewSourceHelper(os.Executable, os.Stdout).
+			Generate(ctx.Cli.Completions.Shell)
+	} else if ctx.Cli.Completions.Install {
 		// install the current auto-complete helper
 		err = helper.InstallHelper(ctx.Cli.Completions.Shell, ctx.Cli.Completions.ShellScript)
 	} else if ctx.Cli.Completions.Uninstall {

internal/helper/helper.go

@@ -19,8 +19,10 @@
  */
 
 import (
+	"bytes"
 	"embed"
 	"fmt"
+	"io"
 	"os"
 	"path"
 
@@ -88,6 +90,33 @@
 	return bytes, path, nil
 }
 
+type SourceHelper struct {
+	getExe func() (string, error)
+	output io.Writer
+}
+
+func NewSourceHelper(getExe func() (string, error), output io.Writer) *SourceHelper {
+	return &SourceHelper{
+		getExe: os.Executable,
+		output: os.Stdout,
+	}
+}
+
+// SourceHelper can be used to generate the completions script for immediate sourcing in the active shell
+func (h SourceHelper) Generate(shell string) error {
+	c, _, err := getScript(shell)
+	if err != nil {
+		return err
+	}
+
+	execPath, err := h.getExe()
+	if err != nil {
+		return err
+	}
+
+	return printConfig(c, execPath, h.output)
+}
+
 // InstallHelper installs any helper code into our shell startup script(s)
 func InstallHelper(shell string, path string) error {
 	c, defaultPath, err := getScript(shell)
@@ -119,6 +148,22 @@
 	return err
 }
 
+func printConfig(contents []byte, execPath string, output io.Writer) error {
+	var err error
+	var source []byte
+
+	args := map[string]string{
+		"Executable": execPath,
+	}
+
+	if source, err = utils.GenerateSource(string(contents), args); err != nil {
+		return err
+	}
+
+	_, err = io.Copy(output, bytes.NewReader(source))
+	return err
+}
+
 // installConfigFile adds our blob to the given file
 func installConfigFile(path string, contents []byte) error {
 	var err error

internal/helper/helper_test.go

@@ -0,0 +1,70 @@
+package helper
+
+import (
+	"bytes"
+	"errors"
+	"testing"
+	"unicode"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestSourceHelper(t *testing.T) {
+	testcases := []struct {
+		shell          string
+		expectedError  error
+		expectedOutput []byte
+	}{
+		{
+			shell: "bash",
+			expectedOutput: []byte(`
+complete -F __aws_sso_profile_complete aws-sso-profile
+complete -C /bin/aws-sso-cli aws-sso
+`),
+		},
+		{
+			shell: "zsh",
+			expectedOutput: []byte(`
+compdef __aws_sso_profile_complete aws-sso-profile
+complete -C /bin/aws-sso-cli aws-sso
+`),
+		},
+		{
+			shell: "fish",
+			expectedOutput: []byte(`
+function __complete_aws-sso
+    set -lx COMP_LINE (commandline -cp)
+    test -z (commandline -ct)
+    and set COMP_LINE "$COMP_LINE "
+    /bin/aws-sso-cli
+end
+complete -f -c aws-sso -a "(__complete_aws-sso)"
+`),
+		},
+		{
+			shell:         "nushell",
+			expectedError: errors.New("unsupported shell: nushell"),
+		},
+	}
+
+	for _, tc := range testcases {
+		tc := tc
+
+		t.Run(tc.shell, func(t *testing.T) {
+			t.Parallel()
+			var (
+				output = bytes.NewBuffer(nil)
+				h      = &SourceHelper{
+					getExe: func() (string, error) {
+						return "/bin/aws-sso-cli", nil
+					},
+					output: output,
+				}
+			)
+
+			err := h.Generate(tc.shell)
+			require.Equal(t, tc.expectedError, err)
+			require.Contains(t, output.String(), string(bytes.TrimLeftFunc(tc.expectedOutput, unicode.IsSpace)))
+		})
+	}
+}

internal/utils/fileedit.go

@@ -47,6 +47,21 @@
 
 var prompt = askUser
 
+func GenerateSource(fileTemplate string, vars interface{}) ([]byte, error) {
+	templ, err := template.New("template").Parse(fileTemplate)
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	err = templ.Execute(&buf, vars)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
 func NewFileEdit(fileTemplate string, vars interface{}) (*FileEdit, error) {
 	var t string
 

internal/utils/fileedit_test.go

@@ -27,6 +27,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/sirupsen/logrus/hooks/test"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestFileEdit(t *testing.T) {
@@ -187,3 +188,43 @@ func TestPrompter(t *testing.T) {
 	assert.Equal(t, []byte(
 		fmt.Sprintf(FILE_TEMPLATE, CONFIG_PREFIX, "foo", CONFIG_SUFFIX)), fBytes)
 }
+
+func TestGenerateSource(t *testing.T) {
+	testcases := []struct {
+		name        string
+		tpl         string
+		expectedErr error
+		expected    string
+	}{
+		{
+			name: "template with no variables",
+			tpl: `
+I'm a text template if you can believe that
+`,
+			expected: `
+I'm a text template if you can believe that
+`,
+		},
+		{
+			name: "template",
+			tpl: `
+{{.Name}}
+`,
+			expected: `
+template
+`,
+		},
+	}
+
+	for _, tc := range testcases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			output, err := GenerateSource(tc.tpl, map[string]interface{}{
+				"Name": tc.name,
+			})
+			require.Equal(t, tc.expectedErr, err)
+			require.Equal(t, tc.expected, string(output))
+		})
+	}
+}