rustyline-async 0.4.9

A minimal readline with multiline and async support.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use async_std::stream;
use rustyline_async::{Readline, ReadlineError, ReadlineEvent};

use std::{io::Write, time::Duration};

use futures_util::{select, FutureExt, StreamExt};

#[async_std::main]
async fn main() -> Result<(), ReadlineError> {
	let mut periodic_timer1 = stream::interval(Duration::from_secs(2));
	let mut periodic_timer2 = stream::interval(Duration::from_secs(3));

	let (mut rl, mut stdout) = Readline::new("> ".to_owned()).unwrap();
	// Options:
	// rl.should_print_line_on(false, false);
	// rl.set_max_history(10);

	simplelog::WriteLogger::init(
		log::LevelFilter::Debug,
		simplelog::Config::default(),
		stdout.clone(),
	)
	.unwrap();

	let mut running_first = true;
	let mut running_second = false;

	loop {
		select! {
			_ = periodic_timer1.next().fuse() => {
				if running_first { writeln!(stdout, "First timer went off!")?; }
			}
			_ = periodic_timer2.next().fuse() => {
				if running_second { log::info!("Second timer went off!"); }
			}
			command = rl.readline().fuse() => match command {
				Ok(ReadlineEvent::Line(line)) => {
					let line = line.trim();
					rl.add_history_entry(line.to_owned());
					match line {
						"start task" => {
							writeln!(stdout, "Starting the task...")?;
							running_first = true;
						},
						"stop task" => {
							writeln!(stdout, "Stopping the task...")?;
							running_first = false;
						}
						"start logging" => {
							log::info!("Starting the logger...");
							running_second = true
						},
						"stop logging" => {
							log::info!("Stopping the logger...");
							running_second = false
						},
						"start printouts" => {
							rl.should_print_line_on(true, true);
						},
						"stop printouts" => {
							rl.should_print_line_on(false, false);
						},
						"info" => {
							writeln!(stdout, r"
hello there
I use NixOS btw
its pretty cool
							")?;
						}
			"help" => {
			  writeln!(stdout,
r"Commands:
start <task|logging|printouts>
stop <task|logging|printouts>
info
help")?;
			}
						_ => writeln!(stdout, "Command not found: \"{}\"", line)?,
					}
				},
				Ok(ReadlineEvent::Eof) => { writeln!(stdout, "Exiting...")?; break },
				Ok(ReadlineEvent::Interrupted) => writeln!(stdout, "^C")?,
				// Err(ReadlineError::Closed) => break, // Readline was closed via one way or another, cleanup other futures here and break out of the loop
				Err(err) => {
					writeln!(stdout, "Received err: {:?}", err)?;
					writeln!(stdout, "Exiting...")?;
					break
				},
			}
		}
	}

	// Flush all writers to stdout
	rl.flush()?;

	Ok(())
}