Add functionality to find examples

In order for an app to find examples it needs to search in all levels
for a match.

For the moment there are only two levels, the app and the commands, so
substring check is sufficent for this purpose.

levels.go

@@ -1,5 +1,9 @@
 package egcmd
 
+import (
+	"strings"
+)
+
 // A Level provides a context for examples to be found,
 // whether this is at the top-level of your app or at a command.
 type Level struct {
@@ -45,6 +49,21 @@ func (a *App) Command(name string) (command *Command) {
 	return
 }
 
+// Find returns the examples that belong to a particular level
+func (a *App) Find(search string) (examples []*Example) {
+	if search == a.name {
+		examples = a.examples
+	} else if strings.HasPrefix(search, a.name) {
+		command := search[len(a.name)+1:]
+
+		if value, ok := a.commands[command]; ok {
+			examples = value.examples
+		}
+	}
+
+	return
+}
+
 // Command provides a container for top-level and command examples to be instantiated
 type Command struct {
 	Level

levels_test.go

@@ -1,6 +1,7 @@
 package egcmd
 
 import (
+	"reflect"
 	"testing"
 )
 
@@ -142,3 +143,78 @@ func TestAppCommand(t *testing.T) {
 		})
 	}
 }
+
+func TestAppFind(t *testing.T) {
+	appExamples := []*Example{
+		{"", "Action: default", ""},
+		{"simple", "Action: simple", ""},
+		{"complex sub-action", "Action: complex sub-action", ""},
+	}
+	simpleExamples := []*Example{
+		{"", "Default for simple", ""},
+		{"--debug", "Simple with debug", ""},
+	}
+	complexExamples := []*Example{
+		{"--json", "Default for complex with json arg", ""},
+		{"sub-action", "complex action with sub-action", ""},
+	}
+	subActionExamples := []*Example{
+		{"", "Subaction", "APP_KEY=1234"},
+	}
+
+	app := App{
+		Level: Level{"root", appExamples},
+		commands: map[string]*Command{
+			"simple":             {Level: Level{"simple", simpleExamples}},
+			"complex":            {Level: Level{"complex", complexExamples}},
+			"complex sub-action": {Level: Level{"complex sub-action", subActionExamples}},
+		},
+	}
+
+	testCases := []struct {
+		testName string
+		search   string
+		want     []*Example
+	}{
+		{
+			"Root",
+			"root",
+			appExamples,
+		},
+		{
+			"SimpleCommand",
+			"root simple",
+			simpleExamples,
+		},
+		{
+			"ComplexCommand",
+			"root complex",
+			complexExamples,
+		},
+		{
+			"ComplexSubCommand",
+			"root complex sub-action",
+			subActionExamples,
+		},
+		{
+			"CommandNotFound",
+			"root no-match",
+			nil,
+		},
+		{
+			"InvalidSearchs",
+			"invalid",
+			nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.testName, func(t *testing.T) {
+			got := app.Find(tc.search)
+
+			if !reflect.DeepEqual(tc.want, got) {
+				t.Errorf("Expected examples to be %#v, got %#v", tc.want, got)
+			}
+		})
+	}
+}