taler-rust

repl.rs (7101B)

---

 /*
   This file is part of TALER
   Copyright (C) 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::borrow::Cow;
 
 use nu_ansi_term::Color;
 use reedline::{
     ColumnarMenu, DefaultHinter, FileBackedHistory, KeyCode, KeyModifiers, MenuBuilder as _,
     Reedline, ReedlineEvent, ReedlineMenu, Signal, Span, Suggestion, Vi,
     default_vi_insert_keybindings, default_vi_normal_keybindings,
 };
 
 use crate::cli::clap_parse;
 
 pub async fn test_repl<T: clap::Parser>(
     history: &str,
     prompt: String,
     prepare: impl AsyncFn(),
     run: impl AsyncFn(T) -> bool,
 ) {
     let history = Box::new(
         FileBackedHistory::with_file(1000, history.into())
             .expect("Error configuring history with file"),
     );
     let completion_menu = Box::new(
         ColumnarMenu::default()
             .with_name("completion_menu")
             .with_columns(4)
             .with_column_width(None)
             .with_column_padding(2),
     );
 
     let mut insert = default_vi_insert_keybindings();
     insert.add_binding(
         KeyModifiers::NONE,
         KeyCode::Tab,
         ReedlineEvent::UntilFound(vec![
             ReedlineEvent::Menu("completion_menu".to_string()),
             ReedlineEvent::MenuNext,
         ]),
     );
     let mut relp = Reedline::create()
         .with_history(history)
         .with_completer(Box::new(ClapCompleter(T::command())))
         .with_menu(ReedlineMenu::EngineCompleter(completion_menu))
         .with_quick_completions(true)
         .with_partial_completions(true)
         .with_hinter(Box::new(DefaultHinter::default().with_style(
             nu_ansi_term::Style::new().italic().fg(Color::LightGray),
         )))
         .with_edit_mode(Box::new(Vi::new(insert, default_vi_normal_keybindings())));
 
     let prompt = ReplPrompt(prompt);
     loop {
         prepare().await;
         let Signal::Success(buf) = relp.read_line(&prompt).unwrap() else {
             break;
         };
         match clap_parse(&buf) {
             Ok(cmd) => {
                 if run(cmd).await {
                     break;
                 }
             }
             Err(e) => {
                 println!("{e}");
             }
         }
     }
 }
 
 struct ClapCompleter(clap::Command);
 
 impl reedline::Completer for ClapCompleter {
     fn complete(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
         let mut suggestions = Vec::new();
         let text_before_cursor = &line[..pos];
 
         let words = shlex::split(text_before_cursor).unwrap_or_default();
         let is_whitespace_at_end = text_before_cursor.ends_with(' ');
 
         let mut active_cmd = &self.0;
         let mut last_word = "";
 
         // Determine the word currently being typed
         if !is_whitespace_at_end && !words.is_empty() {
             last_word = words.last().unwrap();
         }
 
         // Identify which subcommand we are currently inside by walking the tokens
         let tokens = if is_whitespace_at_end {
             &words[..]
         } else {
             &words[..words.len().saturating_sub(1)]
         };
 
         for token in tokens {
             if let Some(subcmd) = active_cmd
                 .get_subcommands()
                 .find(|s| s.get_name() == *token)
             {
                 active_cmd = subcmd;
             }
         }
 
         let start = pos - last_word.len();
         let span = Span::new(start, pos);
 
         // Suggest Long Flags
         if last_word.starts_with("--") {
             for arg in active_cmd.get_arguments() {
                 if let Some(long) = arg.get_long() {
                     let flag = format!("--{}", long);
                     if flag.starts_with(last_word) {
                         suggestions.push(Suggestion {
                             value: flag,
                             description: arg.get_help().map(|s| s.to_string()),
                             span,
                             append_whitespace: true,
                             ..Suggestion::default()
                         });
                     }
                 }
             }
         }
         // Suggest Short & Long Flags
         else if last_word.starts_with("-") {
             for arg in active_cmd.get_arguments() {
                 if let Some(short) = arg.get_short() {
                     let flag = format!("-{}", short);
                     if flag.starts_with(last_word) {
                         suggestions.push(Suggestion {
                             value: flag,
                             description: arg.get_help().map(|s| s.to_string()),
                             span,
                             append_whitespace: true,
                             ..Suggestion::default()
                         });
                     }
                 }
                 if let Some(long) = arg.get_long() {
                     let flag = format!("--{}", long);
                     if flag.starts_with(last_word) {
                         suggestions.push(Suggestion {
                             value: flag,
                             description: arg.get_help().map(|s| s.to_string()),
                             span,
                             append_whitespace: true,
                             ..Suggestion::default()
                         });
                     }
                 }
             }
         }
         // Suggest Subcommands
         else {
             for subcmd in active_cmd.get_subcommands() {
                 if subcmd.get_name().starts_with(last_word) {
                     suggestions.push(Suggestion {
                         value: subcmd.get_name().to_string(),
                         description: subcmd.get_about().map(|s| s.to_string()),
                         span,
                         append_whitespace: true,
                         ..Suggestion::default()
                     });
                 }
             }
         }
 
         suggestions
     }
 }
 
 struct ReplPrompt(String);
 
 impl reedline::Prompt for ReplPrompt {
     fn render_prompt_left(&self) -> Cow<'_, str> {
         Cow::Borrowed(&self.0)
     }
 
     fn render_prompt_right(&self) -> Cow<'_, str> {
         Cow::Borrowed("")
     }
 
     fn render_prompt_indicator(&self, _: reedline::PromptEditMode) -> Cow<'_, str> {
         Cow::Borrowed(">")
     }
 
     fn render_prompt_multiline_indicator(&self) -> Cow<'_, str> {
         Cow::Borrowed(":")
     }
 
     fn render_prompt_history_search_indicator(
         &self,
         _: reedline::PromptHistorySearch,
     ) -> Cow<'_, str> {
         Cow::Borrowed(">")
     }
 }