Struct TerminalApp

Source

pub struct TerminalApp {
    pub stdout_handle: Stdout,
    pub command_history: Vec<String>,
    pub current_input: String,
    pub history_index: Option<usize>,
    pub last_ctrl_c: Option<Instant>,
    pub cursor_position: usize,
    pub should_exit: bool,
    pub action_sender: Option<UnboundedSender<AppAction>>,
    pub action_receiver: Option<UnboundedReceiver<AppAction>>,
    pub events_tx: Option<Sender<DaemonConsoleEvent>>,
    /* private fields */
}

Expand description

Main terminal application structure managing state and command execution.

TerminalApp provides a complete terminal interface with:

Command history navigation
Cursor management
Custom command registration (sync and async)
Configurable unknown command handling
Non-blocking async command execution

Fields§

§stdout_handle: Stdout§command_history: Vec<String>§current_input: String§history_index: Option<usize>§last_ctrl_c: Option<Instant>§cursor_position: usize§should_exit: bool§action_sender: Option<UnboundedSender<AppAction>>§action_receiver: Option<UnboundedReceiver<AppAction>>§events_tx: Option<Sender<DaemonConsoleEvent>>

Implementations§

Source §

impl TerminalApp

Source

pub fn new() -> Self

Creates a new terminal application instance with default settings.

Examples found in repository ?

demo/main.rs (line 84)

83async fn main() {
84    let mut app = TerminalApp::new();
85
86    app.set_unknown_command_handler(|_| {
87        get_warn!("The command system disabled for developing the event system.")
88    });
89
90    let action_tx = app
91        .get_action_sender()
92        .expect("Failed to get action sender");
93    let event_rx = app
94        .subscribe_events()
95        .expect("Failed to subscribe to events");
96
97    start_event_listener(event_rx, action_tx);
98
99    app.info("This message used for debugging 'TerminalLog' event.");
100
101    let _ = app
102        .run(&get_info!("App demo starting...", "Demo"), "")
103        .await;
104}

Source

pub fn get_action_sender(&self) -> Option<UnboundedSender<AppAction>>

Gets a clone of the action sender for communication with async commands

Examples found in repository ?

demo/main.rs (line 91)

83async fn main() {
84    let mut app = TerminalApp::new();
85
86    app.set_unknown_command_handler(|_| {
87        get_warn!("The command system disabled for developing the event system.")
88    });
89
90    let action_tx = app
91        .get_action_sender()
92        .expect("Failed to get action sender");
93    let event_rx = app
94        .subscribe_events()
95        .expect("Failed to subscribe to events");
96
97    start_event_listener(event_rx, action_tx);
98
99    app.info("This message used for debugging 'TerminalLog' event.");
100
101    let _ = app
102        .run(&get_info!("App demo starting...", "Demo"), "")
103        .await;
104}

Source

pub fn subscribe_events(&self) -> Option<Receiver<DaemonConsoleEvent>>

Subscribes to daemon console events

Examples found in repository ?

demo/main.rs (line 94)

83async fn main() {
84    let mut app = TerminalApp::new();
85
86    app.set_unknown_command_handler(|_| {
87        get_warn!("The command system disabled for developing the event system.")
88    });
89
90    let action_tx = app
91        .get_action_sender()
92        .expect("Failed to get action sender");
93    let event_rx = app
94        .subscribe_events()
95        .expect("Failed to subscribe to events");
96
97    start_event_listener(event_rx, action_tx);
98
99    app.info("This message used for debugging 'TerminalLog' event.");
100
101    let _ = app
102        .run(&get_info!("App demo starting...", "Demo"), "")
103        .await;
104}

Source

pub fn register_command<S: Into<String>>( &mut self, name: S, handler: Box<dyn CommandHandler>, )

Registers a synchronous command with the terminal application

Source

pub fn register_async_command<S: Into<String>>( &mut self, name: S, handler: Box<dyn AsyncCommandHandler>, )

Registers an asynchronous command with the terminal application

Source

pub fn set_unknown_command_handler<F>(&mut self, handler: F)
where F: Fn(&str) -> String + Send + Sync + 'static,

Sets a custom handler for unknown commands (synchronous).

§Arguments

handler - Closure that takes the full command string and returns a response

Examples found in repository ?

demo/main.rs (lines 86-88)

83async fn main() {
84    let mut app = TerminalApp::new();
85
86    app.set_unknown_command_handler(|_| {
87        get_warn!("The command system disabled for developing the event system.")
88    });
89
90    let action_tx = app
91        .get_action_sender()
92        .expect("Failed to get action sender");
93    let event_rx = app
94        .subscribe_events()
95        .expect("Failed to subscribe to events");
96
97    start_event_listener(event_rx, action_tx);
98
99    app.info("This message used for debugging 'TerminalLog' event.");
100
101    let _ = app
102        .run(&get_info!("App demo starting...", "Demo"), "")
103        .await;
104}

Source

pub fn set_async_unknown_command_handler<F>(&mut self, handler: F)
where F: Fn(&str) -> BoxFuture<'static, String> + Send + Sync + 'static,

Sets a custom handler for unknown commands (asynchronous).

§Arguments

handler - Closure that takes the full command string and returns a future

Source

pub fn clear_unknown_command_handler(&mut self)

Removes the custom unknown command handler.

Source

pub async fn init_terminal( &mut self, startup_message: &str, ) -> Result<(), Box<dyn Error>>

Initializes the terminal with raw mode and displays startup messages.

§Arguments

startup_message - Message to display on startup

§Errors

Returns an error if terminal initialization fails.

Source

pub async fn process_event( &mut self, event: Event, ) -> Result<bool, Box<dyn Error>>

Processes a single terminal event and returns whether the app should quit.

§Arguments

event - Terminal event to process
stdout - Mutable reference to standard output

§Returns

Ok(true) if the application should exit, Ok(false) otherwise

§Errors

Returns an error if event processing fails.

Source

pub async fn shutdown_terminal( &mut self, exit_message: &str, ) -> Result<(), Box<dyn Error>>

Shuts down the terminal and displays exit messages.

§Arguments

stdout - Mutable reference to standard output
exit_message - Message to display on exit

§Errors

Returns an error if terminal shutdown fails.

Source

pub async fn run( &mut self, startup_message: &str, exit_message: &str, ) -> Result<(), Box<dyn Error>>

Main application loop that handles terminal input and command execution.

Initializes terminal event handling, processes keyboard input, and manages command execution until exit is requested. Handles special key combinations like Ctrl+C for graceful shutdown.

§Arguments

startup_message - Optional message to display on startup
exit_message - Optional message to display on exit

§Errors

Returns an error if terminal initialization or event handling fails.

Examples found in repository ?

demo/main.rs (line 102)

83async fn main() {
84    let mut app = TerminalApp::new();
85
86    app.set_unknown_command_handler(|_| {
87        get_warn!("The command system disabled for developing the event system.")
88    });
89
90    let action_tx = app
91        .get_action_sender()
92        .expect("Failed to get action sender");
93    let event_rx = app
94        .subscribe_events()
95        .expect("Failed to subscribe to events");
96
97    start_event_listener(event_rx, action_tx);
98
99    app.info("This message used for debugging 'TerminalLog' event.");
100
101    let _ = app
102        .run(&get_info!("App demo starting...", "Demo"), "")
103        .await;
104}

Source

pub fn clear_input_line(&mut self)

Clear the current input line and re-renders it.

Source

pub fn print_log_entry(&mut self, log_line: &str)

Prints a log entry while preserving the input line.

Clears the current line, prints the log message, and re-renders the input line.

§Arguments

stdout - Mutable reference to standard output
log_line - Log message to display

§Errors

Returns an error if writing to stdout fails.

Source

pub async fn handle_ctrl_d(&mut self) -> Result<bool, Box<dyn Error>>

Handles Ctrl+D key press, signaling application exit.

§Returns

Ok(true) to signal the application should quit.

Source

pub async fn handle_ctrl_c(&mut self) -> Result<(bool, String), Box<dyn Error>>

Handles Ctrl+C key press with double-press confirmation.

The first press clears input, the second press within 5 seconds exits.

§Returns

Tuple of (should_quit, message_to_display)

Source

pub async fn handle_enter_key( &mut self, input_prefix: &str, ) -> Result<bool, Box<dyn Error>>

Handles the enter key press event, executing commands and managing input history

Source

pub fn info(&mut self, message: &str)

Log info-level messages.

This method ensures proper terminal line management by clearing the current input line, printing the log message, and then re-rendering the input line.

§Arguments

message - The message content to be logged.

§Examples

use daemon_console::TerminalApp;

fn needless_main() {
    let mut app = TerminalApp::new();
    app.info("Application started successfully!");
    app.info("Running tasks...");
}

Examples found in repository ?

demo/main.rs (line 99)

83async fn main() {
84    let mut app = TerminalApp::new();
85
86    app.set_unknown_command_handler(|_| {
87        get_warn!("The command system disabled for developing the event system.")
88    });
89
90    let action_tx = app
91        .get_action_sender()
92        .expect("Failed to get action sender");
93    let event_rx = app
94        .subscribe_events()
95        .expect("Failed to subscribe to events");
96
97    start_event_listener(event_rx, action_tx);
98
99    app.info("This message used for debugging 'TerminalLog' event.");
100
101    let _ = app
102        .run(&get_info!("App demo starting...", "Demo"), "")
103        .await;
104}

Source

pub fn debug(&mut self, message: &str)

Log debug-level messages.

§Examples

use daemon_console::TerminalApp;

fn needless_main() {
    let mut app = TerminalApp::new();
    app.debug("Debugging information...");
    app.debug("Debugging more...");
}

Source

pub fn warn(&mut self, message: &str)

Log warn-level messages.

§Examples

use daemon_console::TerminalApp;

fn needless_main() {
    let mut app = TerminalApp::new();
    app.warn("You get a warning!");
    app.warn("Continue running...");
}

Source

pub fn error(&mut self, message: &str)

Log error-level messages.

§Examples

use daemon_console::TerminalApp;

fn needless_main() {
    let mut app = TerminalApp::new();
    app.error("An error occurred!");
    app.error("Failed to run tasks.");
}

Source

pub fn critical(&mut self, message: &str)

Log critical-level messages.

§Examples

use daemon_console::TerminalApp;

fn needless_main() {
    let mut app = TerminalApp::new();
    app.critical("Application crashed!");
    app.critical("Exception: unknown.");
}

Source

pub fn logger( &mut self, level: LogLevel, message: &str, module_name: Option<&str>, dp_evt: Option<bool>, )

Unified logger method that allows specifying a custom module name for the log message.

§Arguments

level - The log level (Info, Warn, Error, Debug, Critical)
message - The message content to be logged
module_name - The name of the module to associate with the log message (optional)
dispatch_event - Whether to dispatch log events (optional, defaults to true)

§Examples

use daemon_console::{TerminalApp, logger::LogLevel};

fn example() {
    let mut app = TerminalApp::new();
    app.logger(LogLevel::Info, "Application started", Some("Main"), None);
    app.logger(LogLevel::Error, "Database connection failed", None, Some(true));
}