Semicolon (#1613)

* WIP on blocks

* Getting further

* add some tests

crates/nu-cli/src/commands/classified/block.rs

@@ -0,0 +1,97 @@
+use crate::commands::classified::expr::run_expression_block;
+use crate::commands::classified::external::run_external_command;
+use crate::commands::classified::internal::run_internal_command;
+use crate::context::Context;
+use crate::prelude::*;
+use crate::stream::InputStream;
+use futures::stream::TryStreamExt;
+use nu_errors::ShellError;
+use nu_protocol::hir::{Block, ClassifiedCommand, Commands};
+use nu_protocol::{ReturnSuccess, Scope, UntaggedValue, Value};
+use std::sync::atomic::Ordering;
+
+pub(crate) async fn run_block(
+    block: &Block,
+    ctx: &mut Context,
+    mut input: InputStream,
+    scope: &Scope,
+) -> Result<InputStream, ShellError> {
+    let mut output: Result<InputStream, ShellError> = Ok(InputStream::empty());
+    for pipeline in &block.block {
+        match output {
+            Ok(inp) if inp.is_empty() => {}
+            Ok(inp) => {
+                let mut output_stream = inp.to_output_stream();
+
+                loop {
+                    match output_stream.try_next().await {
+                        Ok(Some(ReturnSuccess::Value(Value {
+                            value: UntaggedValue::Error(e),
+                            ..
+                        }))) => return Err(e),
+                        Ok(Some(_item)) => {
+                            if ctx.ctrl_c.load(Ordering::SeqCst) {
+                                break;
+                            }
+                        }
+                        Ok(None) => break,
+                        Err(e) => return Err(e),
+                    }
+                }
+                if !ctx.get_errors().is_empty() {
+                    return Ok(InputStream::empty());
+                }
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        }
+        output = run_pipeline(pipeline, ctx, input, scope).await;
+
+        input = InputStream::empty();
+    }
+
+    output
+}
+
+async fn run_pipeline(
+    commands: &Commands,
+    ctx: &mut Context,
+    mut input: InputStream,
+    scope: &Scope,
+) -> Result<InputStream, ShellError> {
+    let mut iter = commands.list.clone().into_iter().peekable();
+
+    loop {
+        let item: Option<ClassifiedCommand> = iter.next();
+        let next: Option<&ClassifiedCommand> = iter.peek();
+
+        input = match (item, next) {
+            (Some(ClassifiedCommand::Dynamic(_)), _) | (_, Some(ClassifiedCommand::Dynamic(_))) => {
+                return Err(ShellError::unimplemented("Dynamic commands"))
+            }
+
+            (Some(ClassifiedCommand::Expr(expr)), _) => {
+                run_expression_block(*expr, ctx, input, scope)?
+            }
+            (Some(ClassifiedCommand::Error(err)), _) => return Err(err.into()),
+            (_, Some(ClassifiedCommand::Error(err))) => return Err(err.clone().into()),
+
+            (Some(ClassifiedCommand::Internal(left)), _) => {
+                run_internal_command(left, ctx, input, scope)?
+            }
+
+            (Some(ClassifiedCommand::External(left)), None) => {
+                run_external_command(left, ctx, input, scope, true).await?
+            }
+
+            (Some(ClassifiedCommand::External(left)), _) => {
+                run_external_command(left, ctx, input, scope, false).await?
+            }
+
+            (None, _) => break,
+        };
+    }
+
+    Ok(input)
+}

crates/nu-cli/src/commands/classified/internal.rs

@@ -120,12 +120,12 @@ pub(crate) fn run_internal_command(
                             FilesystemShell::with_location(location, context.registry().clone()),
                         ));
                     }
-                    CommandAction::AddAlias(name, args, commands) => {
+                    CommandAction::AddAlias(name, args, block) => {
                         context.add_commands(vec![
                             per_item_command(AliasCommand::new(
                                 name,
                                 args,
-                                commands,
+                                block,
                             ))
                         ]);
                     }

crates/nu-cli/src/commands/classified/mod.rs

@@ -1,8 +1,8 @@
+pub(crate) mod block;
 mod dynamic;
 pub(crate) mod expr;
 pub(crate) mod external;
 pub(crate) mod internal;
-pub(crate) mod pipeline;
 
 #[allow(unused_imports)]
 pub(crate) use dynamic::Command as DynamicCommand;

crates/nu-cli/src/commands/each.rs

@@ -1,4 +1,4 @@
-use crate::commands::classified::pipeline::run_pipeline;
+use crate::commands::classified::block::run_block;
 use crate::commands::PerItemCommand;
 use crate::context::CommandRegistry;
 use crate::prelude::*;
@@ -6,10 +6,7 @@ use crate::prelude::*;
 use futures::stream::once;
 
 use nu_errors::ShellError;
-use nu_protocol::{
-    hir::ClassifiedPipeline, CallInfo, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue,
-    Value,
-};
+use nu_protocol::{CallInfo, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue, Value};
 
 pub struct Each;
 
@@ -50,8 +47,8 @@ impl PerItemCommand for Each {
                     let input_clone = input.clone();
                     let input_stream = once(async { Ok(input) }).to_input_stream();
 
-                    let result = run_pipeline(
-                        ClassifiedPipeline::new(block.clone(), None),
+                    let result = run_block(
+                        block,
                         &mut context,
                         input_stream,
                         &Scope::new(input_clone),

crates/nu-cli/src/commands/run_alias.rs

@@ -1,18 +1,15 @@
-use crate::commands::classified::pipeline::run_pipeline;
+use crate::commands::classified::block::run_block;
 use crate::prelude::*;
 
 use derive_new::new;
 use nu_errors::ShellError;
-use nu_protocol::{
-    hir::ClassifiedPipeline, hir::Commands, CallInfo, ReturnSuccess, Scope, Signature, SyntaxShape,
-    Value,
-};
+use nu_protocol::{hir::Block, CallInfo, ReturnSuccess, Scope, Signature, SyntaxShape, Value};
 
 #[derive(new)]
 pub struct AliasCommand {
     name: String,
     args: Vec<String>,
-    block: Commands,
+    block: Block,
 }
 
 impl PerItemCommand for AliasCommand {
@@ -60,8 +57,8 @@ impl PerItemCommand for AliasCommand {
             let input_clone = Ok(input.clone());
             let input_stream = futures::stream::once(async { input_clone }).boxed().to_input_stream();
 
-            let result = run_pipeline(
-                ClassifiedPipeline::new(block.clone(), None),
+            let result = run_block(
+                &block,
                 &mut context,
                 input_stream,
                 &scope

crates/nu-cli/src/commands/skip_while.rs

@@ -40,25 +40,34 @@ impl WholeStreamCommand for SkipWhile {
             Value {
                 value: UntaggedValue::Block(block),
                 tag,
-            } => match block.list.get(0) {
-                Some(item) => match item {
-                    ClassifiedCommand::Expr(expr) => expr.clone(),
-                    _ => {
-                        return Err(ShellError::labeled_error(
-                            "Expected a condition",
-                            "expected a condition",
-                            tag,
-                        ))
-                    }
-                },
-                None => {
+            } => {
+                if block.block.len() != 1 {
                     return Err(ShellError::labeled_error(
                         "Expected a condition",
                         "expected a condition",
                         tag,
                     ));
                 }
-            },
+                match block.block[0].list.get(0) {
+                    Some(item) => match item {
+                        ClassifiedCommand::Expr(expr) => expr.clone(),
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Expected a condition",
+                                "expected a condition",
+                                tag,
+                            ))
+                        }
+                    },
+                    None => {
+                        return Err(ShellError::labeled_error(
+                            "Expected a condition",
+                            "expected a condition",
+                            tag,
+                        ));
+                    }
+                }
+            }
             Value { tag, .. } => {
                 return Err(ShellError::labeled_error(
                     "Expected a condition",

crates/nu-cli/src/commands/where_.rs

@@ -40,25 +40,34 @@ impl PerItemCommand for Where {
             Value {
                 value: UntaggedValue::Block(block),
                 tag,
-            } => match block.list.get(0) {
-                Some(item) => match item {
-                    ClassifiedCommand::Expr(expr) => expr.clone(),
-                    _ => {
-                        return Err(ShellError::labeled_error(
-                            "Expected a condition",
-                            "expected a condition",
-                            tag,
-                        ))
-                    }
-                },
-                None => {
+            } => {
+                if block.block.len() != 1 {
                     return Err(ShellError::labeled_error(
                         "Expected a condition",
                         "expected a condition",
                         tag,
                     ));
                 }
-            },
+                match block.block[0].list.get(0) {
+                    Some(item) => match item {
+                        ClassifiedCommand::Expr(expr) => expr.clone(),
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Expected a condition",
+                                "expected a condition",
+                                tag,
+                            ))
+                        }
+                    },
+                    None => {
+                        return Err(ShellError::labeled_error(
+                            "Expected a condition",
+                            "expected a condition",
+                            tag,
+                        ));
+                    }
+                }
+            }
             Value { tag, .. } => {
                 return Err(ShellError::labeled_error(
                     "Expected a condition",