Struct reedline::Reedline

pub struct Reedline { /* private fields */ }

Line editor engine

Example usage

use reedline::{Reedline, Signal, DefaultPrompt};
let mut line_editor = Reedline::create();
let prompt = DefaultPrompt::default();

let out = line_editor.read_line(&prompt).unwrap();
match out {
   Signal::Success(content) => {
       // process content
   }
   _ => {
       eprintln!("Entry aborted!");

   }
}

Implementations

impl Reedline

pub fn create() -> Self

Create a new Reedline engine with a local History that is not synchronized to a file.

pub fn get_history_session_id(&self) -> Option<HistorySessionId>

Return the previously generated history session id

pub fn with_hinter(self, hinter: Box<dyn Hinter>) -> Self

A builder to include a Hinter in your instance of the Reedline engine

Example

//Cargo.toml
//[dependencies]
//nu-ansi-term = "*"
use {
    nu_ansi_term::{Color, Style},
    reedline::{DefaultHinter, Reedline},
};

let mut line_editor = Reedline::create().with_hinter(Box::new(
    DefaultHinter::default()
    .with_style(Style::new().italic().fg(Color::LightGray)),
));

pub fn disable_hints(self) -> Self

Remove current Hinter

pub fn with_completer(self, completer: Box<dyn Completer>) -> Self

A builder to configure the tab completion

Example

// Create a reedline object with tab completions support

use reedline::{DefaultCompleter, Reedline};

let commands = vec![
  "test".into(),
  "hello world".into(),
  "hello world reedline".into(),
  "this is the reedline crate".into(),
];
let completer = Box::new(DefaultCompleter::new_with_wordlen(commands.clone(), 2));

let mut line_editor = Reedline::create().with_completer(completer);

pub fn with_quick_completions(self, quick_completions: bool) -> Self

Turn on quick completions. These completions will auto-select if the completer ever narrows down to a single entry.

pub fn with_partial_completions(self, partial_completions: bool) -> Self

Turn on partial completions. These completions will fill the buffer with the smallest common string from all the options

pub fn with_ansi_colors(self, use_ansi_coloring: bool) -> Self

A builder which enables or disables the use of ansi coloring in the prompt and in the command line syntax highlighting.

pub fn with_highlighter(self, highlighter: Box<dyn Highlighter>) -> Self

A builder that configures the highlighter for your instance of the Reedline engine

Example

// Create a reedline object with highlighter support

use reedline::{ExampleHighlighter, Reedline};

let commands = vec![
  "test".into(),
  "hello world".into(),
  "hello world reedline".into(),
  "this is the reedline crate".into(),
];
let mut line_editor =
Reedline::create().with_highlighter(Box::new(ExampleHighlighter::new(commands)));

pub fn with_history(self, history: Box<dyn History>) -> Self

A builder which configures the history for your instance of the Reedline engine

Example

// Create a reedline object with history support, including history size limits

use reedline::{FileBackedHistory, Reedline};

let history = Box::new(
FileBackedHistory::with_file(5, "history.txt".into())
    .expect("Error configuring history with file"),
);
let mut line_editor = Reedline::create()
    .with_history(history);

pub fn with_validator(self, validator: Box<dyn Validator>) -> Self

A builder that configures the validator for your instance of the Reedline engine

Example

// Create a reedline object with validator support

use reedline::{DefaultValidator, Reedline};

let mut line_editor =
Reedline::create().with_validator(Box::new(DefaultValidator));

pub fn with_buffer_editor(self, editor: String, extension: String) -> Self

A builder that configures the text editor used to edit the line buffer

Example

// Create a reedline object with vim as editor

use reedline::{DefaultValidator, Reedline};

let mut line_editor =
Reedline::create().with_buffer_editor("vim".into(), "nu".into());

pub fn disable_validator(self) -> Self

Remove the current Validator

pub fn with_edit_mode(self, edit_mode: Box<dyn EditMode>) -> Self

A builder which configures the edit mode for your instance of the Reedline engine

pub fn with_menu(self, menu: ReedlineMenu) -> Self

A builder that appends a menu to the engine

pub fn clear_menus(self) -> Self

A builder that clears the list of menus added to the engine

pub fn prompt_edit_mode(&self) -> PromptEditMode

Returns the corresponding expected prompt style for the given edit mode

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

Output the complete History chronologically with numbering to the terminal

pub fn history(&self) -> &dyn History

Read-only view of the history

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

Update the underlying History to/from disk

pub fn has_last_command_context(&self) -> bool

Check if any commands have been run.

When no commands have been run, calling Self::update_last_command_context does not make sense and is guaranteed to fail with a “No command run” error.

pub fn update_last_command_context(
    &mut self,
    f: &dyn Fn(HistoryItem) -> HistoryItem
) -> Result<(), ReedlineError>

update the last history item with more information

pub fn read_line(&mut self, prompt: &dyn Prompt) -> Result<Signal>

Wait for input and provide the user with a specified Prompt.

Returns a crossterm::Result in which the Err type is crossterm::ErrorKind to distinguish I/O errors and the Ok variant wraps a Signal which handles user inputs.

pub fn current_buffer_contents(&self) -> &str

Returns the current contents of the input buffer.

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

Clear the screen by printing enough whitespace to start the prompt or other output back at the first line of the terminal.

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

Clear the screen and the scollback buffer of the terminal

pub fn run_edit_commands(&mut self, commands: &[EditCommand])

Executes EditCommand actions by modifying the internal state appropriately. Does not output itself.

Trait Implementations

impl Drop for Reedline

fn drop(&mut self)

Executes the destructor for this type.