extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-08-19 17:35:42 +02:00
Code Issues Packages Projects Releases Wiki Activity

add function to make env vars case-insensitive

Browse Source
This commit is contained in:
Darren Schroeder
2024-11-19 16:11:14 -06:00
parent 9cffbdb42a
commit cf1b8f46eb
7 changed files with 93 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
crates/nu-cli/src/completions/command_completions.rs
View File

@@ -38,8 +38,7 @@ impl CommandCompletion {
) -> Vec<String> {
let mut executables = vec![];
// os agnostic way to get the PATH env var
let paths = working_set.permanent_state.get_path_env_var();
let paths = working_set.permanent_state.get_env_var_insensitive("path");
if let Some(paths) = paths {
if let Ok(paths) = paths.as_list() {

10
crates/nu-cli/tests/completions/mod.rs
View File

@@ -1612,13 +1612,3 @@ fn alias_offset_bug_7754() {
// This crashes before PR #7756
let _suggestions = completer.complete("ll -a | c", 9);
}
#[test]
fn get_path_env_var_8003() {
// Create a new engine
let (_, _, engine, _) = new_engine();
// Get the path env var in a platform agnostic way
let the_path = engine.get_path_env_var();
// Make sure it's not empty
assert!(the_path.is_some());
}

45
crates/nu-engine/src/env.rs
View File

@@ -11,13 +11,6 @@ use std::{
sync::Arc,
};
#[cfg(windows)]
const ENV_PATH_NAME: &str = "Path";
#[cfg(windows)]
const ENV_PATH_NAME_SECONDARY: &str = "PATH";
#[cfg(not(windows))]
const ENV_PATH_NAME: &str = "PATH";
const ENV_CONVERSIONS: &str = "ENV_CONVERSIONS";
enum ConversionResult {
@@ -53,14 +46,14 @@ pub fn convert_env_values(engine_state: &mut EngineState, stack: &Stack) -> Resu
#[cfg(not(windows))]
{
error = error.or_else(|| ensure_path(&mut new_scope, ENV_PATH_NAME));
error = error.or_else(|| ensure_path(&mut new_scope, "PATH"));
}
#[cfg(windows)]
{
let first_result = ensure_path(&mut new_scope, ENV_PATH_NAME);
let first_result = ensure_path(&mut new_scope, "Path");
if first_result.is_some() {
let second_result = ensure_path(&mut new_scope, ENV_PATH_NAME_SECONDARY);
let second_result = ensure_path(&mut new_scope, "PATH");
if second_result.is_some() {
error = error.or(first_result);
@@ -107,7 +100,7 @@ pub fn env_to_string(
ConversionResult::CellPathError => match value.coerce_string() {
Ok(s) => Ok(s),
Err(_) => {
if env_name == ENV_PATH_NAME {
if env_name.to_lowercase() == "path" {
// Try to convert PATH/Path list to a string
match value {
Value::List { vals, .. } => {
@@ -213,31 +206,21 @@ pub fn current_dir_const(working_set: &StateWorkingSet) -> Result<PathBuf, Shell
}
/// Get the contents of path environment variable as a list of strings
///
/// On non-Windows: It will fetch PATH
/// On Windows: It will try to fetch Path first but if not present, try PATH
pub fn path_str(
engine_state: &EngineState,
stack: &Stack,
span: Span,
) -> Result<String, ShellError> {
let (pathname, pathval) = match stack.get_env_var(engine_state, ENV_PATH_NAME) {
Some(v) => Ok((ENV_PATH_NAME, v)),
None => {
#[cfg(windows)]
match stack.get_env_var(engine_state, ENV_PATH_NAME_SECONDARY) {
Some(v) => Ok((ENV_PATH_NAME_SECONDARY, v)),
None => Err(ShellError::EnvVarNotFoundAtRuntime {
envvar_name: ENV_PATH_NAME_SECONDARY.to_string(),
span,
}),
}
#[cfg(not(windows))]
Err(ShellError::EnvVarNotFoundAtRuntime {
envvar_name: ENV_PATH_NAME.to_string(),
span,
})
}
let (pathname, pathval) = match stack.get_env_var_insensitive(engine_state, "path") {
Some(v) => Ok((if cfg!(windows) { "Path" } else { "PATH" }, v)),
None => Err(ShellError::EnvVarNotFoundAtRuntime {
envvar_name: if cfg!(windows) {
"Path".to_string()
} else {
"PATH".to_string()
},
span,
}),
}?;
env_to_string(pathname, pathval, engine_state, stack)

2
crates/nu-plugin-engine/src/context.rs
View File

@@ -126,7 +126,7 @@ impl<'a> PluginExecutionContext for PluginExecutionCommandContext<'a> {
}
fn get_env_var(&self, name: &str) -> Result<Option<&Value>, ShellError> {
Ok(self.stack.get_env_var(&self.engine_state, name))
Ok(self.stack.get_env_var_insensitive(&self.engine_state, name))
}
fn get_env_vars(&self) -> Result<HashMap<String, Value>, ShellError> {

17
crates/nu-protocol/src/engine/engine_state.rs
View File

@@ -465,20 +465,17 @@ impl EngineState {
None
}
// Get the path environment variable in a platform agnostic way
pub fn get_path_env_var(&self) -> Option<&Value> {
let env_path_name_windows: &str = "Path";
let env_path_name_nix: &str = "PATH";
pub fn get_env_var_insensitive(&self, name: &str) -> Option<&Value> {
let name_lower = name.to_lowercase();
for overlay_id in self.scope.active_overlays.iter().rev() {
let overlay_name = String::from_utf8_lossy(self.get_overlay_name(*overlay_id));
if let Some(env_vars) = self.env_vars.get(overlay_name.as_ref()) {
if let Some(val) = env_vars.get(env_path_name_nix) {
return Some(val);
} else if let Some(val) = env_vars.get(env_path_name_windows) {
return Some(val);
} else {
return None;
if let Some(v) = env_vars
.iter()
.find(|(k, _)| k.to_lowercase() == name_lower)
{
return Some(v.1);
}
}
}

42
crates/nu-protocol/src/engine/stack.rs
View File

@@ -479,6 +479,48 @@ impl Stack {
None
}
// Case-Insensitve version of get_env_var
pub fn get_env_var_insensitive<'a>(
&'a self,
engine_state: &'a EngineState,
name: &str,
) -> Option<&'a Value> {
let name_lower = name.to_lowercase();
for scope in self.env_vars.iter().rev() {
for active_overlay in self.active_overlays.iter().rev() {
if let Some(env_vars) = scope.get(active_overlay) {
if let Some(v) = env_vars
.iter()
.find(|(k, _)| k.to_lowercase() == name_lower)
{
return Some(v.1);
}
}
}
}
for active_overlay in self.active_overlays.iter().rev() {
let is_hidden = if let Some(env_hidden) = self.env_hidden.get(active_overlay) {
env_hidden.iter().any(|k| k.to_lowercase() == name_lower)
} else {
false
};
if !is_hidden {
if let Some(env_vars) = engine_state.env_vars.get(active_overlay) {
if let Some(v) = env_vars
.iter()
.find(|(k, _)| k.to_lowercase() == name_lower)
{
return Some(v.1);
}
}
}
}
None
}
pub fn has_env_var(&self, engine_state: &EngineState, name: &str) -> bool {
for scope in self.env_vars.iter().rev() {
for active_overlay in self.active_overlays.iter().rev() {

29
crates/nu-protocol/tests/test_value.rs
View File

@@ -1,4 +1,7 @@
use nu_protocol::{Config, Span, Value};
use nu_protocol::{
engine::{EngineState, Stack},
Config, Span, Value,
};
use rstest::rstest;
#[test]
@@ -46,3 +49,27 @@ fn test_duration_to_string(#[case] in_ns: i64, #[case] expected: &str) {
"expected != observed"
);
}
#[test]
fn test_case_insensitive_env_var() {
let mut engine_state = EngineState::new();
let stack = Stack::new();
for (name, value) in std::env::vars() {
engine_state.add_env_var(name, Value::test_string(value));
}
let path_lower = engine_state.get_env_var_insensitive("path");
let path_upper = engine_state.get_env_var_insensitive("PATH");
let path_mixed = engine_state.get_env_var_insensitive("PaTh");
assert_eq!(path_lower, path_upper);
assert_eq!(path_lower, path_mixed);
let stack_path_lower = stack.get_env_var_insensitive(&engine_state, "path");
let stack_path_upper = stack.get_env_var_insensitive(&engine_state, "PATH");
let stack_path_mixed = stack.get_env_var_insensitive(&engine_state, "PaTh");
assert_eq!(stack_path_lower, stack_path_upper);
assert_eq!(stack_path_lower, stack_path_mixed);
}