Move print_pipeline_data to nu-protocol (#5328)

crates/nu-protocol/src/pipeline_data.rs

@@ -1,6 +1,13 @@
-use std::sync::{atomic::AtomicBool, Arc};
+use std::{
+    io::Write,
+    sync::{atomic::AtomicBool, Arc},
+};
 
-use crate::{ast::PathMember, Config, ListStream, RawStream, ShellError, Span, Value};
+use crate::{
+    ast::{Call, PathMember},
+    engine::{EngineState, Stack},
+    Config, ListStream, RawStream, ShellError, Span, Value,
+};
 
 /// The foundational abstraction for input and output to commands
 ///
@@ -408,6 +415,81 @@ impl PipelineData {
             }
         }
     }
+
+    pub fn print(self, engine_state: &EngineState, stack: &mut Stack) -> Result<(), ShellError> {
+        // If the table function is in the declarations, then we can use it
+        // to create the table value that will be printed in the terminal
+
+        let config = engine_state.get_config();
+
+        let stdout = std::io::stdout();
+
+        if let PipelineData::ExternalStream {
+            stdout: stream,
+            exit_code,
+            ..
+        } = self
+        {
+            if let Some(stream) = stream {
+                for s in stream {
+                    let _ = stdout.lock().write_all(s?.as_binary()?);
+                }
+            }
+
+            // Make sure everything has finished
+            if let Some(exit_code) = exit_code {
+                let _: Vec<_> = exit_code.into_iter().collect();
+            }
+
+            return Ok(());
+        }
+
+        match engine_state.find_decl("table".as_bytes()) {
+            Some(decl_id) => {
+                let table = engine_state.get_decl(decl_id).run(
+                    engine_state,
+                    stack,
+                    &Call::new(Span::new(0, 0)),
+                    self,
+                )?;
+
+                for item in table {
+                    let stdout = std::io::stdout();
+
+                    if let Value::Error { error } = item {
+                        return Err(error);
+                    }
+
+                    let mut out = item.into_string("\n", config);
+                    out.push('\n');
+
+                    match stdout.lock().write_all(out.as_bytes()) {
+                        Ok(_) => (),
+                        Err(err) => eprintln!("{}", err),
+                    };
+                }
+            }
+            None => {
+                for item in self {
+                    let stdout = std::io::stdout();
+
+                    if let Value::Error { error } = item {
+                        return Err(error);
+                    }
+
+                    let mut out = item.into_string("\n", config);
+                    out.push('\n');
+
+                    match stdout.lock().write_all(out.as_bytes()) {
+                        Ok(_) => (),
+                        Err(err) => eprintln!("{}", err),
+                    };
+                }
+            }
+        };
+
+        Ok(())
+    }
 }
 
 pub struct PipelineIterator(PipelineData);