feat: Add plugin listing to "kn --help"

cmd/kn/main.go

@@ -67,7 +67,7 @@ func run(args []string) error {
 	}
 
 	// Create kn root command and all sub-commands
-	rootCmd, err := root.NewRootCommand()
+	rootCmd, err := root.NewRootCommand(pluginManager.HelpTemplateFuncs())
 	if err != nil {
 		return err
 	}

cmd/kn/main_test.go

@@ -158,7 +158,7 @@ func TestUnknownCommands(t *testing.T) {
 	}
 	for _, d := range data {
 		args := append([]string{"kn"}, d.givenCmdArgs...)
-		rootCmd, err := root.NewRootCommand()
+		rootCmd, err := root.NewRootCommand(nil)
 		os.Args = args
 		assert.NilError(t, err)
 		err = validateRootCommand(rootCmd)

hack/build.sh

@@ -152,7 +152,7 @@ go_test() {
 
   echo "🧪 ${X}Test"
   set +e
-  go test -v ./pkg/... >$test_output 2>&1
+  go test -v .cmd/... ./pkg/... >$test_output 2>&1
   local err=$?
   if [ $err -ne 0 ]; then
     echo "🔥 ${red}Failure${reset}"

hack/generate-docs.go

@@ -27,7 +27,7 @@ import (
 )
 
 func main() {
-	rootCmd, err := root.NewRootCommand()
+	rootCmd, err := root.NewRootCommand(nil)
 	if err != nil {
 		log.Panicf("can not create root command: %v", err)
 	}

pkg/kn/plugin/manager.go

@@ -23,9 +23,11 @@ import (
 	"runtime"
 	"sort"
 	"strings"
+	"text/template"
 
 	homedir "github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
 )
 
 // Interface describing a plugin
@@ -108,6 +110,12 @@ func (manager *Manager) FindPlugin(parts []string) (Plugin, error) {
 
 // ListPlugins lists all plugins that can be found in the plugin directory or in the path (if configured)
 func (manager *Manager) ListPlugins() (PluginList, error) {
+	return manager.ListPluginsForCommandGroup(nil)
+}
+
+// ListPluginsForCommandGroup lists all plugins that can be found in the plugin directory or in the path (if configured),
+// and which fits to a command group
+func (manager *Manager) ListPluginsForCommandGroup(commandGroupParts []string) (PluginList, error) {
 	var plugins []Plugin
 
 	dirs, err := manager.pluginLookupDirectories()
@@ -135,6 +143,11 @@ func (manager *Manager) ListPlugins() (PluginList, error) {
 				continue
 			}
 
+			// Check if plugin matches a command group
+			if !isPartOfCommandGroup(commandGroupParts, f.Name()) {
+				continue
+			}
+
 			// Ignore all plugins that are shadowed
 			if _, ok := hasSeen[name]; !ok {
 				plugins = append(plugins, &plugin{
@@ -146,11 +159,29 @@ func (manager *Manager) ListPlugins() (PluginList, error) {
 			}
 		}
 	}
+
 	// Sort according to name
 	sort.Sort(PluginList(plugins))
 	return plugins, nil
 }
 
+func isPartOfCommandGroup(commandGroupParts []string, name string) bool {
+	if commandGroupParts == nil {
+		return true
+	}
+
+	commandParts := extractPluginCommandFromFileName(name)
+	if len(commandParts) != len(commandGroupParts)+1 {
+		return false
+	}
+	for i := range commandGroupParts {
+		if commandParts[i] != commandGroupParts[i] {
+			return false
+		}
+	}
+	return true
+}
+
 // PluginsDir returns the configured directory holding plugins
 func (manager *Manager) PluginsDir() string {
 	return manager.pluginsDir
@@ -212,6 +243,49 @@ func (manager *Manager) pluginLookupDirectories() ([]string, error) {
 	return dirs, nil
 }
 
+// HelpTemplateFuncs returns a function map which can be used in templates for resolving
+// plugin related help messages
+func (manager *Manager) HelpTemplateFuncs() *template.FuncMap {
+	ret := template.FuncMap{
+		"listPlugins": manager.listPluginsHelpMessage(),
+	}
+
+	return &ret
+}
+
+// listPluginsHelpMessage returns a function which returns all plugins that are directly below the given
+// command as a properly formatted string
+func (manager *Manager) listPluginsHelpMessage() func(cmd *cobra.Command) string {
+	return func(cmd *cobra.Command) string {
+		if !cmd.HasSubCommands() {
+			return ""
+		}
+		list, err := manager.ListPluginsForCommandGroup(extractCommandGroup(cmd, []string{}))
+		if err != nil || len(list) == 0 {
+			// We don't show plugins if there is an error
+			return ""
+		}
+		var plugins []string
+		for _, pl := range list {
+			t := fmt.Sprintf("  %%-%ds %%s", cmd.NamePadding())
+			desc, _ := pl.Description()
+			command := (pl.CommandParts())[len(pl.CommandParts())-1]
+			help := fmt.Sprintf(t, command, desc)
+			plugins = append(plugins, help)
+		}
+		return strings.Join(plugins, "\n")
+	}
+}
+
+// extractCommandGroup constructs the command path as array of strings
+func extractCommandGroup(cmd *cobra.Command, parts []string) []string {
+	if cmd.HasParent() {
+		parts = extractCommandGroup(cmd.Parent(), parts)
+		parts = append(parts, cmd.Name())
+	}
+	return parts
+}
+
 // uniquePathsList deduplicates a given slice of strings without
 // sorting or otherwise altering its order in any way.
 func uniquePathsList(paths []string) []string {

pkg/kn/root/root.go

@@ -18,6 +18,7 @@ import (
 	"flag"
 	"fmt"
 	"strings"
+	"text/template"
 
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
@@ -41,7 +42,7 @@ import (
 )
 
 // NewRootCommand creates the default `kn` command with a default plugin handler
-func NewRootCommand() (*cobra.Command, error) {
+func NewRootCommand(helpFuncs *template.FuncMap) (*cobra.Command, error) {
 	p := &commands.KnParams{}
 	p.Initialize()
 
@@ -107,7 +108,7 @@ func NewRootCommand() (*cobra.Command, error) {
 	groups.AddTo(rootCmd)
 
 	// Initialize default `help` cmd early to prevent unknown command errors
-	groups.SetRootUsage(rootCmd)
+	groups.SetRootUsage(rootCmd, helpFuncs)
 
 	// Add the "options" commands for showing all global options
 	rootCmd.AddCommand(options.NewOptionsCommand())

pkg/kn/root/root_test.go

@@ -26,7 +26,7 @@ import (
 )
 
 func TestNewRootCommand(t *testing.T) {
-	rootCmd, err := NewRootCommand()
+	rootCmd, err := NewRootCommand(nil)
 	assert.NilError(t, err)
 	assert.Assert(t, rootCmd != nil)
 
@@ -51,13 +51,13 @@ func TestNewRootCommand(t *testing.T) {
 }
 
 func TestSubCommands(t *testing.T) {
-	rootCmd, err := NewRootCommand()
+	rootCmd, err := NewRootCommand(nil)
 	assert.NilError(t, err)
 	checkLeafCommand(t, "version", rootCmd)
 }
 
 func TestCommandGroup(t *testing.T) {
-	rootCmd, err := NewRootCommand()
+	rootCmd, err := NewRootCommand(nil)
 	assert.NilError(t, err)
 	commandGroups := []string{
 		"service", "revision", "plugin", "source", "source apiserver",

pkg/templates/command_groups.go

@@ -15,6 +15,8 @@
 package templates
 
 import (
+	"text/template"
+
 	"github.com/spf13/cobra"
 )
 
@@ -40,11 +42,8 @@ func (g CommandGroups) AddTo(cmd *cobra.Command) {
 }
 
 // SetRootUsage sets our own help and usage function messages to the root command
-func (g CommandGroups) SetRootUsage(rootCmd *cobra.Command) {
-	engine := &templateEngine{
-		RootCmd:       rootCmd,
-		CommandGroups: g,
-	}
+func (g CommandGroups) SetRootUsage(rootCmd *cobra.Command, extraTemplateFunctions *template.FuncMap) {
+	engine := newTemplateEngine(rootCmd, g, extraTemplateFunctions)
 	setHelpFlagsToSubCommands(rootCmd)
 	rootCmd.SetUsageFunc(engine.usageFunc())
 	rootCmd.SetHelpFunc(engine.helpFunc())

pkg/templates/command_groups_test.go

@@ -17,6 +17,7 @@ package templates
 import (
 	"fmt"
 	"testing"
+	"text/template"
 
 	"github.com/spf13/cobra"
 	"gotest.tools/assert"
@@ -48,7 +49,7 @@ func TestAddTo(t *testing.T) {
 func TestSetUsage(t *testing.T) {
 	rootCmd := &cobra.Command{Use: "root", Short: "root", Run: func(cmd *cobra.Command, args []string) {}}
 	groups.AddTo(rootCmd)
-	groups.SetRootUsage(rootCmd)
+	groups.SetRootUsage(rootCmd, getTestFuncMap())
 
 	for _, cmd := range rootCmd.Commands() {
 		assert.Assert(t, cmd.DisableFlagsInUseLine)
@@ -67,3 +68,12 @@ func TestSetUsage(t *testing.T) {
 	assert.Equal(t, stdErr, "")
 	assert.Assert(t, util.ContainsAll(stdOut, "root", "header-1", "header-2"))
 }
+
+func getTestFuncMap() *template.FuncMap {
+	fMap := template.FuncMap{
+		"listPlugins": func(c *cobra.Command) string {
+			return ""
+		},
+	}
+	return &fMap
+}

pkg/templates/template_engine.go

@@ -30,14 +30,30 @@ import (
 type templateEngine struct {
 	RootCmd *cobra.Command
 	CommandGroups
+	functions template.FuncMap
 }
 
 // Get the function to show the global options
 func NewGlobalOptionsFunc() func(command *cobra.Command) error {
-	return templateEngine{}.optionsFunc()
+	return newTemplateEngine(nil, nil, nil).optionsFunc()
 }
 
-func (e templateEngine) usageFunc() func(command *cobra.Command) error {
+// Create new template engine
+func newTemplateEngine(rootCmd *cobra.Command, g CommandGroups, extraFunctions *template.FuncMap) templateEngine {
+	engine := templateEngine{
+		RootCmd:       rootCmd,
+		CommandGroups: g,
+	}
+	engine.functions = engine.templateFunctions()
+	if extraFunctions != nil {
+		for name, function := range *extraFunctions {
+			engine.functions[name] = function
+		}
+	}
+	return engine
+}
+
+func (e templateEngine) usageFunc() func(*cobra.Command) error {
 	return func(c *cobra.Command) error {
 		return e.fillTemplate("usage", c, usageTemplate())
 	}
@@ -60,7 +76,7 @@ func (e templateEngine) optionsFunc() func(command *cobra.Command) error {
 
 func (e templateEngine) fillTemplate(name string, c *cobra.Command, templ string) error {
 	t := template.New(name)
-	t.Funcs(e.templateFunctions())
+	t.Funcs(e.functions)
 	_, err := t.Parse(templ)
 	if err != nil {
 		fmt.Fprintf(c.ErrOrStderr(), "\nINTERNAL: >>>>> %v\n", err)

pkg/templates/template_engine_test.go

@@ -33,7 +33,7 @@ type testData struct {
 }
 
 func TestUsageFunc(t *testing.T) {
-	rootCmd, engine := newTemplateEngine()
+	rootCmd, engine := newTestTemplateEngine()
 	subCmdWithSubs, _, _ := rootCmd.Find([]string{"g1.1"})
 	subCmd, _, _ := rootCmd.Find([]string{"g2.1"})
 
@@ -71,7 +71,7 @@ func TestUsageFunc(t *testing.T) {
 }
 
 func TestHelpFunc(t *testing.T) {
-	rootCmd, engine := newTemplateEngine()
+	rootCmd, engine := newTestTemplateEngine()
 	subCmd := rootCmd.Commands()[0]
 
 	data := []testData{
@@ -101,7 +101,7 @@ func TestHelpFunc(t *testing.T) {
 }
 
 func TestOptionsFunc(t *testing.T) {
-	rootCmd, _ := newTemplateEngine()
+	rootCmd, _ := newTestTemplateEngine()
 	subCmd := rootCmd.Commands()[0]
 	capture := test.CaptureOutput(t)
 	err := NewGlobalOptionsFunc()(subCmd)
@@ -135,7 +135,7 @@ func validateSubUsageOutput(t *testing.T, stdOut string, cmd *cobra.Command) {
 	assert.Assert(t, util.ContainsAll(stdOut, "Use", "root", "options", "global"))
 }
 
-func newTemplateEngine() (*cobra.Command, templateEngine) {
+func newTestTemplateEngine() (*cobra.Command, templateEngine) {
 	rootCmd := &cobra.Command{Use: "root", Short: "desc-root", Long: "longdesc-root"}
 	rootCmd.PersistentFlags().String("global-opt", "", "global option")
 	cmdGroups := CommandGroups{
@@ -148,10 +148,7 @@ func newTemplateEngine() (*cobra.Command, templateEngine) {
 			[]*cobra.Command{newCmd("g2.1"), newCmd("g2.2"), newCmd("g2.3")},
 		},
 	}
-	engine := templateEngine{
-		RootCmd:       rootCmd,
-		CommandGroups: cmdGroups,
-	}
+	engine := newTemplateEngine(rootCmd, cmdGroups, getTestFuncMap())
 	cmdGroups.AddTo(rootCmd)
 
 	// Add a sub-command to first command

pkg/templates/templates.go

@@ -46,6 +46,13 @@ const (
 
 {{end}}`
 
+	// sectionPlugins lists all plugins (if any)
+	sectionPlugins = `{{$plugins := listPlugins .}}{{ if ne (len $plugins) 0}}Plugins:
+{{trimRight $plugins}}
+
+{{end}}
+`
+
 	// sectionFlags is the help template section that displays the command's flags.
 	sectionFlags = `{{$visibleFlags := visibleFlags .}}{{ if $visibleFlags.HasFlags}}Options:
 {{trimRight (flagsUsages $visibleFlags)}}
@@ -74,6 +81,7 @@ func usageTemplate() string {
 		sectionExamples,
 		sectionCommandGroups,
 		sectionSubCommands,
+		sectionPlugins,
 		sectionFlags,
 		sectionUsage,
 		sectionTipsHelp,