Add tab completion for options #80
Assignees
Labels
Comments
|
This would be nice |
georgebrock
added a commit
that referenced
this issue
Mar 19, 2017
This is a really major change, and therefore a big diff. Replaces the Parslet-based parsing expression grammar (PEG) with an RLTK-based context-free grammar (CFG). The `Gitsh::Parser` (which converted text into a AST) and `Gitsh::Transformer` (which converted the AST into useful domain objects) have been replaced with a `Gitsh::Lexer` (which converts text into tokens) and `Gitsh::Parser` (which converts tokens into useful domain objects). Why? ==== Distinguishing between _invalid input_ and _valid but incomplete input_ is really hard with a PEG. There are various papers on improving PEG error reporting, and some support in Parslet for various strategies, but I couldn't find a satisfactory way to accurately work out why parsing failed without making the grammar significantly more complex. We want to add support for various multi-line constructs, which means we need to know if a line is invalid or just waiting for more input. The specific issues I have in mind are: - Support multi-line strings (#31) - Add a `:function` command for defining functions (#35) We also want to improve tab-completion in various ways, which also involves working with very similar types of incomplete input. Most of the enhancements we have in mind will only be possible if we know more exactly what we're completing, and re-using some of the parsing code to understand the input seemed like the most logical approach. Specific issues are: - Support the same tab completion options as zsh (#25) - Add tab completion for options (#80) - Auto complete stash commands (#220) - Tab completion only works for the first command on the line (#261) Note that this commit doesn't implement any of these enhancements, it just makes them more likely to happen in the future. Implementation details ====================== - Introduces equality methods on argument objects, used to testing parser output. - git-prefix correction (i.e. interpreting `git foo` as `foo` when `help.autocorrect` is set) has moved from the Parser to the GitCommand class. - The subshell implementation in this commit is not very good. It will be significantly improved in the next couple of commits, but it seemed too big of a change to roll into this one.
georgebrock
added a commit
that referenced
this issue
Apr 1, 2017
This is a really major change, and therefore a big diff. Replaces the Parslet-based parsing expression grammar (PEG) with an RLTK-based context-free grammar (CFG). The `Gitsh::Parser` (which converted text into a AST) and `Gitsh::Transformer` (which converted the AST into useful domain objects) have been replaced with a `Gitsh::Lexer` (which converts text into tokens) and `Gitsh::Parser` (which converts tokens into useful domain objects). Why? ==== Distinguishing between _invalid input_ and _valid but incomplete input_ is really hard with a PEG. There are various papers on improving PEG error reporting, and some support in Parslet for various strategies, but I couldn't find a satisfactory way to accurately work out why parsing failed without making the grammar significantly more complex. We want to add support for various multi-line constructs, which means we need to know if a line is invalid or just waiting for more input. The specific issues I have in mind are: - Support multi-line strings (#31) - Add a `:function` command for defining functions (#35) We also want to improve tab-completion in various ways, which also involves working with very similar types of incomplete input. Most of the enhancements we have in mind will only be possible if we know more exactly what we're completing, and re-using some of the parsing code to understand the input seemed like the most logical approach. Specific issues are: - Support the same tab completion options as zsh (#25) - Add tab completion for options (#80) - Auto complete stash commands (#220) - Tab completion only works for the first command on the line (#261) Note that this commit doesn't implement any of these enhancements, it just makes them more likely to happen in the future. Implementation details ====================== - Introduces equality methods on argument objects, used to testing parser output. - git-prefix correction (i.e. interpreting `git foo` as `foo` when `help.autocorrect` is set) has moved from the Parser to the GitCommand class. - The subshell implementation in this commit is not very good. It will be significantly improved in the next couple of commits, but it seemed too big of a change to roll into this one.
georgebrock
added a commit
that referenced
this issue
Apr 8, 2017
This is a really major change, and therefore a big diff. Replaces the Parslet-based parsing expression grammar (PEG) with an RLTK-based context-free grammar (CFG). The `Gitsh::Parser` (which converted text into a AST) and `Gitsh::Transformer` (which converted the AST into useful domain objects) have been replaced with a `Gitsh::Lexer` (which converts text into tokens) and `Gitsh::Parser` (which converts tokens into useful domain objects). Why? ==== Distinguishing between _invalid input_ and _valid but incomplete input_ is really hard with a PEG. There are various papers on improving PEG error reporting, and some support in Parslet for various strategies, but I couldn't find a satisfactory way to accurately work out why parsing failed without making the grammar significantly more complex. We want to add support for various multi-line constructs, which means we need to know if a line is invalid or just waiting for more input. The specific issues I have in mind are: - Support multi-line strings (#31) - Add a `:function` command for defining functions (#35) We also want to improve tab-completion in various ways, which also involves working with very similar types of incomplete input. Most of the enhancements we have in mind will only be possible if we know more exactly what we're completing, and re-using some of the parsing code to understand the input seemed like the most logical approach. Specific issues are: - Support the same tab completion options as zsh (#25) - Add tab completion for options (#80) - Auto complete stash commands (#220) - Tab completion only works for the first command on the line (#261) Note that this commit doesn't implement any of these enhancements, it just makes them more likely to happen in the future. Implementation details ====================== - Introduces equality methods on argument objects, used to testing parser output. - git-prefix correction (i.e. interpreting `git foo` as `foo` when `help.autocorrect` is set) has moved from the Parser to the GitCommand class. - The subshell implementation in this commit is not very good. It will be significantly improved in the next couple of commits, but it seemed too big of a change to roll into this one.
georgebrock
added a commit
that referenced
this issue
Apr 19, 2017
This is a really major change, and therefore a big diff. Replaces the Parslet-based parsing expression grammar (PEG) with an RLTK-based context-free grammar (CFG). The `Gitsh::Parser` (which converted text into a AST) and `Gitsh::Transformer` (which converted the AST into useful domain objects) have been replaced with a `Gitsh::Lexer` (which converts text into tokens) and `Gitsh::Parser` (which converts tokens into useful domain objects). Why? ==== Distinguishing between _invalid input_ and _valid but incomplete input_ is really hard with a PEG. There are various papers on improving PEG error reporting, and some support in Parslet for various strategies, but I couldn't find a satisfactory way to accurately work out why parsing failed without making the grammar significantly more complex. We want to add support for various multi-line constructs, which means we need to know if a line is invalid or just waiting for more input. The specific issues I have in mind are: - Support multi-line strings (#31) - Add a `:function` command for defining functions (#35) We also want to improve tab-completion in various ways, which also involves working with very similar types of incomplete input. Most of the enhancements we have in mind will only be possible if we know more exactly what we're completing, and re-using some of the parsing code to understand the input seemed like the most logical approach. Specific issues are: - Support the same tab completion options as zsh (#25) - Add tab completion for options (#80) - Auto complete stash commands (#220) - Tab completion only works for the first command on the line (#261) Note that this commit doesn't implement any of these enhancements, it just makes them more likely to happen in the future. Implementation details ====================== - Introduces equality methods on argument objects, used to testing parser output. - git-prefix correction (i.e. interpreting `git foo` as `foo` when `help.autocorrect` is set) has moved from the Parser to the GitCommand class. - The subshell implementation in this commit is not very good. It will be significantly improved in the next couple of commits, but it seemed too big of a change to roll into this one.
georgebrock
added a commit
that referenced
this issue
Apr 19, 2017
This is a really major change, and therefore a big diff. Replaces the Parslet-based parsing expression grammar (PEG) with an RLTK-based context-free grammar (CFG). The `Gitsh::Parser` (which converted text into a AST) and `Gitsh::Transformer` (which converted the AST into useful domain objects) have been replaced with a `Gitsh::Lexer` (which converts text into tokens) and `Gitsh::Parser` (which converts tokens into useful domain objects). Why? ==== Distinguishing between _invalid input_ and _valid but incomplete input_ is really hard with a PEG. There are various papers on improving PEG error reporting, and some support in Parslet for various strategies, but I couldn't find a satisfactory way to accurately work out why parsing failed without making the grammar significantly more complex. We want to add support for various multi-line constructs, which means we need to know if a line is invalid or just waiting for more input. The specific issues I have in mind are: - Support multi-line strings (#31) - Add a `:function` command for defining functions (#35) We also want to improve tab-completion in various ways, which also involves working with very similar types of incomplete input. Most of the enhancements we have in mind will only be possible if we know more exactly what we're completing, and re-using some of the parsing code to understand the input seemed like the most logical approach. Specific issues are: - Support the same tab completion options as zsh (#25) - Add tab completion for options (#80) - Auto complete stash commands (#220) - Tab completion only works for the first command on the line (#261) Note that this commit doesn't implement any of these enhancements, it just makes them more likely to happen in the future. Implementation details ====================== - Introduces equality methods on argument objects, used to testing parser output. - git-prefix correction (i.e. interpreting `git foo` as `foo` when `help.autocorrect` is set) has moved from the Parser to the GitCommand class. - The subshell implementation in this commit is not very good. It will be significantly improved in the next couple of commits, but it seemed too big of a change to roll into this one.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
According to the README:
Tab completion works for commands/branches but not for options. For example, if I want to run
rebase --continueI can tab-complete therebasebut not the--continue. ZSH allowed me to complete both. It would be nice to add this ability togitsh.The text was updated successfully, but these errors were encountered: