Semicolon (#1613)

* WIP on blocks

* Getting further

* add some tests

crates/nu-cli/src/cli.rs

@@ -1,5 +1,5 @@
+use crate::commands::classified::block::run_block;
 use crate::commands::classified::external::{MaybeTextCodec, StringOrBinary};
-use crate::commands::classified::pipeline::run_pipeline;
 use crate::commands::plugin::JsonRpc;
 use crate::commands::plugin::{PluginCommand, PluginSink};
 use crate::commands::whole_stream_command;
@@ -710,12 +710,12 @@ async fn process_line(
             debug!("=== Parsed ===");
             debug!("{:#?}", result);
 
-            let pipeline = nu_parser::classify_pipeline(&result, ctx.registry());
+            let classified_block = nu_parser::classify_block(&result, ctx.registry());
 
-            debug!("{:#?}", pipeline);
+            debug!("{:#?}", classified_block);
             //println!("{:#?}", pipeline);
 
-            if let Some(failure) = pipeline.failed {
+            if let Some(failure) = classified_block.failed {
                 return LineResult::Error(line.to_string(), failure.into());
             }
 
@@ -725,10 +725,13 @@ async fn process_line(
             // ...and it doesn't have any arguments
             // ...and we're in the CLI
             // ...then change to this directory
-            if cli_mode && pipeline.commands.list.len() == 1 {
+            if cli_mode
+                && classified_block.block.block.len() == 1
+                && classified_block.block.block[0].list.len() == 1
+            {
                 if let ClassifiedCommand::Internal(InternalCommand {
                     ref name, ref args, ..
-                }) = pipeline.commands.list[0]
+                }) = classified_block.block.block[0].list[0]
                 {
                     let internal_name = name;
                     let name = args
@@ -826,7 +829,7 @@ async fn process_line(
                 InputStream::empty()
             };
 
-            match run_pipeline(pipeline, ctx, input_stream, &Scope::empty()).await {
+            match run_block(&classified_block.block, ctx, input_stream, &Scope::empty()).await {
                 Ok(input) => {
                     // Running a pipeline gives us back a stream that we can then
                     // work through. At the top level, we just want to pull on the
@@ -896,12 +899,10 @@ mod tests {
 
     #[quickcheck]
     fn quickcheck_parse(data: String) -> bool {
-        if let Ok(lite_pipeline) = nu_parser::lite_parse(&data, 0) {
+        if let Ok(lite_block) = nu_parser::lite_parse(&data, 0) {
             let context = crate::context::Context::basic().unwrap();
-            let _ = nu_parser::classify_pipeline(&lite_pipeline, context.registry());
-            true
-        } else {
-            false
+            let _ = nu_parser::classify_block(&lite_block, context.registry());
         }
+        true
     }
 }

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",

crates/nu-cli/src/deserializer.rs

@@ -1,7 +1,7 @@
 use log::trace;
 use nu_errors::{CoerceInto, ShellError};
 use nu_protocol::{
-    hir::Commands, CallInfo, ColumnPath, Primitive, RangeInclusion, ShellTypeName, UntaggedValue,
+    hir::Block, CallInfo, ColumnPath, Primitive, RangeInclusion, ShellTypeName, UntaggedValue,
     Value,
 };
 use nu_source::{HasSpan, Spanned, SpannedItem, Tagged, TaggedItem};
@@ -369,7 +369,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut ConfigDeserializer<'de> {
                     ))
                 }
             };
-            return visit::<Commands, _>(block, name, fields, visitor);
+            return visit::<Block, _>(block, name, fields, visitor);
         }
 
         if name == "ColumnPath" {

crates/nu-cli/src/shell/completer.rs

@@ -34,14 +34,9 @@ impl NuCompleter {
 
         // See if we're a flag
         if pos > 0 && replace_pos < line_chars.len() && line_chars[replace_pos] == '-' {
-            if let Ok(lite_pipeline) = nu_parser::lite_parse(line, 0) {
-                completions = self.get_matching_arguments(
-                    &lite_pipeline,
-                    &line_chars,
-                    line,
-                    replace_pos,
-                    pos,
-                );
+            if let Ok(lite_block) = nu_parser::lite_parse(line, 0) {
+                completions =
+                    self.get_matching_arguments(&lite_block, &line_chars, line, replace_pos, pos);
             } else {
                 completions = self.file_completer.complete(line, pos, context)?.1;
             }
@@ -96,7 +91,7 @@ impl NuCompleter {
 
     fn get_matching_arguments(
         &self,
-        lite_parse: &nu_parser::LitePipeline,
+        lite_block: &nu_parser::LiteBlock,
         line_chars: &[char],
         line: &str,
         replace_pos: usize,
@@ -109,23 +104,25 @@ impl NuCompleter {
         let replace_string = (replace_pos..pos).map(|_| " ").collect::<String>();
         line_copy.replace_range(replace_pos..pos, &replace_string);
 
-        let result = nu_parser::classify_pipeline(&lite_parse, &self.commands);
+        let result = nu_parser::classify_block(&lite_block, &self.commands);
 
-        for command in result.commands.list {
-            if let nu_protocol::hir::ClassifiedCommand::Internal(
-                nu_protocol::hir::InternalCommand { args, .. },
-            ) = command
-            {
-                if replace_pos >= args.span.start() && replace_pos <= args.span.end() {
-                    if let Some(named) = args.named {
-                        for (name, _) in named.iter() {
-                            let full_flag = format!("--{}", name);
+        for pipeline in &result.block.block {
+            for command in &pipeline.list {
+                if let nu_protocol::hir::ClassifiedCommand::Internal(
+                    nu_protocol::hir::InternalCommand { args, .. },
+                ) = command
+                {
+                    if replace_pos >= args.span.start() && replace_pos <= args.span.end() {
+                        if let Some(named) = &args.named {
+                            for (name, _) in named.iter() {
+                                let full_flag = format!("--{}", name);
 
-                            if full_flag.starts_with(&substring) {
-                                matching_arguments.push(rustyline::completion::Pair {
-                                    display: full_flag.clone(),
-                                    replacement: full_flag,
-                                });
+                                if full_flag.starts_with(&substring) {
+                                    matching_arguments.push(rustyline::completion::Pair {
+                                        display: full_flag.clone(),
+                                        replacement: full_flag,
+                                    });
+                                }
                             }
                         }
                     }

crates/nu-cli/src/shell/helper.rs

@@ -61,15 +61,15 @@ impl Highlighter for Helper {
     }
 
     fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
-        let lite_pipeline = nu_parser::lite_parse(line, 0);
+        let lite_block = nu_parser::lite_parse(line, 0);
 
-        match lite_pipeline {
+        match lite_block {
             Err(_) => Cow::Borrowed(line),
-            Ok(lp) => {
+            Ok(lb) => {
                 let classified =
-                    nu_parser::classify_pipeline(&lp, &self.context.registry().clone_box());
+                    nu_parser::classify_block(&lb, &self.context.registry().clone_box());
 
-                let shapes = nu_parser::shapes(&classified.commands);
+                let shapes = nu_parser::shapes(&classified.block);
                 let mut painter = Painter::new(line);
 
                 for shape in shapes {