Da última vez falamos sobre o modo de interação de domínio da CLI. No modo de interação de domínio, pode haver vários níveis de subcomandos. Se você quiser memorizar todos os comandos durante o uso, é melhor ter menos comandos, mas você realmente não consegue lembrar muitos. Frequent --help também é algo muito problemático. Não seria conveniente se você pudesse solicitar ou completar comandos sempre que pressionar a tecla 'tab'? Nesta seção falaremos sobre como implementar o 'autocompletar'. Ainda usamos a implementação em interactcli-rs para explicar o processo de implementação.
Processo de implementação
Na verdade, Rustyline nos forneceu uma estrutura básica de funções auxiliares, incluindo completador. Vejamos o código, o local do arquivo é src/interact/cli.rs
#[derive(Helper)]
struct MyHelper {
completer: CommandCompleter,
highlighter: MatchingBracketHighlighter,
validator: MatchingBracketValidator,
hinter: HistoryHinter,
colored_prompt: String,
}
pub fn run() {
let config = Config::builder()
.history_ignore_space(true)
.completion_type(CompletionType::List)
.output_stream(OutputStreamType::Stdout)
.build();
let h = MyHelper {
completer: get_command_completer(),
highlighter: MatchingBracketHighlighter::new(),
hinter: HistoryHinter {},
colored_prompt: "".to_owned(),
validator: MatchingBracketValidator::new(),
};
let mut rl = Editor::with_config(config);
// let mut rl = Editor::<()>::new();
rl.set_helper(Some(h));
......
}
Primeiro defina a estrutura MyHelper, que precisa implementar a característica Completer + Hinter + Highlighter + Validator. Em seguida, carregue o auxiliar que definimos por meio da função set_helper do Rustyline. Na estrutura MyHelper, precisamos implementar nós mesmos a lógica completa.
Detalhes de implementação do preenchimento automático do subcomando
- Estrutura SubCmd
#[derive(Debug, Clone)]
pub struct SubCmd {
pub level: usize,
pub command_name: String,
pub subcommands: Vec<String>,
}
A estrutura SubCmd contém: nível de comando, nome do comando e informações de subcomando contidas no comando para localizar o escopo do comando e subcomandos ao implementar o preenchimento automático.
- Percorra todos os comandos quando o programa for iniciado. A função all_subcommand em src/cmd/rootcmd.rs é responsável por coletar todos os comandos e convertê-los em Vec<SubCmd>
pub fn all_subcommand(app: &clap_Command, beginlevel: usize, input: &mut Vec<SubCmd>) {
let nextlevel = beginlevel + 1;
let mut subcmds = vec![];
for iterm in app.get_subcommands() {
subcmds.push(iterm.get_name().to_string());
if iterm.has_subcommands() {
all_subcommand(iterm, nextlevel, input);
} else {
if beginlevel == 0 {
all_subcommand(iterm, nextlevel, input);
}
}
}
let subcommand = SubCmd {
level: beginlevel,
command_name: app.get_name().to_string(),
subcommands: subcmds,
};
input.push(subcommand);
}
- CommandCompleter é a parte central do recurso de preenchimento automático de subcomando
#[derive(Debug, Clone)]
pub struct CommandCompleter {
subcommands: Vec<SubCmd>,
}
impl CommandCompleter {
pub fn new(subcmds: Vec<SubCmd>) -> Self {
Self {
subcommands: subcmds,
}
}
//获取level下所有可能的子命令
pub fn level_possible_cmd(&self, level: usize) -> Vec<String> {
let mut subcmds = vec![];
let cmds = self.subcommands.clone();
for iterm in cmds {
if iterm.level == level {
subcmds.push(iterm.command_name.clone());
}
}
return subcmds;
}
//获取level下某字符串开头的子命令
pub fn level_prefix_possible_cmd(&self, level: usize, prefix: &str) -> Vec<String> {
let mut subcmds = vec![];
let cmds = self.subcommands.clone();
for iterm in cmds {
if iterm.level == level && iterm.command_name. starts_with(prefix) {
subcmds.push(iterm.command_name);
}
}
return subcmds;
}
//获取某level 下某subcommand的所有子命令
pub fn level_cmd_possible_sub_cmd(&self, level: usize, cmd: String) -> Vec<String> {
let mut subcmds = vec![];
let cmds = self.subcommands.clone();
for iterm in cmds {
if iterm.level == level && iterm.command_name == cmd {
subcmds = iterm.subcommands.clone();
}
}
return subcmds;
}
//获取某level 下某subcommand的所有prefix子命令
pub fn level_cmd_possible_prefix_sub_cmd(
&self,
level: usize,
cmd: String,
prefix: &str,
) -> Vec<String> {
let mut subcmds = vec![];
let cmds = self.subcommands.clone();
for iterm in cmds {
if iterm.level == level && iterm.command_name == cmd {
for i in iterm.subcommands {
if i.starts_with(prefix) {
subcmds.push(i);
}
}
}
}
return subcmds;
}
pub fn complete_cmd(&self, line: &str, pos: usize) -> Result<(usize, Vec<Pair>)> {
let mut entries: Vec<Pair> = Vec::new();
let d: Vec<_> = line.split(' ').collect();
if d.len() == 1 {
if d.last() == Some(&"") {
for str in self.level_possible_cmd(1) {
let mut replace = str.clone();
replace.push_str(" ");
entries.push(Pair {
display: str.clone(),
replacement: replace,
});
}
return Ok((pos, entries));
}
if let Some(last) = d.last() {
for str in self.level_prefix_possible_cmd (1, *last) {
let mut replace = str.clone();
replace.push_str(" ");
entries.push(Pair {
display: str.clone(),
replacement: replace,
});
}
return Ok((pos - last.len(), entries));
}
}
if d.last() == Some(&"") {
for str in self
.level_cmd_possible_sub_cmd(d.len() - 1, d.get(d.len() - 2).unwrap().to_string())
{
let mut replace = str.clone();
replace.push_str(" ");
entries.push(Pair {
display: str.clone(),
replacement: replace,
});
}
return Ok((pos, entries));
}
if let Some(last) = d.last() {
for str in self. level_cmd_possible_prefix_sub_cmd(
d.len() - 1,
d.get(d.len() - 2).unwrap().to_string(),
*last,
) {
let mut replace = str.clone();
replace.push_str(" ");
entries.push(Pair {
display: str.clone(),
replacement: replace,
});
}
return Ok((pos - last.len(), entries));
}
Ok((pos, entries))
}
}
impl Completer for CommandCompleter {
type Candidate = Pair;
fn complete(&self, line: &str, pos: usize, _ctx: & Context<'_>) -> Result<(usize, Vec<Pair>)> {
self.complete_cmd(line, pos)
}
}
Existem muitas partes de implementação do CommandCompleter, que incluem aproximadamente duas partes: a primeira parte inclui: obter todos os subcomandos possíveis em um determinado nível, obter os subcomandos começando com uma determinada string em um determinado nível e obter todos os subcomandos de um determinado comando em um determinado nível, comandos e outras funções básicas. Existem comentários nesta parte do código, então não vou repeti-los um por um.
A função complete_cmd é usada para calcular a posição na linha e o conteúdo de substituição nessa posição.
O item de entrada é o conteúdo da linha de comando e a posição do cursor, e o item de saída é o conteúdo que precisa ser substituído nessa posição. Por exemplo, digitamos "root cm" no prompt. A raiz contém dois subcomandos: cmd1 e cmd2. Se pressionarmos a tecla 'tab', a função complete_cmd retornará (7,[cmd1,cmd2]).
A versão web do Windows 12 deepin-IDE compilado por alunos do ensino médio foi oficialmente revelada. É conhecido como QQ "verdadeiramente desenvolvido de forma independente" e alcançou "atualizações simultâneas de três terminais", e a arquitetura NT subjacente é baseada no Electron QQ para Linux lançou oficialmente 3.2.0 "Pai de Hongmeng" Wang Chenglu : O sistema de versão para PC Hongmeng será lançado no próximo ano para desafiar o ChatGPT. Esses 8 produtos domésticos de modelo grande de IA GitUI v0.24.0 são lançados. O papel de parede padrão do Ubuntu 23.10, um Git terminal escrito em Rust é revelado. O "Tauren" no labirinto. JetBrains anuncia o roteiro do WebStorm 2023.3 na China. Ecossistema Human Java, Solon v2.5.3 lançadoAutor: JD.com Jia Shiwen
Fonte: Reimpresso pela comunidade de desenvolvedores JD Cloud, indique a fonte