Added evalkeys command

Author: rgburke

cmd/grv/config.go

@@ -322,14 +322,16 @@ type Configuration struct {
 	channels        Channels
 	variables       GRVVariableGetter
 	customCommands  map[string]string
+	inputConsumer   InputConsumer
 }
 
 // NewConfiguration creates a Configuration instance with default values
-func NewConfiguration(keyBindings KeyBindings, channels Channels, variables GRVVariableGetter) *Configuration {
+func NewConfiguration(keyBindings KeyBindings, channels Channels, variables GRVVariableGetter, inputConsumer InputConsumer) *Configuration {
 	config := &Configuration{
 		keyBindings:    keyBindings,
 		channels:       channels,
 		variables:      variables,
+		inputConsumer:  inputConsumer,
 		customCommands: map[string]string{},
 		themes: map[string]MutableTheme{
 			cfClassicThemeName:   NewClassicTheme(),
@@ -534,6 +536,8 @@ func (config *Configuration) processCommand(command ConfigCommand, inputSource s
 		err = config.processUndefCommand(command, inputSource)
 	case *CustomCommand:
 		err = config.processCustomCommand(command)
+	case *EvalKeysCommand:
+		err = config.processEvalKeysCommand(command)
 	default:
 		log.Errorf("Unknown command type %T", command)
 	}
@@ -948,6 +952,12 @@ func (config *Configuration) processConfigCommandBody(commandBody string, args [
 	return processedCommandBody.String()
 }
 
+func (config *Configuration) processEvalKeysCommand(evalKeysCommand *EvalKeysCommand) (err error) {
+	log.Debugf("Processing keys: %v", evalKeysCommand.keys)
+	config.inputConsumer.ProcessInput(evalKeysCommand.keys)
+	return
+}
+
 func (config *Configuration) runCommand(command string, outputType ShellCommandOutputType) {
 	NewShellCommandProcessor(config.channels, config.variables, command, outputType).Execute()
 }

cmd/grv/config_command_help.go

@@ -453,3 +453,26 @@ func GenerateUndefCommandHelpSections(config Config) (helpSections []*HelpSectio
 		},
 	}
 }
+
+// GenerateEvalKeysCommandHelpSections generates help documentation for the addtab command
+func GenerateEvalKeysCommandHelpSections(config Config) (helpSections []*HelpSection) {
+	description := []HelpSectionText{
+		{text: "evalkeys", themeComponentID: CmpHelpViewSectionSubTitle},
+		{},
+		{text: "The evalkeys command executes the provided key string sequence."},
+		{text: "The format of the command is:"},
+		{},
+		{text: "evalkeys keys", themeComponentID: CmpHelpViewSectionCodeBlock},
+		{},
+		{text: "For example, running the following will switch to the next tab:"},
+		{},
+		{text: "evalkeys <grv-next-tab>", themeComponentID: CmpHelpViewSectionCodeBlock},
+		{},
+	}
+
+	return []*HelpSection{
+		{
+			description: description,
+		},
+	}
+}

cmd/grv/config_parse.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"io"
 	"regexp"
+	"strings"
+	"unicode"
 
 	slice "github.com/bradfitz/slice"
 )
@@ -27,6 +29,7 @@ const (
 	helpCommand           = "help"
 	defCommand            = "def"
 	undefCommand          = "undef"
+	evalkeysCommand       = "evalkeys"
 )
 
 const (
@@ -35,6 +38,9 @@ const (
 )
 
 var isIdentifier = regexp.MustCompile(`[[:alnum:]]+`).MatchString
+var commentTokens = map[ConfigTokenType]bool{
+	CtkComment: true,
+}
 var whiteSpaceTokens = map[ConfigTokenType]bool{
 	CtkWhiteSpace: true,
 	CtkComment:    true,
@@ -166,6 +172,13 @@ type CustomCommand struct {
 
 func (customCommand *CustomCommand) configCommand() {}
 
+// EvalKeysCommand represents a key evaluation command
+type EvalKeysCommand struct {
+	keys string
+}
+
+func (evalKeysCommand *EvalKeysCommand) configCommand() {}
+
 type commandHelpGenerator func(config Config) []*HelpSection
 type commandCustomParser func(parser *ConfigParser) (tokens []*ConfigToken, err error)
 
@@ -184,7 +197,7 @@ func DefineCustomCommand(commandName string) (err error) {
 	}
 
 	commandDescriptors[commandName] = &commandDescriptor{
-		customParser: parseVarArgsCommand,
+		customParser: parseVarArgsCommand(),
 		constructor:  customCommandConstructor,
 		userDefined:  true,
 	}
@@ -238,32 +251,32 @@ var commandDescriptors = map[string]*commandDescriptor{
 		commandHelpGenerator: GenerateRmTabCommandHelpSections,
 	},
 	addviewCommand: {
-		customParser:         parseVarArgsCommand,
+		customParser:         parseVarArgsCommand(),
 		constructor:          addViewCommandConstructor,
 		commandHelpGenerator: GenerateAddViewCommandHelpSections,
 	},
 	vsplitCommand: {
-		customParser:         parseVarArgsCommand,
+		customParser:         parseVarArgsCommand(),
 		constructor:          splitViewCommandConstructor,
 		commandHelpGenerator: GenerateVSplitCommandHelpSections,
 	},
 	hsplitCommand: {
-		customParser:         parseVarArgsCommand,
+		customParser:         parseVarArgsCommand(),
 		constructor:          splitViewCommandConstructor,
 		commandHelpGenerator: GenerateHSplitCommandHelpSections,
 	},
 	splitCommand: {
-		customParser:         parseVarArgsCommand,
+		customParser:         parseVarArgsCommand(),
 		constructor:          splitViewCommandConstructor,
 		commandHelpGenerator: GenerateSplitCommandHelpSections,
 	},
 	gitCommand: {
-		customParser:         parseVarArgsCommand,
+		customParser:         parseVarArgsCommand(),
 		constructor:          gitCommandConstructor,
 		commandHelpGenerator: GenerateGitCommandHelpSections,
 	},
 	gitInteractiveCommand: {
-		customParser:         parseVarArgsCommand,
+		customParser:         parseVarArgsCommand(),
 		constructor:          gitCommandConstructor,
 		commandHelpGenerator: GenerateGitiCommandHelpSections,
 	},
@@ -281,6 +294,11 @@ var commandDescriptors = map[string]*commandDescriptor{
 		constructor:          undefCommandConstructor,
 		commandHelpGenerator: GenerateUndefCommandHelpSections,
 	},
+	evalkeysCommand: {
+		customParser:         parseVarArgsParserGenerator(false),
+		constructor:          evalKeysCommandConstructor,
+		commandHelpGenerator: GenerateEvalKeysCommandHelpSections,
+	},
 }
 
 // GenerateConfigCommandHelpSections generates help documentation for all configuration commands
@@ -481,28 +499,41 @@ func (parser *ConfigParser) parseCommand(commandToken *ConfigToken) (command Con
 	return
 }
 
-func parseVarArgsCommand(parser *ConfigParser) (tokens []*ConfigToken, err error) {
-OuterLoop:
-	for {
-		var token *ConfigToken
-		token, err = parser.scan()
+func parseVarArgsCommand() commandCustomParser {
+	return parseVarArgsParserGenerator(true)
+}
 
-		switch {
-		case err != nil:
-			return
-		case token.err != nil:
-			err = parser.generateParseError(token, "Syntax Error")
-			return
-		case token.tokenType == CtkEOF:
-			break OuterLoop
-		case token.tokenType == CtkTerminator:
-			break OuterLoop
+func parseVarArgsParserGenerator(ignoreWhitespace bool) commandCustomParser {
+	var ignoreTokens map[ConfigTokenType]bool
+	if ignoreWhitespace {
+		ignoreTokens = whiteSpaceTokens
+	} else {
+		ignoreTokens = commentTokens
+	}
+
+	return func(parser *ConfigParser) (tokens []*ConfigToken, err error) {
+	OuterLoop:
+		for {
+			var token *ConfigToken
+			token, err = parser.scanAndIgnore(ignoreTokens)
+
+			switch {
+			case err != nil:
+				return
+			case token.err != nil:
+				err = parser.generateParseError(token, "Syntax Error")
+				return
+			case token.tokenType == CtkEOF:
+				break OuterLoop
+			case token.tokenType == CtkTerminator:
+				break OuterLoop
+			}
+
+			tokens = append(tokens, token)
 		}
 
-		tokens = append(tokens, token)
+		return
 	}
-
-	return
 }
 
 func parseDefCommand(parser *ConfigParser) (tokens []*ConfigToken, err error) {
@@ -720,3 +751,21 @@ func customCommandConstructor(parser *ConfigParser, commandToken *ConfigToken, t
 		args:        args,
 	}, nil
 }
+
+func evalKeysCommandConstructor(parser *ConfigParser, commandToken *ConfigToken, tokens []*ConfigToken) (configCommand ConfigCommand, err error) {
+	if len(tokens) == 0 {
+		return nil, parser.generateParseError(commandToken, "No keys specified for %v command", evalkeysCommand)
+	}
+
+	var buffer bytes.Buffer
+
+	for _, token := range tokens {
+		buffer.WriteString(token.value)
+	}
+
+	keys := strings.TrimLeftFunc(buffer.String(), unicode.IsSpace)
+
+	return &EvalKeysCommand{
+		keys: keys,
+	}, nil
+}

cmd/grv/config_parse_test.go

@@ -292,6 +292,23 @@ func (customCommandValues *CustomCommandValues) Equal(command ConfigCommand) boo
 		reflect.DeepEqual(customCommandValues.args, other.args)
 }
 
+type EvalKeysCommandValues struct {
+	keys string
+}
+
+func (evalKeysCommandValues *EvalKeysCommandValues) Equal(command ConfigCommand) bool {
+	if command == nil {
+		return false
+	}
+
+	other, ok := command.(*EvalKeysCommand)
+	if !ok {
+		return false
+	}
+
+	return evalKeysCommandValues.keys == other.keys
+}
+
 func TestParseSingleCommand(t *testing.T) {
 	var singleCommandTests = []struct {
 		input           string
@@ -439,6 +456,12 @@ func TestParseSingleCommand(t *testing.T) {
 				functionBody: " addtab \"}\" ",
 			},
 		},
+		{
+			input: "evalkeys <grv-next-tab><grv-search-prompt>Untracked files<Enter>",
+			expectedCommand: &EvalKeysCommandValues{
+				keys: "<grv-next-tab><grv-search-prompt>Untracked files<Enter>",
+			},
+		},
 	}
 
 	for _, singleCommandTest := range singleCommandTests {

cmd/grv/config_test.go

@@ -2,10 +2,20 @@ package main
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/mock"
 )
 
+type MockInputConsumer struct {
+	mock.Mock
+}
+
+func (inputConsumer *MockInputConsumer) ProcessInput(input string) {
+	inputConsumer.Called(input)
+}
+
 func TestConfigVariablesHaveRequiredFieldsSet(t *testing.T) {
-	config := NewConfiguration(&MockKeyBindings{}, &MockChannels{}, &MockGRVVariableSetter{})
+	config := NewConfiguration(&MockKeyBindings{}, &MockChannels{}, &MockGRVVariableSetter{}, &MockInputConsumer{})
 
 	for configVariableName, configVariable := range config.configVariables {
 		if configVariable.defaultValue == nil {
@@ -40,7 +50,7 @@ func TestViewNamesContainsEntriesForAllViews(t *testing.T) {
 }
 
 func TestCommandBodyArgumentsAreExpanded(t *testing.T) {
-	config := NewConfiguration(&MockKeyBindings{}, &MockChannels{}, &MockGRVVariableSetter{})
+	config := NewConfiguration(&MockKeyBindings{}, &MockChannels{}, &MockGRVVariableSetter{}, &MockInputConsumer{})
 
 	args := []string{"do", "re", "mi"}
 

cmd/grv/documentation_generator.go

@@ -14,7 +14,7 @@ const (
 
 // GenerateDocumentation generates grv markdown documentation
 func GenerateDocumentation() (err error) {
-	helpSections, _, err := GenerateHelpView(NewConfiguration(NewKeyBindingManager(), nil, nil))
+	helpSections, _, err := GenerateHelpView(NewConfiguration(NewKeyBindingManager(), nil, nil, nil))
 	if err != nil {
 		return
 	}

cmd/grv/grv.go

@@ -36,13 +36,14 @@ type gRVChannels struct {
 	errorCh    chan error
 }
 
-func (grvChannels gRVChannels) Channels() Channels {
+func (grvChannels gRVChannels) Channels() *channels {
 	return &channels{
-		displayCh: grvChannels.displayCh,
-		exitCh:    grvChannels.exitCh,
-		errorCh:   grvChannels.errorCh,
-		actionCh:  grvChannels.actionCh,
-		eventCh:   grvChannels.eventCh,
+		displayCh:  grvChannels.displayCh,
+		exitCh:     grvChannels.exitCh,
+		errorCh:    grvChannels.errorCh,
+		actionCh:   grvChannels.actionCh,
+		eventCh:    grvChannels.eventCh,
+		inputKeyCh: grvChannels.inputKeyCh,
 	}
 }
 
@@ -58,11 +59,17 @@ type Channels interface {
 }
 
 type channels struct {
-	displayCh chan<- bool
-	exitCh    <-chan bool
-	errorCh   chan<- error
-	actionCh  chan<- Action
-	eventCh   chan<- Event
+	displayCh  chan<- bool
+	exitCh     <-chan bool
+	errorCh    chan<- error
+	actionCh   chan<- Action
+	eventCh    chan<- Event
+	inputKeyCh chan<- string
+}
+
+// InputConsumer can consumer and process key string input
+type InputConsumer interface {
+	ProcessInput(input string)
 }
 
 // EventType identifies a type of event
@@ -162,6 +169,15 @@ func (channels *channels) ReportStatus(format string, args ...interface{}) {
 	}
 }
 
+// ProcessInput sends the provided input to be processed
+func (channels *channels) ProcessInput(input string) {
+	select {
+	case channels.inputKeyCh <- input:
+	default:
+		log.Errorf("Unable to add input \"%v\" to input channel", input)
+	}
+}
+
 // NewGRV creates a new instace of GRV
 func NewGRV(readOnly bool) *GRV {
 	grvChannels := gRVChannels{
@@ -176,7 +192,7 @@ func NewGRV(readOnly bool) *GRV {
 	channels := grvChannels.Channels()
 	keyBindings := NewKeyBindingManager()
 	variables := NewGRVVariables()
-	config := NewConfiguration(keyBindings, channels, variables)
+	config := NewConfiguration(keyBindings, channels, variables, channels)
 
 	repoDataLoader := NewRepoDataLoader(channels, config)
 	repoData := NewRepositoryData(repoDataLoader, channels, variables)