Struct Editor 

pub struct Editor<H: Helper, I: History> { /* private fields */ }

Line editor

Implementations

impl<H: Helper> Editor<H, DefaultHistory>

pub fn new() -> Result<Self>

Create an editor with the default configuration

pub fn with_config(config: Config) -> Result<Self>

Create an editor with a specific configuration.

impl<H: Helper, I: History> Editor<H, I>

pub fn with_history(config: Config, history: I) -> Result<Self>

Create an editor with a custom history impl.

pub fn readline<P: Prompt + ?Sized>(&mut self, prompt: &P) -> Result<String>

This method will read a line from STDIN and will display a prompt.

prompt should not be styled (in case the terminal doesn’t support ANSI) directly: use Highlighter::highlight_prompt instead.

It uses terminal-style interaction if stdin is connected to a terminal. Otherwise (e.g., if stdin is a pipe or the terminal is not supported), it uses file-style interaction.

pub fn readline_with_initial<P: Prompt + ?Sized>( &mut self, prompt: &P, initial: (&str, &str), ) -> Result<String>

This function behaves in the exact same manner as Editor::readline, except that it pre-populates the input area.

The text that resides in the input area is given as a 2-tuple. The string on the left of the tuple is what will appear to the left of the cursor and the string on the right is what will appear to the right of the cursor.

pub fn load_history<P: AsRef<Path> + ?Sized>(&mut self, path: &P) -> Result<()>

Load the history from the specified file.

pub fn save_history<P: AsRef<Path> + ?Sized>(&mut self, path: &P) -> Result<()>

Save the history in the specified file.

pub fn append_history<P: AsRef<Path> + ?Sized>( &mut self, path: &P, ) -> Result<()>

Append new entries in the specified file.

pub fn add_history_entry<S: AsRef<str> + Into<String>>( &mut self, line: S, ) -> Result<bool>

Add a new entry in the history.

pub fn clear_history(&mut self) -> Result<()>

Clear history.

pub fn history_mut(&mut self) -> &mut I

Return a mutable reference to the history object.

pub fn history(&self) -> &I

Return an immutable reference to the history object.

pub fn set_helper(&mut self, helper: Option<H>)

Register a callback function to be called for tab-completion or to show hints to the user at the right of the prompt.

pub fn helper_mut(&mut self) -> Option<&mut H>

Return a mutable reference to the helper.

pub fn helper(&self) -> Option<&H>

Return an immutable reference to the helper.

pub fn bind_sequence<E: Into<Event>, R: Into<EventHandler>>( &mut self, key_seq: E, handler: R, ) -> Option<EventHandler>

Available on crate feature custom-bindings only.

Bind a sequence to a command.

pub fn unbind_sequence<E: Into<Event>>( &mut self, key_seq: E, ) -> Option<EventHandler>

Available on crate feature custom-bindings only.

Remove a binding for the given sequence.

pub fn iter<'a>( &'a mut self, prompt: &'a str, ) -> impl Iterator<Item = Result<String>> + 'a

Returns an iterator over edited lines. Iterator ends at EOF.

let mut rl = rustyline::DefaultEditor::new()?;
for readline in rl.iter("> ") {
    match readline {
        Ok(line) => {
            println!("Line: {}", line);
        }
        Err(err) => {
            println!("Error: {:?}", err);
            break;
        }
    }
}

pub fn dimensions(&mut self) -> Option<(u16, u16)>

If output stream is a tty, this function returns its width and height as a number of characters.

pub fn clear_screen(&mut self) -> Result<()>

Clear the screen.

pub fn create_external_printer( &mut self, ) -> Result<<PosixTerminal as Term>::ExternalPrinter>

Create an external printer

pub fn set_cursor_visibility( &mut self, visible: bool, ) -> Result<Option<<PosixTerminal as Term>::CursorGuard>>

Change cursor visibility

Trait Implementations

impl<H: Helper, I: History> Configurer for Editor<H, I>

fn config_mut(&mut self) -> &mut Config

Config accessor.

fn set_max_history_size(&mut self, max_size: usize) -> Result<()>

Set the maximum length for the history.

fn set_history_ignore_dups(&mut self, yes: bool) -> Result<()>

Tell if lines which match the previous history entry are saved or not in the history list.

fn set_history_ignore_space(&mut self, yes: bool)

Tell if lines which begin with a space character are saved or not in the history list.

fn set_completion_type(&mut self, completion_type: CompletionType)

Set completion_type.

fn set_completion_show_all_if_ambiguous( &mut self, completion_show_all_if_ambiguous: bool, )

Choose whether or not to show all alternatives immediately when using list completion

fn set_completion_prompt_limit(&mut self, completion_prompt_limit: usize)

The number of possible completions that determines when the user is asked whether the list of possibilities should be displayed.

fn set_keyseq_timeout(&mut self, keyseq_timeout_ms: Option<u16>)

Timeout for ambiguous key sequences in milliseconds.

fn set_edit_mode(&mut self, edit_mode: EditMode)

Choose between Emacs or Vi mode.

fn set_auto_add_history(&mut self, yes: bool)

Tell if lines are automatically added to the history.

fn set_bell_style(&mut self, bell_style: BellStyle)

Set bell style: beep, flash or nothing.

fn set_color_mode(&mut self, color_mode: ColorMode)

Forces colorization on or off.

fn set_grapheme_cluster_mode( &mut self, grapheme_cluster_mode: GraphemeClusterMode, )

Tell if terminal supports grapheme clustering

fn set_tab_stop(&mut self, tab_stop: u8)

Horizontal space taken by a tab.

fn set_check_cursor_position(&mut self, yes: bool)

Check if cursor position is at leftmost before displaying prompt.

fn set_indent_size(&mut self, size: u8)

Indentation size for indent/dedent commands

fn enable_bracketed_paste(&mut self, enabled: bool)

Enable or disable bracketed paste on unix platform

fn enable_synchronized_output(&mut self, enabled: bool)

Enable or disable synchronized output on unix platform

fn set_enable_signals(&mut self, enable_signals: bool)

Enable or disable signals in termios

impl<H: Helper, I: History> Debug for Editor<H, I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.