2022-02-09 22:08:16 +00:00
|
|
|
use log::info;
|
2023-01-20 21:20:38 +00:00
|
|
|
#[cfg(feature = "plugin")]
|
|
|
|
use nu_cli::read_plugin_file;
|
2023-03-20 04:05:22 +00:00
|
|
|
use nu_cli::{eval_config_contents, eval_source};
|
|
|
|
use nu_command::util::report_error;
|
2022-02-19 20:54:43 +00:00
|
|
|
use nu_path::canonicalize_with;
|
2022-07-14 14:09:27 +00:00
|
|
|
use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
|
2023-04-07 00:35:45 +00:00
|
|
|
use nu_protocol::{ParseError, PipelineData, Spanned};
|
2022-08-01 01:44:33 +00:00
|
|
|
use nu_utils::{get_default_config, get_default_env};
|
2022-02-20 10:08:53 +00:00
|
|
|
use std::fs::File;
|
|
|
|
use std::io::Write;
|
2023-01-20 21:20:38 +00:00
|
|
|
use std::path::Path;
|
2022-01-18 08:48:28 +00:00
|
|
|
|
2022-03-16 18:17:06 +00:00
|
|
|
pub(crate) const NUSHELL_FOLDER: &str = "nushell";
|
2022-01-18 08:48:28 +00:00
|
|
|
const CONFIG_FILE: &str = "config.nu";
|
2022-04-06 17:11:51 +00:00
|
|
|
const ENV_FILE: &str = "env.nu";
|
2022-06-06 11:52:37 +00:00
|
|
|
const LOGINSHELL_FILE: &str = "login.nu";
|
2022-02-26 08:57:51 +00:00
|
|
|
|
2022-02-19 20:54:43 +00:00
|
|
|
pub(crate) fn read_config_file(
|
|
|
|
engine_state: &mut EngineState,
|
|
|
|
stack: &mut Stack,
|
|
|
|
config_file: Option<Spanned<String>>,
|
2022-04-06 17:11:51 +00:00
|
|
|
is_env_config: bool,
|
2022-02-19 20:54:43 +00:00
|
|
|
) {
|
2022-01-18 08:48:28 +00:00
|
|
|
// Load config startup file
|
2022-02-19 20:54:43 +00:00
|
|
|
if let Some(file) = config_file {
|
|
|
|
let working_set = StateWorkingSet::new(engine_state);
|
|
|
|
let cwd = working_set.get_cwd();
|
|
|
|
|
2023-01-24 11:23:42 +00:00
|
|
|
if let Ok(path) = canonicalize_with(&file.item, cwd) {
|
|
|
|
eval_config_contents(path, engine_state, stack);
|
|
|
|
} else {
|
|
|
|
let e = ParseError::FileNotFound(file.item, file.span);
|
|
|
|
report_error(&working_set, &e);
|
2022-02-19 20:54:43 +00:00
|
|
|
}
|
|
|
|
} else if let Some(mut config_path) = nu_path::config_dir() {
|
2022-01-18 08:48:28 +00:00
|
|
|
config_path.push(NUSHELL_FOLDER);
|
|
|
|
|
|
|
|
// Create config directory if it does not exist
|
|
|
|
if !config_path.exists() {
|
|
|
|
if let Err(err) = std::fs::create_dir_all(&config_path) {
|
2023-01-30 01:37:54 +00:00
|
|
|
eprintln!("Failed to create config directory: {err}");
|
2022-02-19 20:54:43 +00:00
|
|
|
return;
|
2022-01-18 08:48:28 +00:00
|
|
|
}
|
2022-02-19 20:54:43 +00:00
|
|
|
}
|
|
|
|
|
2022-04-06 17:11:51 +00:00
|
|
|
config_path.push(if is_env_config { ENV_FILE } else { CONFIG_FILE });
|
2022-02-20 10:08:53 +00:00
|
|
|
|
2022-07-10 12:16:46 +00:00
|
|
|
if !config_path.exists() {
|
2022-04-06 17:11:51 +00:00
|
|
|
let file_msg = if is_env_config {
|
|
|
|
"environment config"
|
|
|
|
} else {
|
|
|
|
"config"
|
|
|
|
};
|
|
|
|
println!(
|
|
|
|
"No {} file found at {}",
|
|
|
|
file_msg,
|
|
|
|
config_path.to_string_lossy()
|
|
|
|
);
|
2022-02-25 18:58:47 +00:00
|
|
|
println!("Would you like to create one with defaults (Y/n): ");
|
2022-02-20 10:08:53 +00:00
|
|
|
|
|
|
|
let mut answer = String::new();
|
|
|
|
std::io::stdin()
|
|
|
|
.read_line(&mut answer)
|
|
|
|
.expect("Failed to read user input");
|
|
|
|
|
2022-07-10 12:16:46 +00:00
|
|
|
let config_file = if is_env_config {
|
2022-08-01 01:44:33 +00:00
|
|
|
get_default_env()
|
2022-07-10 12:16:46 +00:00
|
|
|
} else {
|
2022-08-01 01:44:33 +00:00
|
|
|
get_default_config()
|
2022-07-10 12:16:46 +00:00
|
|
|
};
|
|
|
|
|
2022-02-20 10:08:53 +00:00
|
|
|
match answer.to_lowercase().trim() {
|
2023-01-24 11:23:42 +00:00
|
|
|
"y" | "" => {
|
|
|
|
if let Ok(mut output) = File::create(&config_path) {
|
2023-01-30 01:37:54 +00:00
|
|
|
if write!(output, "{config_file}").is_ok() {
|
2022-12-21 22:16:08 +00:00
|
|
|
let config_type = if is_env_config {
|
|
|
|
"Environment config"
|
|
|
|
} else {
|
|
|
|
"Config"
|
|
|
|
};
|
|
|
|
println!(
|
|
|
|
"{} file created at: {}",
|
|
|
|
config_type,
|
|
|
|
config_path.to_string_lossy()
|
|
|
|
);
|
2023-01-24 11:23:42 +00:00
|
|
|
} else {
|
2022-07-24 12:00:52 +00:00
|
|
|
eprintln!(
|
|
|
|
"Unable to write to {}, sourcing default file instead",
|
|
|
|
config_path.to_string_lossy(),
|
|
|
|
);
|
|
|
|
eval_default_config(engine_state, stack, config_file, is_env_config);
|
|
|
|
return;
|
2022-07-14 14:09:27 +00:00
|
|
|
}
|
2023-01-24 11:23:42 +00:00
|
|
|
} else {
|
2023-01-30 01:37:54 +00:00
|
|
|
eprintln!("Unable to create {config_file}, sourcing default file instead");
|
2022-07-24 12:00:52 +00:00
|
|
|
eval_default_config(engine_state, stack, config_file, is_env_config);
|
|
|
|
return;
|
2022-07-14 14:09:27 +00:00
|
|
|
}
|
2023-01-24 11:23:42 +00:00
|
|
|
}
|
2022-07-24 12:00:52 +00:00
|
|
|
_ => {
|
|
|
|
eval_default_config(engine_state, stack, config_file, is_env_config);
|
2022-02-20 10:08:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-19 20:54:43 +00:00
|
|
|
eval_config_contents(config_path, engine_state, stack);
|
|
|
|
}
|
|
|
|
}
|
2022-07-14 14:09:27 +00:00
|
|
|
|
2022-10-21 15:20:21 +00:00
|
|
|
pub(crate) fn read_loginshell_file(engine_state: &mut EngineState, stack: &mut Stack) {
|
2022-06-06 11:52:37 +00:00
|
|
|
// read and execute loginshell file if exists
|
|
|
|
if let Some(mut config_path) = nu_path::config_dir() {
|
|
|
|
config_path.push(NUSHELL_FOLDER);
|
|
|
|
config_path.push(LOGINSHELL_FILE);
|
|
|
|
|
|
|
|
if config_path.exists() {
|
|
|
|
eval_config_contents(config_path, engine_state, stack);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-21 15:20:21 +00:00
|
|
|
info!("read_loginshell_file {}:{}:{}", file!(), line!(), column!());
|
2022-06-06 11:52:37 +00:00
|
|
|
}
|
2022-07-14 05:53:13 +00:00
|
|
|
|
2022-10-21 15:20:21 +00:00
|
|
|
pub(crate) fn read_default_env_file(engine_state: &mut EngineState, stack: &mut Stack) {
|
2022-08-01 01:44:33 +00:00
|
|
|
let config_file = get_default_env();
|
2022-07-14 05:53:13 +00:00
|
|
|
eval_source(
|
|
|
|
engine_state,
|
|
|
|
stack,
|
|
|
|
config_file.as_bytes(),
|
|
|
|
"default_env.nu",
|
2022-12-07 18:31:57 +00:00
|
|
|
PipelineData::empty(),
|
2023-02-01 23:02:27 +00:00
|
|
|
false,
|
2022-07-14 05:53:13 +00:00
|
|
|
);
|
|
|
|
|
2022-10-21 15:20:21 +00:00
|
|
|
info!("read_config_file {}:{}:{}", file!(), line!(), column!());
|
2022-07-14 14:09:27 +00:00
|
|
|
// Merge the environment in case env vars changed in the config
|
2022-07-14 05:53:13 +00:00
|
|
|
match nu_engine::env::current_dir(engine_state, stack) {
|
|
|
|
Ok(cwd) => {
|
2022-07-14 14:09:27 +00:00
|
|
|
if let Err(e) = engine_state.merge_env(stack, cwd) {
|
2022-07-14 05:53:13 +00:00
|
|
|
let working_set = StateWorkingSet::new(engine_state);
|
|
|
|
report_error(&working_set, &e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
let working_set = StateWorkingSet::new(engine_state);
|
|
|
|
report_error(&working_set, &e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-07-24 12:00:52 +00:00
|
|
|
|
|
|
|
fn eval_default_config(
|
|
|
|
engine_state: &mut EngineState,
|
|
|
|
stack: &mut Stack,
|
|
|
|
config_file: &str,
|
|
|
|
is_env_config: bool,
|
|
|
|
) {
|
|
|
|
println!("Continuing without config file");
|
|
|
|
// Just use the contents of "default_config.nu" or "default_env.nu"
|
|
|
|
eval_source(
|
|
|
|
engine_state,
|
|
|
|
stack,
|
|
|
|
config_file.as_bytes(),
|
|
|
|
if is_env_config {
|
|
|
|
"default_env.nu"
|
|
|
|
} else {
|
|
|
|
"default_config.nu"
|
|
|
|
},
|
2022-12-07 18:31:57 +00:00
|
|
|
PipelineData::empty(),
|
2023-02-01 23:02:27 +00:00
|
|
|
false,
|
2022-07-24 12:00:52 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
// Merge the environment in case env vars changed in the config
|
|
|
|
match nu_engine::env::current_dir(engine_state, stack) {
|
|
|
|
Ok(cwd) => {
|
|
|
|
if let Err(e) = engine_state.merge_env(stack, cwd) {
|
|
|
|
let working_set = StateWorkingSet::new(engine_state);
|
|
|
|
report_error(&working_set, &e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
let working_set = StateWorkingSet::new(engine_state);
|
|
|
|
report_error(&working_set, &e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-20 21:20:38 +00:00
|
|
|
|
|
|
|
pub(crate) fn setup_config(
|
|
|
|
engine_state: &mut EngineState,
|
|
|
|
stack: &mut Stack,
|
|
|
|
#[cfg(feature = "plugin")] plugin_file: Option<Spanned<String>>,
|
|
|
|
config_file: Option<Spanned<String>>,
|
|
|
|
env_file: Option<Spanned<String>>,
|
|
|
|
is_login_shell: bool,
|
|
|
|
) {
|
|
|
|
#[cfg(feature = "plugin")]
|
|
|
|
read_plugin_file(engine_state, stack, plugin_file, NUSHELL_FOLDER);
|
|
|
|
|
|
|
|
read_config_file(engine_state, stack, env_file, true);
|
|
|
|
read_config_file(engine_state, stack, config_file, false);
|
|
|
|
|
|
|
|
if is_login_shell {
|
|
|
|
read_loginshell_file(engine_state, stack);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Give a warning if we see `$config` for a few releases
|
|
|
|
{
|
|
|
|
let working_set = StateWorkingSet::new(engine_state);
|
|
|
|
if working_set.find_variable(b"$config").is_some() {
|
|
|
|
println!("warning: use `let-env config = ...` instead of `let config = ...`");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn set_config_path(
|
|
|
|
engine_state: &mut EngineState,
|
|
|
|
cwd: &Path,
|
|
|
|
default_config_name: &str,
|
|
|
|
key: &str,
|
|
|
|
config_file: &Option<Spanned<String>>,
|
|
|
|
) {
|
|
|
|
let config_path = match config_file {
|
|
|
|
Some(s) => canonicalize_with(&s.item, cwd).ok(),
|
|
|
|
None => nu_path::config_dir().map(|mut p| {
|
|
|
|
p.push(NUSHELL_FOLDER);
|
|
|
|
p.push(default_config_name);
|
|
|
|
p
|
|
|
|
}),
|
|
|
|
};
|
|
|
|
|
|
|
|
if let Some(path) = config_path {
|
|
|
|
engine_state.set_config_path(key, path);
|
|
|
|
}
|
|
|
|
}
|