Struct Prompt 

pub struct Prompt {
    pub prompt_text: String,
    pub history: Vec<String>,
    pub commands: Vec<Command>,
}

Config struct for building command line interfaces. An example:

use shli::{Prompt,Command};

let mut p = Prompt::new("> ".to_string(), vec!(
    Command::new("print"),
    Command::new("echo"),
    Command::new("cat").arg("--help"),
    Command::new("exit")
));

Now, use the read_commandline method to let the user type a command.

It will tab complete print, echo, cat, cat --help and exit.

Fields

prompt_text: String

history: Vec<String>

commands: Vec<Command>

Implementations

impl Prompt

pub fn new(prompt_text: String, commands: Vec<Command>) -> Prompt

Creates a new Prompt instance.

prompt_text is the text written before the user input. commands is the list of available commands used by tab completion.

Examples found in repository

examples/simple.rs (lines 6-14)

fn main() {
    let mut p = Prompt::new(
        "> ".to_string(),
        vec![
            Command::new("print"),
            Command::new("echo"),
            Command::new("cat").arg("--help"),
            Command::new("exit"),
        ],
    );
    loop {
        // read_commandline does all the reading and tab completion
        match p.read_commandline() {
            Ok(line) => {
                println!("");
                match line.get(0).map(|s| s.as_str()) {
                    Some("exit") => break,
                    Some("print") | Some("echo") => {
                        if line.len() > 1 {
                            let output = line[1..]
                                .iter()
                                .map(|s| &**s)
                                .collect::<Vec<&str>>()
                                .join(" ");
                            println!("{}", output);
                        }
                    }
                    Some(cmd) => println!("Did not find '{}' command!", cmd),
                    None => {}
                }
            }
            Err(Error::CtrlD) => {
                    println!("exit");
                    break;
            }
            Err(Error::CtrlC) => println!("\nCtrl+C pressed."),
            Err(Error::IoError(e)) => println!("Reading error: {:?}", e),
        }
    }
}

pub fn read_commandline(&mut self) -> Result<Vec<String>, Error>

Prompt for a single command line.

This function reads and returns a command line. Line editing with backspace and ALT+backspace is supported.

If TAB is pressed by the user, the callback function completion is asked for possible argument completion. If it returns exactly 1 completion, it is used, if it returns more, they are displayed.

If Ctrl+C is pressed, this function returns Err(Error::new(ErrorKind::Other, "Ctrl-C pressed."), while an EOF of stdin or Ctrl+D will return the error type ErrorKind::UnexpectedEof.

On success, read_commandline returns a Vector of command line components (command + arguments).

For example, the following input:

> print out "example command"

will return vec!["print", "out", "example command"].

Examples found in repository

examples/simple.rs (line 17)

fn main() {
    let mut p = Prompt::new(
        "> ".to_string(),
        vec![
            Command::new("print"),
            Command::new("echo"),
            Command::new("cat").arg("--help"),
            Command::new("exit"),
        ],
    );
    loop {
        // read_commandline does all the reading and tab completion
        match p.read_commandline() {
            Ok(line) => {
                println!("");
                match line.get(0).map(|s| s.as_str()) {
                    Some("exit") => break,
                    Some("print") | Some("echo") => {
                        if line.len() > 1 {
                            let output = line[1..]
                                .iter()
                                .map(|s| &**s)
                                .collect::<Vec<&str>>()
                                .join(" ");
                            println!("{}", output);
                        }
                    }
                    Some(cmd) => println!("Did not find '{}' command!", cmd),
                    None => {}
                }
            }
            Err(Error::CtrlD) => {
                    println!("exit");
                    break;
            }
            Err(Error::CtrlC) => println!("\nCtrl+C pressed."),
            Err(Error::IoError(e)) => println!("Reading error: {:?}", e),
        }
    }
}