mirror of https://github.com/sayanarijit/xplr
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
833 lines
32 KiB
Rust
833 lines
32 KiB
Rust
#![allow(clippy::too_many_arguments)]
|
|
|
|
use crate::app;
|
|
use crate::app::ExternalMsg;
|
|
use crate::cli::Cli;
|
|
use crate::event_reader::EventReader;
|
|
use crate::explorer;
|
|
use crate::lua;
|
|
use crate::pipe;
|
|
use crate::pwd_watcher;
|
|
use crate::ui;
|
|
use crate::yaml;
|
|
use anyhow::{bail, Error, Result};
|
|
use crossterm::event;
|
|
use crossterm::execute;
|
|
use crossterm::terminal as term;
|
|
use mlua::LuaSerdeExt;
|
|
use mlua::Value;
|
|
use std::fs;
|
|
use std::fs::File;
|
|
use std::io::Write;
|
|
use std::path::PathBuf;
|
|
use std::process::{Command, Stdio};
|
|
use std::sync::mpsc;
|
|
use tui::backend::CrosstermBackend;
|
|
use tui::Terminal;
|
|
use tui_input::Input;
|
|
|
|
pub fn get_tty() -> Result<fs::File> {
|
|
let tty = "/dev/tty";
|
|
match fs::OpenOptions::new().read(true).write(true).open(tty) {
|
|
Ok(f) => Ok(f),
|
|
Err(e) => {
|
|
bail!(format!("Failed to open {}. {}", tty, e))
|
|
}
|
|
}
|
|
}
|
|
|
|
// In unix system, the std::env::current_dir() calls libc getcwd() that
|
|
// returns physical path. As a workaround, this function tries to use `PWD`
|
|
// environment variable that is configured by shell.
|
|
fn get_current_dir() -> Result<PathBuf, std::io::Error> {
|
|
let cur = std::env::current_dir();
|
|
if let Ok(pwd) = std::env::var("PWD") {
|
|
if pwd.is_empty() {
|
|
cur
|
|
} else {
|
|
Ok(PathBuf::from(pwd))
|
|
}
|
|
} else {
|
|
cur
|
|
}
|
|
}
|
|
|
|
fn call_lua_heavy(
|
|
app: &app::App,
|
|
lua: &mlua::Lua,
|
|
func: &str,
|
|
_silent: bool,
|
|
) -> Result<Option<Vec<app::ExternalMsg>>> {
|
|
let arg = app.to_lua_ctx_heavy();
|
|
let arg = lua::serialize(lua, &arg)?;
|
|
lua::call(lua, func, arg)
|
|
}
|
|
|
|
fn call(
|
|
mut app: app::App,
|
|
cmd: app::Command,
|
|
silent: bool,
|
|
terminal: &mut Terminal<CrosstermBackend<File>>,
|
|
event_reader: &mut EventReader,
|
|
mouse_enabled: &mut bool,
|
|
delimiter: char,
|
|
) -> Result<app::App> {
|
|
if !silent {
|
|
if *mouse_enabled {
|
|
execute!(terminal.backend_mut(), event::DisableMouseCapture)
|
|
.unwrap_or_default();
|
|
}
|
|
|
|
event_reader.stop();
|
|
|
|
terminal.clear()?;
|
|
terminal.set_cursor(0, 0)?;
|
|
term::disable_raw_mode()?;
|
|
terminal.show_cursor()?;
|
|
}
|
|
|
|
app.write_pipes(delimiter)?;
|
|
let focus_index = app
|
|
.directory_buffer
|
|
.as_ref()
|
|
.map(|d| d.focus)
|
|
.unwrap_or_default()
|
|
.to_string();
|
|
|
|
let (stdin, stdout, stderr) = if silent {
|
|
(Stdio::null(), Stdio::null(), Stdio::null())
|
|
} else {
|
|
(get_tty()?.into(), get_tty()?.into(), get_tty()?.into())
|
|
};
|
|
|
|
let input_buffer = app
|
|
.input
|
|
.buffer
|
|
.as_ref()
|
|
.map(Input::to_string)
|
|
.unwrap_or_default();
|
|
|
|
let status = Command::new(cmd.command.clone())
|
|
.env("XPLR", &app.bin)
|
|
.env("XPLR_VROOT", &app.vroot.clone().unwrap_or_default())
|
|
.env("XPLR_APP_VERSION", &app.version)
|
|
.env("XPLR_PID", &app.pid.to_string())
|
|
.env("XPLR_INPUT_BUFFER", input_buffer)
|
|
.env("XPLR_INITIAL_PWD", &app.initial_pwd)
|
|
.env("XPLR_FOCUS_PATH", app.focused_node_str())
|
|
.env("XPLR_FOCUS_INDEX", focus_index)
|
|
.env("XPLR_SESSION_PATH", &app.session_path)
|
|
.env("XPLR_PIPE_MSG_IN", &app.pipe.msg_in)
|
|
.env("XPLR_PIPE_SELECTION_OUT", &app.pipe.selection_out)
|
|
.env("XPLR_PIPE_HISTORY_OUT", &app.pipe.history_out)
|
|
.env("XPLR_MODE", app.mode_str())
|
|
.env("XPLR_PIPE_RESULT_OUT", &app.pipe.result_out)
|
|
.env(
|
|
"XPLR_PIPE_GLOBAL_HELP_MENU_OUT",
|
|
&app.pipe.global_help_menu_out,
|
|
)
|
|
.env(
|
|
"XPLR_PIPE_DIRECTORY_NODES_OUT",
|
|
&app.pipe.directory_nodes_out,
|
|
)
|
|
.env("XPLR_PIPE_LOGS_OUT", &app.pipe.logs_out)
|
|
.stdin(stdin)
|
|
.stdout(stdout)
|
|
.stderr(stderr)
|
|
.args(cmd.args)
|
|
.status()
|
|
.map(|s| {
|
|
if s.success() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!("process exited with code {}", &s))
|
|
}
|
|
})
|
|
.unwrap_or_else(|e| Err(e.to_string()));
|
|
|
|
match pipe::read_all(&app.pipe.msg_in, delimiter) {
|
|
Ok(msgs) => {
|
|
app = app.handle_batch_external_msgs(msgs)?;
|
|
}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
};
|
|
|
|
app.cleanup_pipes()?;
|
|
|
|
if let Err(e) = status {
|
|
app = app.log_error(e)?;
|
|
};
|
|
|
|
if !silent {
|
|
terminal.clear()?;
|
|
term::enable_raw_mode()?;
|
|
terminal.hide_cursor()?;
|
|
event_reader.start();
|
|
|
|
if *mouse_enabled {
|
|
match execute!(terminal.backend_mut(), event::EnableMouseCapture) {
|
|
Ok(_) => {
|
|
*mouse_enabled = true;
|
|
}
|
|
Err(e) => {
|
|
app = app.log_error(e.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(app)
|
|
}
|
|
|
|
fn start_fifo(path: &str, focus_path: &str) -> Result<fs::File> {
|
|
match fs::OpenOptions::new().write(true).open(path) {
|
|
Ok(mut file) => {
|
|
writeln!(file, "{}", focus_path)?;
|
|
Ok(file)
|
|
}
|
|
Err(e) => Err(e.into()),
|
|
}
|
|
}
|
|
|
|
pub struct Runner {
|
|
bin: String,
|
|
vroot: Option<PathBuf>,
|
|
pwd: PathBuf,
|
|
focused_path: Option<PathBuf>,
|
|
config_file: Option<PathBuf>,
|
|
extra_config_files: Vec<PathBuf>,
|
|
on_load: Vec<app::ExternalMsg>,
|
|
read_only: bool,
|
|
print_pwd_as_result: bool,
|
|
selection: Vec<PathBuf>,
|
|
delimiter: char,
|
|
}
|
|
|
|
impl Runner {
|
|
/// Create a new runner object passing the default arguments
|
|
pub fn new() -> Result<Self> {
|
|
Self::from_cli(Default::default())
|
|
}
|
|
|
|
/// Create a new runner object passing the given arguments
|
|
pub fn from_cli(cli: Cli) -> Result<Self> {
|
|
let currdir = get_current_dir()?;
|
|
let mut paths = cli.paths.into_iter();
|
|
let mut pwd = paths
|
|
.next()
|
|
.or_else(|| cli.vroot.clone())
|
|
.unwrap_or_else(|| currdir.clone());
|
|
let mut focused_path = None;
|
|
|
|
if cli.force_focus || pwd.is_file() {
|
|
focused_path = pwd.file_name().map(|p| p.into());
|
|
pwd = pwd.parent().map(|p| p.into()).unwrap_or(currdir);
|
|
}
|
|
|
|
Ok(Self {
|
|
bin: cli.bin,
|
|
vroot: cli.vroot,
|
|
pwd,
|
|
focused_path,
|
|
config_file: cli.config,
|
|
extra_config_files: cli.extra_config,
|
|
on_load: cli.on_load,
|
|
read_only: cli.read_only,
|
|
print_pwd_as_result: cli.print_pwd_as_result,
|
|
selection: paths.collect(),
|
|
delimiter: if cli.write0 { '\0' } else { '\n' },
|
|
})
|
|
}
|
|
|
|
/// Run the instance
|
|
pub fn run(self) -> Result<Option<String>> {
|
|
// Why unsafe? See https://github.com/sayanarijit/xplr/issues/309
|
|
let lua = unsafe { mlua::Lua::unsafe_new() };
|
|
let mut app = app::App::create(
|
|
self.bin,
|
|
self.vroot,
|
|
self.pwd,
|
|
&lua,
|
|
self.config_file,
|
|
self.extra_config_files,
|
|
)?;
|
|
app.config.general.read_only = self.read_only;
|
|
|
|
fs::create_dir_all(app.session_path.clone())?;
|
|
|
|
let (tx_msg_in, rx_msg_in) = mpsc::channel();
|
|
let (tx_pwd_watcher, rx_pwd_watcher) = mpsc::channel();
|
|
|
|
app = app.explore_pwd()?;
|
|
|
|
for file in self.selection {
|
|
app = app.select_path(file.to_string_lossy().to_string())?;
|
|
}
|
|
|
|
app = if let Some(f) = self
|
|
.focused_path
|
|
.clone()
|
|
.map(|f| f.to_string_lossy().to_string())
|
|
{
|
|
app.focus_by_file_name(&f, true)?
|
|
} else {
|
|
app.focus_first(true)?
|
|
};
|
|
|
|
explorer::explore_recursive_async(
|
|
app.explorer_config.clone(),
|
|
app.pwd.clone().into(),
|
|
self.focused_path,
|
|
app.directory_buffer.as_ref().map(|d| d.focus).unwrap_or(0),
|
|
tx_msg_in.clone(),
|
|
);
|
|
tx_pwd_watcher.send(app.pwd.clone())?;
|
|
|
|
let mut result = Ok(None);
|
|
let session_path = app.session_path.to_owned();
|
|
|
|
term::enable_raw_mode()?;
|
|
|
|
// Use a tty to enable piping results
|
|
let mut stdout = get_tty()?;
|
|
// let stdout = io::stdout();
|
|
// let mut stdout = stdout.lock();
|
|
execute!(stdout, term::EnterAlternateScreen)?;
|
|
|
|
let mut fifo: Option<fs::File> =
|
|
if let Some(path) = app.config.general.start_fifo.as_ref() {
|
|
// TODO remove duplicate segment
|
|
match start_fifo(path, &app.focused_node_str()) {
|
|
Ok(file) => Some(file),
|
|
Err(e) => {
|
|
app = app.log_error(e.to_string())?;
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let mut last_focus: Option<app::Node> = None;
|
|
let mut last_pwd = app.pwd.clone();
|
|
|
|
let mut mouse_enabled = app.config.general.enable_mouse;
|
|
if mouse_enabled {
|
|
if let Err(e) = execute!(stdout, event::EnableMouseCapture) {
|
|
app = app.log_error(e.to_string())?;
|
|
}
|
|
}
|
|
|
|
let backend = CrosstermBackend::new(stdout);
|
|
let mut terminal = Terminal::new(backend)?;
|
|
terminal.hide_cursor()?;
|
|
terminal.clear()?;
|
|
|
|
// Threads
|
|
pwd_watcher::keep_watching(app.pwd.as_ref(), tx_msg_in.clone(), rx_pwd_watcher)?;
|
|
let mut event_reader = EventReader::new(tx_msg_in.clone());
|
|
event_reader.start();
|
|
|
|
// Enqueue on_load messages
|
|
for msg in app.hooks.on_load.iter().chain(self.on_load.iter()) {
|
|
tx_msg_in.send(app::Task::new(app::MsgIn::External(msg.clone()), None))?;
|
|
}
|
|
|
|
// Refresh screen once after loading
|
|
tx_msg_in.send(app::Task::new(
|
|
app::MsgIn::External(app::ExternalMsg::Refresh),
|
|
None,
|
|
))?;
|
|
|
|
'outer: for task in rx_msg_in {
|
|
match app.handle_task(task) {
|
|
Ok(a) => {
|
|
app = a;
|
|
while let Some(msg) = app.msg_out.pop_front() {
|
|
use app::MsgOut::*;
|
|
match msg {
|
|
// NOTE: Do not schedule critical tasks via tx_msg_in in this loop.
|
|
// Try handling them immediately.
|
|
Enque(task) => {
|
|
tx_msg_in.send(task)?;
|
|
}
|
|
|
|
Quit => {
|
|
result = Ok(None);
|
|
break 'outer;
|
|
}
|
|
|
|
PrintPwdAndQuit => {
|
|
result = Ok(Some(app.pwd_str(self.delimiter)));
|
|
break 'outer;
|
|
}
|
|
|
|
PrintFocusPathAndQuit => {
|
|
result = Ok(app.focused_node().map(|n| {
|
|
format!("{}{}", n.absolute_path, self.delimiter)
|
|
}));
|
|
break 'outer;
|
|
}
|
|
|
|
PrintSelectionAndQuit => {
|
|
result = Ok(Some(app.selection_str(self.delimiter)));
|
|
break 'outer;
|
|
}
|
|
|
|
PrintResultAndQuit => {
|
|
result = if self.print_pwd_as_result {
|
|
Ok(Some(app.pwd_str(self.delimiter)))
|
|
} else {
|
|
Ok(Some(app.result_str(self.delimiter)))
|
|
};
|
|
|
|
break 'outer;
|
|
}
|
|
|
|
PrintAppStateAndQuit => {
|
|
let out = yaml::to_string(&app)?;
|
|
result = Ok(Some(out));
|
|
break 'outer;
|
|
}
|
|
|
|
Debug(path) => {
|
|
fs::write(&path, yaml::to_string(&app)?)?;
|
|
}
|
|
|
|
ClearScreen => {
|
|
terminal.clear()?;
|
|
}
|
|
|
|
ScrollUp => {
|
|
app = app.focus_previous_by_relative_index(
|
|
terminal.size()?.height as usize,
|
|
)?;
|
|
}
|
|
|
|
ScrollDown => {
|
|
app = app.focus_next_by_relative_index(
|
|
terminal.size()?.height as usize,
|
|
)?;
|
|
}
|
|
|
|
ScrollUpHalf => {
|
|
app = app.focus_next_by_relative_index(
|
|
terminal.size()?.height as usize / 2,
|
|
)?;
|
|
}
|
|
|
|
ScrollDownHalf => {
|
|
app = app.focus_next_by_relative_index(
|
|
terminal.size()?.height as usize / 2,
|
|
)?;
|
|
}
|
|
|
|
ExplorePwdAsync => {
|
|
explorer::explore_async(
|
|
app.explorer_config.clone(),
|
|
app.pwd.clone().into(),
|
|
app.focused_node()
|
|
.map(|n| n.relative_path.clone().into()),
|
|
app.directory_buffer
|
|
.as_ref()
|
|
.map(|d| d.focus)
|
|
.unwrap_or(0),
|
|
tx_msg_in.clone(),
|
|
);
|
|
tx_pwd_watcher.send(app.pwd.clone())?;
|
|
}
|
|
|
|
ExploreParentsAsync => {
|
|
explorer::explore_recursive_async(
|
|
app.explorer_config.clone(),
|
|
app.pwd.clone().into(),
|
|
app.focused_node()
|
|
.map(|n| n.relative_path.clone().into()),
|
|
app.directory_buffer
|
|
.as_ref()
|
|
.map(|d| d.focus)
|
|
.unwrap_or(0),
|
|
tx_msg_in.clone(),
|
|
);
|
|
tx_pwd_watcher.send(app.pwd.clone())?;
|
|
}
|
|
|
|
Refresh => {
|
|
let focus = app.focused_node();
|
|
if focus != last_focus.as_ref() {
|
|
last_focus = focus.cloned();
|
|
|
|
// Fifo
|
|
if let Some(ref mut file) = fifo {
|
|
writeln!(file, "{}", app.focused_node_str())?;
|
|
};
|
|
|
|
// Hooks
|
|
if !app.hooks.on_focus_change.is_empty() {
|
|
let msgs = app.hooks.on_focus_change.clone();
|
|
app = app.handle_batch_external_msgs(msgs)?
|
|
}
|
|
}
|
|
|
|
if app.pwd != last_pwd {
|
|
last_pwd = app.pwd.clone();
|
|
|
|
// $PWD watcher
|
|
tx_pwd_watcher.send(app.pwd.clone())?;
|
|
|
|
// OSC 7: Change CWD
|
|
if !(*ui::NO_COLOR) {
|
|
write!(
|
|
terminal.backend_mut(),
|
|
"\x1b]7;file://{}{}\x1b\\",
|
|
&app.hostname,
|
|
&app.pwd
|
|
)?;
|
|
}
|
|
|
|
// Hooks
|
|
if !app.hooks.on_directory_change.is_empty() {
|
|
let msgs = app.hooks.on_directory_change.clone();
|
|
app = app.handle_batch_external_msgs(msgs)?
|
|
}
|
|
}
|
|
|
|
// UI
|
|
terminal.draw(|f| ui::draw(f, &app, &lua))?;
|
|
}
|
|
|
|
EnableMouse => {
|
|
if !mouse_enabled {
|
|
match execute!(
|
|
terminal.backend_mut(),
|
|
event::EnableMouseCapture
|
|
) {
|
|
Ok(_) => {
|
|
mouse_enabled = true;
|
|
}
|
|
Err(e) => {
|
|
app = app.log_error(e.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ToggleMouse => {
|
|
let msg = if mouse_enabled {
|
|
app::ExternalMsg::DisableMouse
|
|
} else {
|
|
app::ExternalMsg::EnableMouse
|
|
};
|
|
app = app.handle_task(app::Task::new(
|
|
app::MsgIn::External(msg),
|
|
None,
|
|
))?;
|
|
}
|
|
|
|
DisableMouse => {
|
|
if mouse_enabled {
|
|
match execute!(
|
|
terminal.backend_mut(),
|
|
event::DisableMouseCapture
|
|
) {
|
|
Ok(_) => {
|
|
mouse_enabled = false;
|
|
}
|
|
Err(e) => {
|
|
app = app.log_error(e.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
StartFifo(path) => {
|
|
fifo = match start_fifo(&path, &app.focused_node_str()) {
|
|
Ok(file) => Some(file),
|
|
Err(e) => {
|
|
app = app.log_error(e.to_string())?;
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
StopFifo => {
|
|
if let Some(file) = fifo {
|
|
fifo = None;
|
|
std::mem::drop(file);
|
|
}
|
|
}
|
|
|
|
ToggleFifo(path) => {
|
|
if let Some(file) = fifo {
|
|
fifo = None;
|
|
std::mem::drop(file);
|
|
} else {
|
|
fifo =
|
|
match start_fifo(&path, &app.focused_node_str())
|
|
{
|
|
Ok(file) => Some(file),
|
|
Err(e) => {
|
|
app = app.log_error(e.to_string())?;
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CallLuaSilently(func) => {
|
|
match call_lua_heavy(&app, &lua, &func, false) {
|
|
Ok(Some(msgs)) => {
|
|
app = app.handle_batch_external_msgs(msgs)?;
|
|
}
|
|
Ok(None) => {}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
};
|
|
}
|
|
|
|
CallLua(func) => {
|
|
execute!(
|
|
terminal.backend_mut(),
|
|
event::DisableMouseCapture
|
|
)
|
|
.unwrap_or_default();
|
|
|
|
event_reader.stop();
|
|
|
|
terminal.clear()?;
|
|
terminal.set_cursor(0, 0)?;
|
|
term::disable_raw_mode()?;
|
|
terminal.show_cursor()?;
|
|
|
|
match call_lua_heavy(&app, &lua, &func, false) {
|
|
Ok(Some(msgs)) => {
|
|
app = app.handle_batch_external_msgs(msgs)?;
|
|
}
|
|
Ok(None) => {}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
};
|
|
|
|
terminal.clear()?;
|
|
term::enable_raw_mode()?;
|
|
terminal.hide_cursor()?;
|
|
event_reader.start();
|
|
|
|
if mouse_enabled {
|
|
match execute!(
|
|
terminal.backend_mut(),
|
|
event::EnableMouseCapture
|
|
) {
|
|
Ok(_) => {
|
|
mouse_enabled = true;
|
|
}
|
|
Err(e) => {
|
|
app = app.log_error(e.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LuaEval(code) => {
|
|
execute!(
|
|
terminal.backend_mut(),
|
|
event::DisableMouseCapture
|
|
)
|
|
.unwrap_or_default();
|
|
|
|
event_reader.stop();
|
|
|
|
terminal.clear()?;
|
|
terminal.set_cursor(0, 0)?;
|
|
term::disable_raw_mode()?;
|
|
terminal.show_cursor()?;
|
|
|
|
let res: Result<Value> =
|
|
lua.load(&code).eval().map_err(Error::from);
|
|
|
|
match res {
|
|
Ok(Value::Function(f)) => {
|
|
let arg = app.to_lua_ctx_heavy();
|
|
let res: Result<Option<Vec<ExternalMsg>>> = lua
|
|
.to_value(&arg)
|
|
.and_then(|a| f.call(a))
|
|
.and_then(|v| lua.from_value(v))
|
|
.map_err(Error::from);
|
|
match res {
|
|
Ok(Some(msgs)) => {
|
|
app = app
|
|
.handle_batch_external_msgs(msgs)?;
|
|
}
|
|
Ok(None) => {}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
Ok(v) => {
|
|
let res: Result<Option<Vec<ExternalMsg>>> =
|
|
lua.from_value(v).map_err(Error::from);
|
|
match res {
|
|
Ok(Some(msgs)) => {
|
|
app = app
|
|
.handle_batch_external_msgs(msgs)?;
|
|
}
|
|
Ok(None) => {}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
};
|
|
|
|
terminal.clear()?;
|
|
term::enable_raw_mode()?;
|
|
terminal.hide_cursor()?;
|
|
event_reader.start();
|
|
|
|
if mouse_enabled {
|
|
match execute!(
|
|
terminal.backend_mut(),
|
|
event::EnableMouseCapture
|
|
) {
|
|
Ok(_) => {
|
|
mouse_enabled = true;
|
|
}
|
|
Err(e) => {
|
|
app = app.log_error(e.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LuaEvalSilently(code) => {
|
|
let res: Result<Value> =
|
|
lua.load(&code).eval().map_err(Error::from);
|
|
|
|
match res {
|
|
Ok(Value::Function(f)) => {
|
|
let arg = app.to_lua_ctx_heavy();
|
|
let res: Result<Option<Vec<ExternalMsg>>> = lua
|
|
.to_value(&arg)
|
|
.and_then(|a| f.call(a))
|
|
.and_then(|v| lua.from_value(v))
|
|
.map_err(Error::from);
|
|
match res {
|
|
Ok(Some(msgs)) => {
|
|
app = app
|
|
.handle_batch_external_msgs(msgs)?;
|
|
}
|
|
Ok(None) => {}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
Ok(v) => {
|
|
let res: Result<Option<Vec<ExternalMsg>>> =
|
|
lua.from_value(v).map_err(Error::from);
|
|
match res {
|
|
Ok(Some(msgs)) => {
|
|
app = app
|
|
.handle_batch_external_msgs(msgs)?;
|
|
}
|
|
Ok(None) => {}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
app = app.log_error(err.to_string())?;
|
|
}
|
|
};
|
|
}
|
|
|
|
Call(cmd) => {
|
|
app = call(
|
|
app,
|
|
cmd,
|
|
false,
|
|
&mut terminal,
|
|
&mut event_reader,
|
|
&mut mouse_enabled,
|
|
'\n',
|
|
)?;
|
|
}
|
|
|
|
Call0(cmd) => {
|
|
app = call(
|
|
app,
|
|
cmd,
|
|
false,
|
|
&mut terminal,
|
|
&mut event_reader,
|
|
&mut mouse_enabled,
|
|
'\0',
|
|
)?;
|
|
}
|
|
|
|
CallSilently(cmd) => {
|
|
app = call(
|
|
app,
|
|
cmd,
|
|
true,
|
|
&mut terminal,
|
|
&mut event_reader,
|
|
&mut mouse_enabled,
|
|
'\n',
|
|
)?;
|
|
}
|
|
|
|
CallSilently0(cmd) => {
|
|
app = call(
|
|
app,
|
|
cmd,
|
|
true,
|
|
&mut terminal,
|
|
&mut event_reader,
|
|
&mut mouse_enabled,
|
|
'\0',
|
|
)?;
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
Err(e) => {
|
|
result = Err(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
terminal.clear()?;
|
|
terminal.set_cursor(0, 0)?;
|
|
execute!(terminal.backend_mut(), term::LeaveAlternateScreen)?;
|
|
execute!(terminal.backend_mut(), event::DisableMouseCapture).unwrap_or_default();
|
|
term::disable_raw_mode()?;
|
|
terminal.show_cursor()?;
|
|
|
|
fs::remove_dir_all(session_path)?;
|
|
|
|
result
|
|
}
|
|
}
|
|
|
|
/// Create a new runner object passing the default arguments
|
|
pub fn runner() -> Result<Runner> {
|
|
Runner::new()
|
|
}
|
|
|
|
/// Create a new runner object passing the given arguments
|
|
pub fn from_cli(cli: Cli) -> Result<Runner> {
|
|
Runner::from_cli(cli)
|
|
}
|