extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-04-24 13:18:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup of src/main.rs (#7801)

Browse Source 
While reading nushell's code, I've started to clean up `src/main.rs` a
bit.
The description of the changes can be found in the commit messages.
This commit is contained in:
Hofer-Julian 2023-01-20 19:44:49 +01:00 committed by GitHub
parent cde56741fb
commit 24aa1f312a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 236 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
src/main.rs
View File

@ -1,5 +1,6 @@
mod config_files; mod config_files;
mod logger; mod logger;
mod signals;
mod test_bins; mod test_bins;
#[cfg(test)] #[cfg(test)]
mod tests; mod tests;
@ -27,12 +28,10 @@ use nu_protocol::{
SyntaxShape, Value, SyntaxShape, Value,
}; };
use nu_utils::stdout_write_all_and_flush; use nu_utils::stdout_write_all_and_flush;
use signals::{ctrlc_protection, sigquit_protection};
use std::{ use std::{
io::BufReader, io::BufReader,
sync::{ sync::{atomic::AtomicBool, Arc},
atomic::{AtomicBool, Ordering},
Arc,
},
}; };
use std::{path::Path, str::FromStr}; use std::{path::Path, str::FromStr};
@ -136,7 +135,6 @@ fn acquire_terminal(interactive: bool) {
fn acquire_terminal(_: bool) {} fn acquire_terminal(_: bool) {}
fn main() -> Result<()> { fn main() -> Result<()> {
// miette::set_panic_hook();
let miette_hook = std::panic::take_hook(); let miette_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |x| { std::panic::set_hook(Box::new(move |x| {
crossterm::terminal::disable_raw_mode().expect("unable to disable raw mode"); crossterm::terminal::disable_raw_mode().expect("unable to disable raw mode");
@ -152,7 +150,6 @@ fn main() -> Result<()> {
let mut working_set = nu_protocol::engine::StateWorkingSet::new(&engine_state); let mut working_set = nu_protocol::engine::StateWorkingSet::new(&engine_state);
working_set.add_decl(Box::new(nu_cli::NuHighlight)); working_set.add_decl(Box::new(nu_cli::NuHighlight));
working_set.add_decl(Box::new(nu_cli::Print)); working_set.add_decl(Box::new(nu_cli::Print));
working_set.render() working_set.render()
}; };
@ -160,29 +157,10 @@ fn main() -> Result<()> {
report_error_new(&engine_state, &err); report_error_new(&engine_state, &err);
} }
// TODO: make this conditional in the future
// Ctrl-c protection section
let ctrlc = Arc::new(AtomicBool::new(false)); let ctrlc = Arc::new(AtomicBool::new(false));
let handler_ctrlc = ctrlc.clone(); // TODO: make this conditional in the future
let engine_state_ctrlc = ctrlc.clone(); ctrlc_protection(&mut engine_state, &ctrlc);
sigquit_protection(&mut engine_state);
ctrlc::set_handler(move || {
handler_ctrlc.store(true, Ordering::SeqCst);
})
.expect("Error setting Ctrl-C handler");
engine_state.ctrlc = Some(engine_state_ctrlc);
// End ctrl-c protection section
// SIGQUIT protection section (only works for POSIX system)
#[cfg(not(windows))]
{
use signal_hook::consts::SIGQUIT;
let sig_quit = Arc::new(AtomicBool::new(false));
signal_hook::flag::register(SIGQUIT, sig_quit.clone()).expect("Error setting SIGQUIT flag");
engine_state.set_sig_quit(sig_quit);
}
// End SIGQUIT protection section
let mut args_to_nushell = vec![]; let mut args_to_nushell = vec![];
let mut script_name = String::new(); let mut script_name = String::new();
@ -231,15 +209,15 @@ fn main() -> Result<()> {
let nushell_commandline_args = args_to_nushell.join(" "); let nushell_commandline_args = args_to_nushell.join(" ");
let parsed_nu_cli_args = parse_commandline_args(&nushell_commandline_args, &mut engine_state); let parsed_nu_cli_args = parse_commandline_args(&nushell_commandline_args, &mut engine_state)
.unwrap_or_else(|_| std::process::exit(1));
if let Ok(ref args) = parsed_nu_cli_args {
set_config_path( set_config_path(
&mut engine_state, &mut engine_state,
&init_cwd, &init_cwd,
"config.nu", "config.nu",
"config-path", "config-path",
&args.config_file, &parsed_nu_cli_args.config_file,
); );
set_config_path( set_config_path(
@ -247,19 +225,16 @@ fn main() -> Result<()> {
&init_cwd, &init_cwd,
"env.nu", "env.nu",
"env-path", "env-path",
&args.env_file, &parsed_nu_cli_args.env_file,
); );
}
match parsed_nu_cli_args {
Ok(binary_args) => {
// keep this condition in sync with the branches below // keep this condition in sync with the branches below
acquire_terminal( acquire_terminal(
binary_args.commands.is_none() parsed_nu_cli_args.commands.is_none()
&& (script_name.is_empty() || binary_args.interactive_shell.is_some()), && (script_name.is_empty() || parsed_nu_cli_args.interactive_shell.is_some()),
); );
if let Some(t) = binary_args.threads { if let Some(t) = parsed_nu_cli_args.threads {
// 0 means to let rayon decide how many threads to use // 0 means to let rayon decide how many threads to use
let threads = t.as_i64().unwrap_or(0); let threads = t.as_i64().unwrap_or(0);
rayon::ThreadPoolBuilder::new() rayon::ThreadPoolBuilder::new()
@ -268,27 +243,25 @@ fn main() -> Result<()> {
.expect("error setting number of threads"); .expect("error setting number of threads");
} }
if binary_args.log_level.is_some() { if let Some(level) = parsed_nu_cli_args.log_level.map(|level| level.item) {
let mut level = binary_args let level = if Level::from_str(&level).is_ok() {
.log_level level
.map(|level| level.item) } else {
.unwrap_or_else(|| "info".to_string()); eprintln!(
"ERROR: log library did not recognize log level '{level}', using default 'info'"
if Level::from_str(level.as_str()).is_err() { );
eprintln!("ERROR: log library did not recognize log level '{level}', using default 'info'"); "info".to_string()
level = "info".to_string(); };
} let target = parsed_nu_cli_args
let target = binary_args
.log_target .log_target
.map(|target| target.item) .map(|target| target.item)
.unwrap_or_else(|| "stderr".to_string()); .unwrap_or_else(|| "stderr".to_string());
logger(|builder| configure(level.as_str(), target.as_str(), builder))?; logger(|builder| configure(&level, &target, builder))?;
info!("start logging {}:{}:{}", file!(), line!(), column!()); info!("start logging {}:{}:{}", file!(), line!(), column!());
} }
if let Some(testbin) = &binary_args.testbin { if let Some(testbin) = &parsed_nu_cli_args.testbin {
// Call out to the correct testbin // Call out to the correct testbin
match testbin.item.as_str() { match testbin.item.as_str() {
"echo_env" => test_bins::echo_env(true), "echo_env" => test_bins::echo_env(true),
@ -307,7 +280,7 @@ fn main() -> Result<()> {
} }
std::process::exit(0) std::process::exit(0)
} }
let input = if let Some(redirect_stdin) = &binary_args.redirect_stdin { let input = if let Some(redirect_stdin) = &parsed_nu_cli_args.redirect_stdin {
let stdin = std::io::stdin(); let stdin = std::io::stdin();
let buf_reader = BufReader::new(stdin); let buf_reader = BufReader::new(stdin);
@ -335,32 +308,32 @@ fn main() -> Result<()> {
let mut stack = nu_protocol::engine::Stack::new(); let mut stack = nu_protocol::engine::Stack::new();
if let Some(commands) = &binary_args.commands { if let Some(commands) = &parsed_nu_cli_args.commands {
#[cfg(feature = "plugin")] #[cfg(feature = "plugin")]
read_plugin_file( read_plugin_file(
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
binary_args.plugin_file, parsed_nu_cli_args.plugin_file,
NUSHELL_FOLDER, NUSHELL_FOLDER,
); );
// only want to load config and env if relative argument is provided. // only want to load config and env if relative argument is provided.
if binary_args.env_file.is_some() { if parsed_nu_cli_args.env_file.is_some() {
config_files::read_config_file( config_files::read_config_file(
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
binary_args.env_file, parsed_nu_cli_args.env_file,
true, true,
); );
} else { } else {
config_files::read_default_env_file(&mut engine_state, &mut stack) config_files::read_default_env_file(&mut engine_state, &mut stack)
} }
if binary_args.config_file.is_some() { if parsed_nu_cli_args.config_file.is_some() {
config_files::read_config_file( config_files::read_config_file(
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
binary_args.config_file, parsed_nu_cli_args.config_file,
false, false,
); );
} }
@ -370,7 +343,7 @@ fn main() -> Result<()> {
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
input, input,
binary_args.table_mode, parsed_nu_cli_args.table_mode,
); );
info!("-c command execution {}:{}:{}", file!(), line!(), column!()); info!("-c command execution {}:{}:{}", file!(), line!(), column!());
match ret_val { match ret_val {
@ -378,32 +351,32 @@ fn main() -> Result<()> {
Ok(None) => Ok(()), Ok(None) => Ok(()),
Err(e) => Err(e), Err(e) => Err(e),
} }
} else if !script_name.is_empty() && binary_args.interactive_shell.is_none() { } else if !script_name.is_empty() && parsed_nu_cli_args.interactive_shell.is_none() {
#[cfg(feature = "plugin")] #[cfg(feature = "plugin")]
read_plugin_file( read_plugin_file(
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
binary_args.plugin_file, parsed_nu_cli_args.plugin_file,
NUSHELL_FOLDER, NUSHELL_FOLDER,
); );
// only want to load config and env if relative argument is provided. // only want to load config and env if relative argument is provided.
if binary_args.env_file.is_some() { if parsed_nu_cli_args.env_file.is_some() {
config_files::read_config_file( config_files::read_config_file(
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
binary_args.env_file, parsed_nu_cli_args.env_file,
true, true,
); );
} else { } else {
config_files::read_default_env_file(&mut engine_state, &mut stack) config_files::read_default_env_file(&mut engine_state, &mut stack)
} }
if binary_args.config_file.is_some() { if parsed_nu_cli_args.config_file.is_some() {
config_files::read_config_file( config_files::read_config_file(
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
binary_args.config_file, parsed_nu_cli_args.config_file,
false, false,
); );
} }
@ -433,26 +406,23 @@ fn main() -> Result<()> {
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
#[cfg(feature = "plugin")] #[cfg(feature = "plugin")]
binary_args.plugin_file, parsed_nu_cli_args.plugin_file,
binary_args.config_file, parsed_nu_cli_args.config_file,
binary_args.env_file, parsed_nu_cli_args.env_file,
binary_args.login_shell.is_some(), parsed_nu_cli_args.login_shell.is_some(),
); );
let ret_val = evaluate_repl( let ret_val = evaluate_repl(
&mut engine_state, &mut engine_state,
&mut stack, &mut stack,
config_files::NUSHELL_FOLDER, config_files::NUSHELL_FOLDER,
binary_args.execute, parsed_nu_cli_args.execute,
); );
info!("repl eval {}:{}:{}", file!(), line!(), column!()); info!("repl eval {}:{}:{}", file!(), line!(), column!());
ret_val ret_val
} }
} }
Err(_) => std::process::exit(1),
}
}
fn setup_config( fn setup_config(
engine_state: &mut EngineState, engine_state: &mut EngineState,

29
src/signals.rs Normal file
View File

@ -0,0 +1,29 @@
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
use nu_protocol::engine::EngineState;
pub(crate) fn ctrlc_protection(engine_state: &mut EngineState, ctrlc: &Arc<AtomicBool>) {
let handler_ctrlc = ctrlc.clone();
let engine_state_ctrlc = ctrlc.clone();
ctrlc::set_handler(move || {
handler_ctrlc.store(true, Ordering::SeqCst);
})
.expect("Error setting Ctrl-C handler");
engine_state.ctrlc = Some(engine_state_ctrlc);
}
#[cfg(not(windows))]
pub(crate) fn sigquit_protection(engine_state: &mut EngineState) {
use signal_hook::consts::SIGQUIT;
let sig_quit = Arc::new(AtomicBool::new(false));
signal_hook::flag::register(SIGQUIT, sig_quit.clone()).expect("Error setting SIGQUIT flag");
engine_state.set_sig_quit(sig_quit);
}
#[cfg(windows)]
pub(crate) fn sigquit_protection(_engine_state: &mut EngineState) {}