taler-rust

repl.rs (7570B)

---

 /*
   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, marker::PhantomData};
 
 use nu_ansi_term::Color;
 use reedline::{
     ColumnarMenu, CompletionResult, DefaultHinter, FileBackedHistory, KeyCode, KeyModifiers,
     MenuBuilder as _, Reedline, ReedlineEvent, ReedlineMenu, Signal, Span, Suggestion, Vi,
     default_vi_insert_keybindings, default_vi_normal_keybindings, default_vi_visual_keybindings,
 };
 
 use crate::cli::clap_parse;
 
 pub struct Repl<T: clap::Parser> {
     relp: Reedline,
     phantom: PhantomData<T>,
 }
 
 impl<T: clap::Parser> Repl<T> {
     pub fn new(history: &str) -> Self {
         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 repl = Reedline::create()
             .with_history(history)
             .with_completer(Box::new(ClapCompleter(T::command().clone())))
             .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(),
                 default_vi_visual_keybindings(),
             )));
 
         Self {
             relp: repl,
             phantom: PhantomData,
         }
     }
 
     pub fn read_line(&mut self, left: &str, right: &str) -> Option<T> {
         loop {
             let Signal::Success(buf) = self.relp.read_line(&ReplPrompt(left, right)).unwrap()
             else {
                 return None;
             };
             match clap_parse(&buf) {
                 Ok(cmd) => return Some(cmd),
                 Err(e) => {
                     e.print().unwrap();
                 }
             }
         }
     }
 }
 
 struct ClapCompleter(clap::Command);
 
 impl reedline::Completer for ClapCompleter {
     fn complete(&mut self, line: &str, pos: usize) -> CompletionResult {
         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()
                     });
                 }
             }
         }
 
         CompletionResult::fresh(suggestions)
     }
 }
 
 struct ReplPrompt<'a>(&'a str, &'a str);
 
 impl<'a> reedline::Prompt for ReplPrompt<'a> {
     fn render_prompt_left(&self) -> Cow<'_, str> {
         Cow::Borrowed(self.0)
     }
 
     fn render_prompt_right(&self) -> Cow<'_, str> {
         Cow::Borrowed(self.1)
     }
 
     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(">")
     }
 }