Struct LineEditor 

pub struct LineEditor { /* private fields */ }

Main line editor interface with full editing and history support.

Provides a high-level API for reading edited lines from any Terminal implementation. Handles all keyboard input, cursor movement, text editing, and history navigation.

Examples

use editline::{LineEditor, terminals::StdioTerminal};

let mut editor = LineEditor::new(1024, 50);
let mut terminal = StdioTerminal::new();

match editor.read_line(&mut terminal) {
    Ok(line) => println!("Got: {}", line),
    Err(e) => eprintln!("Error: {}", e),
}

Key Bindings

• Arrow keys: Move cursor left/right, navigate history up/down
• Home/End: Jump to start/end of line
• Backspace/Delete: Delete characters
• Ctrl+Left/Right: Move by word
• Alt+Backspace: Delete word left
• Ctrl+Delete: Delete word right
• Enter: Submit line

Implementations

impl LineEditor

pub fn new(buffer_capacity: usize, history_capacity: usize) -> Self

Creates a new line editor with the specified capacities.

Arguments

• buffer_capacity - Initial capacity for the line buffer in bytes
• history_capacity - Maximum number of history entries to store

Examples

use editline::LineEditor;

// 1024 byte buffer, 50 history entries
let editor = LineEditor::new(1024, 50);

Examples found in repository

examples/simple_repl.rs (line 13)

fn main() {
    println!("Simple REPL - Type something and press Enter");
    println!("Type 'exit' or press Ctrl-D to quit");
    println!("Features: line editing, history (up/down), word navigation (Ctrl+arrows)");
    println!("Press Ctrl-C to cancel current line");
    println!();

    let mut editor = LineEditor::new(1024, 50);
    let mut terminal = StdioTerminal::new();

    loop {
        print!("> ");
        std::io::Write::flush(&mut std::io::stdout()).unwrap();

        match editor.read_line(&mut terminal) {
            Ok(line) => {
                if line == "exit" {
                    println!("Goodbye!");
                    break;
                } else if !line.is_empty() {
                    println!("typed: {}", line);
                }
            }
            Err(e) => {
                // Handle Ctrl-C and Ctrl-D
                match e {
                    editline::Error::Eof => {
                        // Ctrl-D pressed - exit gracefully
                        println!("\nGoodbye!");
                        break;
                    }
                    editline::Error::Interrupted => {
                        // Ctrl-C pressed - show message and continue
                        println!("\nInterrupted. Type 'exit' or press Ctrl-D to quit.");
                        continue;
                    }
                    _ => {
                        eprintln!("\nError reading input: {}", e);
                        break;
                    }
                }
            }
        }
    }
}

pub fn read_line<T: Terminal>(&mut self, terminal: &mut T) -> Result<String>

Reads a line from the terminal with full editing support.

Enters raw mode, processes key events until Enter is pressed, then returns the edited line with leading and trailing whitespace removed. The trimmed line is automatically added to history if non-empty.

Arguments

• terminal - Any type implementing the Terminal trait

Returns

Ok(String) with the trimmed entered line, or Err if an I/O error occurs.

Examples

use editline::{LineEditor, terminals::StdioTerminal};

let mut editor = LineEditor::new(1024, 50);
let mut terminal = StdioTerminal::new();

print!("> ");
std::io::Write::flush(&mut std::io::stdout()).unwrap();

let line = editor.read_line(&mut terminal)?;
println!("You entered: {}", line);

Examples found in repository

examples/simple_repl.rs (line 20)

fn main() {
    println!("Simple REPL - Type something and press Enter");
    println!("Type 'exit' or press Ctrl-D to quit");
    println!("Features: line editing, history (up/down), word navigation (Ctrl+arrows)");
    println!("Press Ctrl-C to cancel current line");
    println!();

    let mut editor = LineEditor::new(1024, 50);
    let mut terminal = StdioTerminal::new();

    loop {
        print!("> ");
        std::io::Write::flush(&mut std::io::stdout()).unwrap();

        match editor.read_line(&mut terminal) {
            Ok(line) => {
                if line == "exit" {
                    println!("Goodbye!");
                    break;
                } else if !line.is_empty() {
                    println!("typed: {}", line);
                }
            }
            Err(e) => {
                // Handle Ctrl-C and Ctrl-D
                match e {
                    editline::Error::Eof => {
                        // Ctrl-D pressed - exit gracefully
                        println!("\nGoodbye!");
                        break;
                    }
                    editline::Error::Interrupted => {
                        // Ctrl-C pressed - show message and continue
                        println!("\nInterrupted. Type 'exit' or press Ctrl-D to quit.");
                        continue;
                    }
                    _ => {
                        eprintln!("\nError reading input: {}", e);
                        break;
                    }
                }
            }
        }
    }
}