Move from source to source-env (#6277)

* start working on source-env

* WIP

* Get most tests working, still one to go

* Fix file-relative paths; Report parser error

* Fix merge conflicts; Restore source as deprecated

* Tests: Use source-env; Remove redundant tests

* Fmt

* Respect hidden env vars

* Fix file-relative eval for source-env

* Add file-relative eval to "overlay use"

* Use FILE_PWD only in source-env and "overlay use"

* Ignore new tests for now

This will be another issue

* Throw an error if setting FILE_PWD manually

* Fix source-related test failures

* Fix nu-check to respect FILE_PWD

* Fix corrupted spans in source-env shell errors

* Fix up some references to old source

* Remove deprecation message

* Re-introduce deleted tests

Co-authored-by: kubouch <kubouch@gmail.com>

crates/nu-command/src/env/let_env.rs

@@ -1,7 +1,9 @@
 use nu_engine::{current_dir, eval_expression_with_input, CallExt};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Value};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape, Value,
+};
 
 #[derive(Clone)]
 pub struct LetEnv;
@@ -34,7 +36,7 @@ impl Command for LetEnv {
         input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
         // TODO: find and require the crossplatform restrictions on environment names
-        let env_var = call.req(engine_state, stack, 0)?;
+        let env_var: Spanned<String> = call.req(engine_state, stack, 0)?;
 
         let keyword_expr = call
             .positional_nth(1)
@@ -47,19 +49,26 @@ impl Command for LetEnv {
                 .0
                 .into_value(call.head);
 
-        if env_var == "PWD" {
+        if env_var.item == "FILE_PWD" {
+            return Err(ShellError::AutomaticEnvVarSetManually(
+                env_var.item,
+                env_var.span,
+            ));
+        }
+
+        if env_var.item == "PWD" {
             let cwd = current_dir(engine_state, stack)?;
             let rhs = rhs.as_string()?;
             let rhs = nu_path::expand_path_with(rhs, cwd);
             stack.add_env_var(
-                env_var,
+                env_var.item,
                 Value::String {
                     val: rhs.to_string_lossy().to_string(),
                     span: call.head,
                 },
             );
         } else {
-            stack.add_env_var(env_var, rhs);
+            stack.add_env_var(env_var.item, rhs);
         }
         Ok(PipelineData::new(call.head))
     }

crates/nu-command/src/env/load_env.rs

@@ -38,6 +38,10 @@ impl Command for LoadEnv {
         match arg {
             Some((cols, vals)) => {
                 for (env_var, rhs) in cols.into_iter().zip(vals) {
+                    if env_var == "FILE_PWD" {
+                        return Err(ShellError::AutomaticEnvVarSetManually(env_var, call.head));
+                    }
+
                     if env_var == "PWD" {
                         let cwd = current_dir(engine_state, stack)?;
                         let rhs = rhs.as_string()?;
@@ -58,6 +62,10 @@ impl Command for LoadEnv {
             None => match input {
                 PipelineData::Value(Value::Record { cols, vals, .. }, ..) => {
                     for (env_var, rhs) in cols.into_iter().zip(vals) {
+                        if env_var == "FILE_PWD" {
+                            return Err(ShellError::AutomaticEnvVarSetManually(env_var, call.head));
+                        }
+
                         if env_var == "PWD" {
                             let cwd = current_dir(engine_state, stack)?;
                             let rhs = rhs.as_string()?;

crates/nu-command/src/env/mod.rs

@@ -3,6 +3,7 @@ mod env_command;
 mod export_env;
 mod let_env;
 mod load_env;
+mod source_env;
 mod with_env;
 
 pub use config::ConfigEnv;
@@ -13,4 +14,5 @@ pub use env_command::Env;
 pub use export_env::ExportEnv;
 pub use let_env::LetEnv;
 pub use load_env::LoadEnv;
+pub use source_env::SourceEnv;
 pub use with_env::WithEnv;

crates/nu-command/src/env/source_env.rs

@@ -0,0 +1,142 @@
+use std::path::PathBuf;
+
+use nu_engine::{eval_block, find_in_dirs_env, redirect_env, CallExt};
+use nu_parser::parse;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack, StateWorkingSet};
+use nu_protocol::{
+    Category, CliError, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape, Value,
+};
+
+/// Source a file for environment variables.
+#[derive(Clone)]
+pub struct SourceEnv;
+
+impl Command for SourceEnv {
+    fn name(&self) -> &str {
+        "source-env"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("source-env")
+            .required(
+                "filename",
+                SyntaxShape::String, // type is string to avoid automatically canonicalizing the path
+                "the filepath to the script file to source the environment from",
+            )
+            .category(Category::Core)
+    }
+
+    fn usage(&self) -> &str {
+        "Source the environment from a source file into the current environment."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        caller_stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let source_filename: Spanned<String> = call.req(engine_state, caller_stack, 0)?;
+
+        if let Some(path) = find_in_dirs_env(&source_filename.item, engine_state, caller_stack)? {
+            if let Ok(content) = std::fs::read_to_string(&path) {
+                let mut parent = PathBuf::from(&path);
+                parent.pop();
+
+                let mut new_engine_state = engine_state.clone();
+
+                let (block, delta) = {
+                    let mut working_set = StateWorkingSet::new(&new_engine_state);
+
+                    // Set the currently parsed directory
+                    working_set.currently_parsed_cwd = Some(parent.clone());
+
+                    let (block, err) = parse(&mut working_set, None, content.as_bytes(), true, &[]);
+
+                    if let Some(err) = err {
+                        // Because the error span points at new_engine_state, we must create the error message now
+                        let msg = format!(
+                            r#"Found this parser error: {:?}"#,
+                            CliError(&err, &working_set)
+                        );
+
+                        return Err(ShellError::GenericError(
+                            "Failed to parse content".to_string(),
+                            "cannot parse this file".to_string(),
+                            Some(source_filename.span),
+                            Some(msg),
+                            vec![],
+                        ));
+                    } else {
+                        (block, working_set.render())
+                    }
+                };
+
+                // Merge parser changes to a temporary engine state
+                new_engine_state.merge_delta(delta)?;
+
+                // Set the currently evaluated directory
+                let file_pwd = Value::String {
+                    val: parent.to_string_lossy().to_string(),
+                    span: call.head,
+                };
+
+                caller_stack.add_env_var("FILE_PWD".to_string(), file_pwd);
+
+                // Evaluate the parsed file's block
+                let mut callee_stack = caller_stack.gather_captures(&block.captures);
+
+                let result = eval_block(
+                    &new_engine_state,
+                    &mut callee_stack,
+                    &block,
+                    input,
+                    true,
+                    true,
+                );
+
+                let result = if let Err(err) = result {
+                    // Because the error span points at new_engine_state, we must create the error message now
+                    let working_set = StateWorkingSet::new(&new_engine_state);
+
+                    let msg = format!(
+                        r#"Found this shell error: {:?}"#,
+                        CliError(&err, &working_set)
+                    );
+
+                    Err(ShellError::GenericError(
+                        "Failed to evaluate content".to_string(),
+                        "cannot evaluate this file".to_string(),
+                        Some(source_filename.span),
+                        Some(msg),
+                        vec![],
+                    ))
+                } else {
+                    result
+                };
+
+                // Merge the block's environment to the current stack
+                redirect_env(engine_state, caller_stack, &callee_stack);
+
+                // Remove the file-relative PWD
+                caller_stack.remove_env_var(engine_state, "FILE_PWD");
+
+                result
+            } else {
+                Err(ShellError::FileNotFound(source_filename.span))
+            }
+        } else {
+            Err(ShellError::FileNotFound(source_filename.span))
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Sources the environment from foo.nu in the current context",
+            example: r#"source-env foo.nu"#,
+            result: None,
+        }]
+    }
+}