Use 'table' during internal->external (#898)

* Use 'table' during internal->external

* Preserve more of config

crates/nu-command/src/system/run_external.rs

@@ -8,7 +8,7 @@ use std::sync::mpsc;
 use nu_engine::env_to_strings;
 use nu_protocol::engine::{EngineState, Stack};
 use nu_protocol::{ast::Call, engine::Command, ShellError, Signature, SyntaxShape, Value};
-use nu_protocol::{Category, Config, PipelineData, RawStream, Span, Spanned};
+use nu_protocol::{Category, PipelineData, RawStream, Span, Spanned};
 
 use itertools::Itertools;
 
@@ -96,7 +96,7 @@ impl Command for External {
             last_expression,
             env_vars: env_vars_str,
         };
-        command.run_with_input(engine_state, input, config)
+        command.run_with_input(engine_state, stack, input)
     }
 }
 
@@ -111,8 +111,8 @@ impl ExternalCommand {
     pub fn run_with_input(
         &self,
         engine_state: &EngineState,
+        stack: &mut Stack,
         input: PipelineData,
-        config: Config,
     ) -> Result<PipelineData, ShellError> {
         let head = self.name.span;
 
@@ -155,33 +155,42 @@ impl ExternalCommand {
                 self.name.span,
             )),
             Ok(mut child) => {
-                // if there is a string or a stream, that is sent to the pipe std
+                if !input.is_nothing() {
-                if let Some(mut stdin_write) = child.stdin.take() {
+                    let engine_state = engine_state.clone();
-                    std::thread::spawn(move || {
+                    let mut stack = stack.clone();
-                        for value in input.into_iter() {
+                    stack.update_config(
-                            match value {
+                        "use_ansi_coloring",
-                                Value::String { val, span: _ } => {
+                        Value::Bool {
-                                    if stdin_write.write(val.as_bytes()).is_err() {
+                            val: false,
-                                        return Ok(());
+                            span: Span::new(0, 0),
-                                    }
+                        },
-                                }
+                    );
-                                Value::Binary { val, span: _ } => {
+                    // if there is a string or a stream, that is sent to the pipe std
-                                    if stdin_write.write(&val).is_err() {
+                    if let Some(mut stdin_write) = child.stdin.take() {
-                                        return Ok(());
+                        std::thread::spawn(move || {
-                                    }
+                            let input = crate::Table::run(
-                                }
+                                &crate::Table,
-                                x => {
+                                &engine_state,
-                                    if stdin_write
+                                &mut stack,
-                                        .write(x.into_string(", ", &config).as_bytes())
+                                &Call::new(),
-                                        .is_err()
+                                input,
-                                    {
+                            );
+
+                            if let Ok(input) = input {
+                                for value in input.into_iter() {
+                                    if let Value::String { val, span: _ } = value {
+                                        if stdin_write.write(val.as_bytes()).is_err() {
+                                            return Ok(());
+                                        }
+                                    } else {
                                         return Err(());
                                     }
                                 }
                             }
-                        }
+
-                        Ok(())
+                            Ok(())
-                    });
+                        });
+                    }
                 }
 
                 let last_expression = self.last_expression;

crates/nu-protocol/src/engine/stack.rs

@@ -178,10 +178,20 @@ impl Stack {
 
         match config {
             Ok(config) => config.into_config(),
-            Err(e) => {
+            Err(e) => Err(e),
-                println!("Can't find {} in {:?}", CONFIG_VARIABLE_ID, self);
+        }
-                Err(e)
+    }
+
+    pub fn update_config(&mut self, name: &str, value: Value) {
+        if let Some(Value::Record { cols, vals, .. }) = self.vars.get_mut(&CONFIG_VARIABLE_ID) {
+            for col_val in cols.iter().zip(vals.iter_mut()) {
+                if col_val.0 == name {
+                    *col_val.1 = value;
+                    return;
+                }
             }
+            cols.push(name.to_string());
+            vals.push(value);
         }
     }
 

crates/nu-protocol/src/pipeline_data.rs

@@ -75,6 +75,10 @@ impl PipelineData {
         self
     }
 
+    pub fn is_nothing(&self) -> bool {
+        matches!(self, PipelineData::Value(Value::Nothing { .. }, ..))
+    }
+
     pub fn into_value(self, span: Span) -> Value {
         match self {
             PipelineData::Value(Value::Nothing { .. }, ..) => Value::nothing(span),