extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2024-12-23 23:49:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Getting closer to multiline scripts (#2738)" (#2745)

Browse Source 
This reverts commit e66bf70589.
This commit is contained in:
Jonathan Turner 2020-11-10 18:22:13 +13:00 committed by GitHub
parent e66bf70589
commit 5a75e11b0e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 160 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
crates/nu-cli/src/cli.rs
View File

@ -290,8 +290,8 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
Ok(context)
}
pub async fn run_script_file(
file_contents: String,
pub async fn run_vec_of_pipelines(
pipelines: Vec<String>,
redirect_stdin: bool,
) -> Result<(), Box<dyn Error>> {
let mut syncer = EnvironmentSyncer::new();
@ -313,7 +313,9 @@ pub async fn run_script_file(
let _ = run_startup_commands(&mut context, &config).await;
run_script_standalone(file_contents, redirect_stdin, &mut context, true).await?;
for pipeline in pipelines {
run_pipeline_standalone(pipeline, redirect_stdin, &mut context, true).await?;
}
Ok(())
}
@ -473,7 +475,7 @@ pub async fn cli(mut context: EvaluationContext) -> Result<(), Box<dyn Error>> {
}
let line = match convert_rustyline_result_to_string(readline) {
LineResult::Success(s) => process_script(&s, &mut context, false, true).await,
LineResult::Success(s) => process_line(&s, &mut context, false, true).await,
x => x,
};
@ -600,7 +602,8 @@ async fn run_startup_commands(
} => {
for pipeline in pipelines {
if let Ok(pipeline_string) = pipeline.as_string() {
let _ = run_script_standalone(pipeline_string, false, context, false).await;
let _ =
run_pipeline_standalone(pipeline_string, false, context, false).await;
}
}
}
@ -615,13 +618,13 @@ async fn run_startup_commands(
Ok(())
}
pub async fn run_script_standalone(
script_text: String,
pub async fn run_pipeline_standalone(
pipeline: String,
redirect_stdin: bool,
context: &mut EvaluationContext,
exit_on_error: bool,
) -> Result<(), Box<dyn Error>> {
let line = process_script(&script_text, context, redirect_stdin, false).await;
let line = process_line(&pipeline, context, redirect_stdin, false).await;
match line {
LineResult::Success(line) => {
@ -889,16 +892,16 @@ pub async fn parse_and_eval(line: &str, ctx: &mut EvaluationContext) -> Result<S
}
/// Process the line by parsing the text to turn it into commands, classify those commands so that we understand what is being called in the pipeline, and then run this pipeline
pub async fn process_script(
script_text: &str,
pub async fn process_line(
line: &str,
ctx: &mut EvaluationContext,
redirect_stdin: bool,
cli_mode: bool,
) -> LineResult {
if script_text.trim() == "" {
LineResult::Success(script_text.to_string())
if line.trim() == "" {
LineResult::Success(line.to_string())
} else {
let line = chomp_newline(script_text);
let line = chomp_newline(line);
ctx.raw_input = line.to_string();
let (result, err) = nu_parser::lite_parse(&line, 0);
@ -927,12 +930,11 @@ pub async fn process_script(
// ...then change to this directory
if cli_mode
&& classified_block.block.block.len() == 1
&& classified_block.block.block[0].pipelines.len() == 1
&& classified_block.block.block[0].pipelines[0].list.len() == 1
&& classified_block.block.block[0].list.len() == 1
{
if let ClassifiedCommand::Internal(InternalCommand {
ref name, ref args, ..
}) = classified_block.block.block[0].pipelines[0].list[0]
}) = classified_block.block.block[0].list[0]
{
let internal_name = name;
let name = args

24
crates/nu-cli/src/commands/benchmark.rs
View File

@ -5,7 +5,7 @@ use crate::prelude::*;
use heim::cpu::time;
use nu_errors::ShellError;
use nu_protocol::{
hir::{Block, ClassifiedCommand, Group, InternalCommand, Pipeline},
hir::{Block, ClassifiedCommand, Commands, InternalCommand},
Dictionary, Scope, Signature, SyntaxShape, UntaggedValue, Value,
};
use rand::{
@ -175,19 +175,15 @@ where
fn add_implicit_autoview(mut block: Block) -> Block {
if block.block.is_empty() {
let group = Group::new(
vec![{
let mut commands = Pipeline::new(block.span);
commands.push(ClassifiedCommand::Internal(InternalCommand::new(
"autoview".to_string(),
block.span,
block.span,
)));
commands
}],
block.span,
);
block.push(group);
block.push({
let mut commands = Commands::new(block.span);
commands.push(ClassifiedCommand::Internal(InternalCommand::new(
"autoview".to_string(),
block.span,
block.span,
)));
commands
});
}
block
}

109
crates/nu-cli/src/commands/classified/block.rs
View File

@ -5,9 +5,7 @@ use crate::prelude::*;
use crate::stream::InputStream;
use futures::stream::TryStreamExt;
use nu_errors::ShellError;
use nu_protocol::hir::{
Block, Call, ClassifiedCommand, Expression, Pipeline, SpannedExpression, Synthetic,
};
use nu_protocol::hir::{Block, ClassifiedCommand, Commands};
use nu_protocol::{ReturnSuccess, Scope, UntaggedValue, Value};
use std::sync::atomic::Ordering;
@ -18,52 +16,35 @@ pub(crate) async fn run_block(
scope: Arc<Scope>,
) -> Result<InputStream, ShellError> {
let mut output: Result<InputStream, ShellError> = Ok(InputStream::empty());
for group in &block.block {
for pipeline in &block.block {
match output {
Ok(inp) if inp.is_empty() => {}
Ok(inp) => {
// Run autoview on the values we've seen so far
// We may want to make this configurable for other kinds of hosting
if let Some(autoview) = ctx.get_command("autoview") {
let mut output_stream = ctx
.run_command(
autoview,
Tag::unknown(),
Call::new(
Box::new(SpannedExpression::new(
Expression::Synthetic(Synthetic::String("autoview".into())),
Span::unknown(),
)),
Span::unknown(),
),
scope.clone(),
inp,
)
.await?;
loop {
match output_stream.try_next().await {
Ok(Some(ReturnSuccess::Value(Value {
value: UntaggedValue::Error(e),
..
}))) => return Err(e),
Ok(Some(_item)) => {
if let Some(err) = ctx.get_errors().get(0) {
ctx.clear_errors();
return Err(err.clone());
}
if ctx.ctrl_c.load(Ordering::SeqCst) {
break;
}
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 let Some(err) = ctx.get_errors().get(0) {
ctx.clear_errors();
return Err(err.clone());
}
Ok(None) => {
if let Some(err) = ctx.get_errors().get(0) {
ctx.clear_errors();
return Err(err.clone());
}
if ctx.ctrl_c.load(Ordering::SeqCst) {
break;
}
Err(e) => return Err(e),
}
Ok(None) => {
if let Some(err) = ctx.get_errors().get(0) {
ctx.clear_errors();
return Err(err.clone());
}
break;
}
Err(e) => return Err(e),
}
}
}
@ -71,54 +52,16 @@ pub(crate) async fn run_block(
return Err(e);
}
}
output = Ok(InputStream::empty());
for pipeline in &group.pipelines {
match output {
Ok(inp) if inp.is_empty() => {}
Ok(inp) => {
let mut output_stream = inp.to_output_stream();
output = run_pipeline(pipeline, ctx, input, scope.clone()).await;
loop {
match output_stream.try_next().await {
Ok(Some(ReturnSuccess::Value(Value {
value: UntaggedValue::Error(e),
..
}))) => return Err(e),
Ok(Some(_item)) => {
if let Some(err) = ctx.get_errors().get(0) {
ctx.clear_errors();
return Err(err.clone());
}
if ctx.ctrl_c.load(Ordering::SeqCst) {
break;
}
}
Ok(None) => {
if let Some(err) = ctx.get_errors().get(0) {
ctx.clear_errors();
return Err(err.clone());
}
break;
}
Err(e) => return Err(e),
}
}
}
Err(e) => {
return Err(e);
}
}
output = run_pipeline(pipeline, ctx, input, scope.clone()).await;
input = InputStream::empty();
}
input = InputStream::empty();
}
output
}
async fn run_pipeline(
commands: &Pipeline,
commands: &Commands,
ctx: &mut EvaluationContext,
mut input: InputStream,
scope: Arc<Scope>,

6
crates/nu-cli/src/commands/if_.rs
View File

@ -94,9 +94,9 @@ async fn if_command(
tag,
));
}
match condition.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
match condition.block[0].list.get(0) {
Some(item) => match item {
ClassifiedCommand::Expr(expr) => expr.clone(),
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",

6
crates/nu-cli/src/commands/keep/until.rs
View File

@ -51,9 +51,9 @@ impl WholeStreamCommand for SubCommand {
tag,
));
}
match block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
match block.block[0].list.get(0) {
Some(item) => match item {
ClassifiedCommand::Expr(expr) => expr.clone(),
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",

6
crates/nu-cli/src/commands/keep/while_.rs
View File

@ -50,9 +50,9 @@ impl WholeStreamCommand for SubCommand {
tag,
));
}
match block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
match block.block[0].list.get(0) {
Some(item) => match item {
ClassifiedCommand::Expr(expr) => expr.clone(),
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",

6
crates/nu-cli/src/commands/skip/until.rs
View File

@ -50,9 +50,9 @@ impl WholeStreamCommand for SubCommand {
tag,
));
}
match block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
match block.block[0].list.get(0) {
Some(item) => match item {
ClassifiedCommand::Expr(expr) => expr.clone(),
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",

6
crates/nu-cli/src/commands/skip/while_.rs
View File

@ -50,9 +50,9 @@ impl WholeStreamCommand for SubCommand {
tag,
));
}
match block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
match block.block[0].list.get(0) {
Some(item) => match item {
ClassifiedCommand::Expr(expr) => expr.clone(),
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",

6
crates/nu-cli/src/commands/where_.rs
View File

@ -81,9 +81,9 @@ async fn where_command(
tag,
));
}
match block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
match block.block[0].list.get(0) {
Some(item) => match item {
ClassifiedCommand::Expr(expr) => expr.clone(),
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",

8
crates/nu-cli/src/completion/engine.rs
View File

@ -138,7 +138,7 @@ impl<'s> Flatten<'s> {
result
}
fn pipeline(&self, pipeline: &Pipeline) -> Vec<CompletionLocation> {
fn pipeline(&self, pipeline: &Commands) -> Vec<CompletionLocation> {
let mut result = Vec::new();
for command in &pipeline.list {
@ -158,11 +158,7 @@ impl<'s> Flatten<'s> {
/// Flattens the block into a Vec of completion locations
pub fn completion_locations(&self, block: &Block) -> Vec<CompletionLocation> {
block
.block
.iter()
.flat_map(|g| g.pipelines.iter().flat_map(|v| self.pipeline(v)))
.collect()
block.block.iter().flat_map(|v| self.pipeline(v)).collect()
}
pub fn new(line: &'s str) -> Flatten<'s> {

4
crates/nu-cli/src/lib.rs
View File

@ -43,8 +43,8 @@ mod examples;
pub use crate::cli::cli;
pub use crate::cli::{
create_default_context, parse_and_eval, process_script, register_plugins, run_script_file,
run_script_standalone, LineResult,
create_default_context, parse_and_eval, process_line, register_plugins,
run_pipeline_standalone, run_vec_of_pipelines, LineResult,
};
pub use crate::command_registry::CommandRegistry;
pub use crate::commands::command::{

26
crates/nu-cli/src/types/deduction.rs
View File

@ -5,8 +5,8 @@ use nu_errors::ShellError;
use nu_parser::SignatureRegistry;
use nu_protocol::{
hir::{
Binary, Block, ClassifiedCommand, Expression, Literal, NamedArguments, NamedValue,
Operator, Pipeline, SpannedExpression,
Binary, Block, ClassifiedCommand, Commands, Expression, Literal, NamedArguments,
NamedValue, Operator, SpannedExpression,
},
NamedType, PositionalType, Signature, SyntaxShape,
};
@ -318,7 +318,7 @@ fn spanned_to_binary(bin_spanned: &SpannedExpression) -> &Binary {
///Returns result shape of this math expr otherwise
fn get_result_shape_of_math_expr(
bin: &Binary,
(pipeline_idx, pipeline): (usize, &Pipeline),
(pipeline_idx, pipeline): (usize, &Commands),
registry: &CommandRegistry,
) -> Result<Option<SyntaxShape>, ShellError> {
let mut shapes: Vec<Option<SyntaxShape>> = vec![];
@ -388,17 +388,15 @@ impl VarSyntaxShapeDeductor {
fn infer_shape(&mut self, block: &Block, registry: &CommandRegistry) -> Result<(), ShellError> {
trace!("Infering vars in shape");
for group in &block.block {
for pipeline in &group.pipelines {
self.infer_pipeline(pipeline, registry)?;
}
for pipeline in &block.block {
self.infer_pipeline(pipeline, registry)?;
}
Ok(())
}
pub fn infer_pipeline(
&mut self,
pipeline: &Pipeline,
pipeline: &Commands,
registry: &CommandRegistry,
) -> Result<(), ShellError> {
trace!("Infering vars in pipeline");
@ -536,7 +534,7 @@ impl VarSyntaxShapeDeductor {
fn infer_shapes_in_expr(
&mut self,
(pipeline_idx, pipeline): (usize, &Pipeline),
(pipeline_idx, pipeline): (usize, &Commands),
spanned_expr: &SpannedExpression,
registry: &CommandRegistry,
) -> Result<(), ShellError> {
@ -662,7 +660,7 @@ impl VarSyntaxShapeDeductor {
(var, expr): (&VarUsage, &SpannedExpression),
//source_bin is binary having var on one and expr on other side
source_bin: &SpannedExpression,
(pipeline_idx, pipeline): (usize, &Pipeline),
(pipeline_idx, pipeline): (usize, &Commands),
registry: &CommandRegistry,
) -> Result<Option<SyntaxShape>, ShellError> {
get_result_shape_of_math_expr(spanned_to_binary(expr), (pipeline_idx, pipeline), registry)
@ -684,7 +682,7 @@ impl VarSyntaxShapeDeductor {
(var, expr): (&VarUsage, &SpannedExpression),
//source_bin is binary having var on one and expr on other side
source_bin: &SpannedExpression,
(pipeline_idx, pipeline): (usize, &Pipeline),
(pipeline_idx, pipeline): (usize, &Commands),
registry: &CommandRegistry,
) -> Result<Option<SyntaxShape>, ShellError> {
trace!("Getting shape of binary arg {:?} for var {:?}", expr, var);
@ -716,7 +714,7 @@ impl VarSyntaxShapeDeductor {
var: &VarUsage,
bin_spanned: &SpannedExpression,
list: &[SpannedExpression],
(_pipeline_idx, _pipeline): (usize, &Pipeline),
(_pipeline_idx, _pipeline): (usize, &Commands),
_registry: &CommandRegistry,
) -> Option<Vec<SyntaxShape>> {
let shapes_in_list = list
@ -742,7 +740,7 @@ impl VarSyntaxShapeDeductor {
var_side: BinarySide,
//Binary having expr on one side and var on other
bin_spanned: &SpannedExpression,
(pipeline_idx, pipeline): (usize, &Pipeline),
(pipeline_idx, pipeline): (usize, &Commands),
registry: &CommandRegistry,
) -> Result<(), ShellError> {
trace!("Infering shapes between var {:?} and expr {:?}", var, expr);
@ -895,7 +893,7 @@ impl VarSyntaxShapeDeductor {
fn infer_shapes_in_binary_expr(
&mut self,
(pipeline_idx, pipeline): (usize, &Pipeline),
(pipeline_idx, pipeline): (usize, &Commands),
bin_spanned: &SpannedExpression,
registry: &CommandRegistry,
) -> Result<(), ShellError> {

17
crates/nu-parser/src/lite_parse.rs
View File

@ -117,17 +117,6 @@ impl LiteGroup {
pub fn push(&mut self, item: LitePipeline) {
self.pipelines.push(item)
}
pub fn is_comment(&self) -> bool {
if !self.is_empty()
&& !self.pipelines[0].is_empty()
&& !self.pipelines[0].commands.is_empty()
&& !self.pipelines[0].commands[0].parts.is_empty()
{
self.pipelines[0].commands[0].parts[0].item.starts_with('#')
} else {
false
}
}
pub(crate) fn span(&self) -> Span {
let start = if !self.pipelines.is_empty() {
self.pipelines[0].span().start()
@ -359,9 +348,7 @@ fn group(tokens: Vec<Token>) -> (LiteBlock, Option<ParseError>) {
pipeline = LitePipeline::new();
}
if !group.is_empty() {
if !group.is_comment() {
groups.push(group);
}
groups.push(group);
group = LiteGroup::new();
}
}
@ -402,7 +389,7 @@ fn group(tokens: Vec<Token>) -> (LiteBlock, Option<ParseError>) {
if !pipeline.is_empty() {
group.push(pipeline);
}
if !group.is_empty() && !group.is_comment() {
if !group.is_empty() {
groups.push(group);
}

35
crates/nu-parser/src/parse.rs
View File

@ -3,9 +3,9 @@ use std::path::Path;
use log::trace;
use nu_errors::{ArgumentError, ParseError};
use nu_protocol::hir::{
self, Binary, Block, ClassifiedBlock, ClassifiedCommand, ClassifiedPipeline, Expression,
ExternalRedirection, Flag, FlagKind, Group, InternalCommand, Member, NamedArguments, Operator,
Pipeline, RangeOperator, SpannedExpression, Unit,
self, Binary, Block, ClassifiedBlock, ClassifiedCommand, ClassifiedPipeline, Commands,
Expression, ExternalRedirection, Flag, FlagKind, InternalCommand, Member, NamedArguments,
Operator, RangeOperator, SpannedExpression, Unit,
};
use nu_protocol::{NamedType, PositionalType, Signature, SyntaxShape, UnspannedPathMember};
use nu_source::{Span, Spanned, SpannedItem};
@ -584,7 +584,7 @@ fn parse_interpolated_string(
}
}
let pipelines = vec![Pipeline {
let block = vec![Commands {
span: lite_arg.span,
list: vec![ClassifiedCommand::Internal(InternalCommand {
name: "build-string".to_owned(),
@ -602,10 +602,8 @@ fn parse_interpolated_string(
})],
}];
let group = Group::new(pipelines, lite_arg.span);
let call = SpannedExpression {
expr: Expression::Invocation(Block::new(vec![], vec![group], lite_arg.span)),
expr: Expression::Invocation(Block::new(vec![], block, lite_arg.span)),
span: lite_arg.span,
};
@ -1343,14 +1341,10 @@ fn parse_positional_argument(
parse_math_expression(idx, &lite_cmd.parts[idx..end_idx], registry, true);
let span = arg.span;
let mut commands = hir::Pipeline::new(span);
let mut commands = hir::Commands::new(span);
commands.push(ClassifiedCommand::Expr(Box::new(arg)));
let block = hir::Block::new(
vec![],
vec![Group::new(vec![commands], lite_cmd.span())],
span,
);
let block = hir::Block::new(vec![], vec![commands], span);
let arg = SpannedExpression::new(Expression::Block(block), span);
@ -1544,7 +1538,7 @@ fn classify_pipeline(
lite_pipeline: &LitePipeline,
registry: &dyn SignatureRegistry,
) -> (ClassifiedPipeline, Option<ParseError>) {
let mut commands = Pipeline::new(lite_pipeline.span());
let mut commands = Commands::new(lite_pipeline.span());
let mut error = None;
let mut iter = lite_pipeline.commands.iter().peekable();
@ -1751,10 +1745,10 @@ fn expand_shorthand_forms(
}
pub fn classify_block(lite_block: &LiteBlock, registry: &dyn SignatureRegistry) -> ClassifiedBlock {
let mut block = vec![];
let mut command_list = vec![];
let mut error = None;
for lite_group in &lite_block.block {
let mut command_list = vec![];
for lite_pipeline in &lite_group.pipelines {
let (lite_pipeline, vars, err) = expand_shorthand_forms(lite_pipeline);
if error.is_none() {
@ -1765,8 +1759,7 @@ pub fn classify_block(lite_block: &LiteBlock, registry: &dyn SignatureRegistry)
let pipeline = if let Some(vars) = vars {
let span = pipeline.commands.span;
let group = Group::new(vec![pipeline.commands.clone()], span);
let block = hir::Block::new(vec![], vec![group], span);
let block = hir::Block::new(vec![], vec![pipeline.commands.clone()], span);
let mut call = hir::Call::new(
Box::new(SpannedExpression {
expr: Expression::string("with-env".to_string()),
@ -1799,7 +1792,7 @@ pub fn classify_block(lite_block: &LiteBlock, registry: &dyn SignatureRegistry)
args: call,
});
ClassifiedPipeline {
commands: Pipeline {
commands: Commands {
list: vec![classified_with_env],
span,
},
@ -1813,10 +1806,8 @@ pub fn classify_block(lite_block: &LiteBlock, registry: &dyn SignatureRegistry)
error = err;
}
}
let group = Group::new(command_list, lite_block.span());
block.push(group);
}
let block = Block::new(vec![], block, lite_block.span());
let block = Block::new(vec![], command_list, lite_block.span());
ClassifiedBlock::new(block, error)
}

46
crates/nu-parser/src/shapes.rs
View File

@ -88,39 +88,35 @@ pub fn expression_to_flat_shape(e: &SpannedExpression) -> Vec<Spanned<FlatShape>
pub fn shapes(commands: &Block) -> Vec<Spanned<FlatShape>> {
let mut output = vec![];
for group in &commands.block {
for pipeline in &group.pipelines {
for command in &pipeline.list {
match command {
ClassifiedCommand::Internal(internal) => {
output.append(&mut expression_to_flat_shape(&internal.args.head));
for pipeline in &commands.block {
for command in &pipeline.list {
match command {
ClassifiedCommand::Internal(internal) => {
output.append(&mut expression_to_flat_shape(&internal.args.head));
if let Some(positionals) = &internal.args.positional {
for positional_arg in positionals {
output.append(&mut expression_to_flat_shape(positional_arg));
}
if let Some(positionals) = &internal.args.positional {
for positional_arg in positionals {
output.append(&mut expression_to_flat_shape(positional_arg));
}
}
if let Some(named) = &internal.args.named {
for (_, named_arg) in named.iter() {
match named_arg {
NamedValue::PresentSwitch(span) => {
output.push(FlatShape::Flag.spanned(*span));
}
NamedValue::Value(span, expr) => {
output.push(FlatShape::Flag.spanned(*span));
output.append(&mut expression_to_flat_shape(expr));
}
_ => {}
if let Some(named) = &internal.args.named {
for (_, named_arg) in named.iter() {
match named_arg {
NamedValue::PresentSwitch(span) => {
output.push(FlatShape::Flag.spanned(*span));
}
NamedValue::Value(span, expr) => {
output.push(FlatShape::Flag.spanned(*span));
output.append(&mut expression_to_flat_shape(expr));
}
_ => {}
}
}
}
ClassifiedCommand::Expr(expr) => {
output.append(&mut expression_to_flat_shape(expr))
}
_ => {}
}
ClassifiedCommand::Expr(expr) => output.append(&mut expression_to_flat_shape(expr)),
_ => {}
}
}
}

49
crates/nu-protocol/src/hir.rs
View File

@ -62,11 +62,11 @@ impl ClassifiedBlock {
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
pub struct ClassifiedPipeline {
pub commands: Pipeline,
pub commands: Commands,
}
impl ClassifiedPipeline {
pub fn new(commands: Pipeline) -> ClassifiedPipeline {
pub fn new(commands: Commands) -> ClassifiedPipeline {
ClassifiedPipeline { commands }
}
}
@ -92,14 +92,14 @@ impl ClassifiedCommand {
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
pub struct Pipeline {
pub struct Commands {
pub list: Vec<ClassifiedCommand>,
pub span: Span,
}
impl Pipeline {
pub fn new(span: Span) -> Pipeline {
Pipeline { list: vec![], span }
impl Commands {
pub fn new(span: Span) -> Commands {
Commands { list: vec![], span }
}
pub fn push(&mut self, command: ClassifiedCommand) {
@ -111,34 +111,15 @@ impl Pipeline {
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
pub struct Group {
pub pipelines: Vec<Pipeline>,
pub span: Span,
}
impl Group {
pub fn new(pipelines: Vec<Pipeline>, span: Span) -> Group {
Group { pipelines, span }
}
pub fn push(&mut self, pipeline: Pipeline) {
self.pipelines.push(pipeline);
}
pub fn has_it_usage(&self) -> bool {
self.pipelines.iter().any(|cc| cc.has_it_usage())
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
pub struct Block {
pub params: Vec<String>,
pub block: Vec<Group>,
pub block: Vec<Commands>,
pub span: Span,
}
impl Block {
pub fn new(params: Vec<String>, block: Vec<Group>, span: Span) -> Block {
pub fn new(params: Vec<String>, block: Vec<Commands>, span: Span) -> Block {
let mut output = Block {
params,
block,
@ -149,18 +130,16 @@ impl Block {
output
}
pub fn push(&mut self, group: Group) {
self.block.push(group);
pub fn push(&mut self, commands: Commands) {
self.block.push(commands);
self.infer_params();
}
pub fn set_redirect(&mut self, external_redirection: ExternalRedirection) {
if let Some(group) = self.block.last_mut() {
if let Some(pipeline) = group.pipelines.last_mut() {
if let Some(command) = pipeline.list.last_mut() {
if let ClassifiedCommand::Internal(internal) = command {
internal.args.external_redirection = external_redirection;
}
if let Some(pipeline) = self.block.last_mut() {
if let Some(command) = pipeline.list.last_mut() {
if let ClassifiedCommand::Internal(internal) = command {
internal.args.external_redirection = external_redirection;
}
}
}

34
src/main.rs
View File

@ -4,7 +4,7 @@ use nu_cli::create_default_context;
use nu_cli::utils::test_bins as binaries;
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;
use std::io::{prelude::*, BufReader};
fn main() -> Result<(), Box<dyn Error>> {
let matches = App::new("nushell")
@ -124,12 +124,9 @@ fn main() -> Result<(), Box<dyn Error>> {
match matches.values_of("commands") {
None => {}
Some(values) => {
let script_text: String = values
.map(|x| x.to_string())
.collect::<Vec<String>>()
.join("\n");
futures::executor::block_on(nu_cli::run_script_file(
script_text,
let pipelines: Vec<String> = values.map(|x| x.to_string()).collect();
futures::executor::block_on(nu_cli::run_vec_of_pipelines(
pipelines,
matches.is_present("stdin"),
))?;
return Ok(());
@ -138,12 +135,25 @@ fn main() -> Result<(), Box<dyn Error>> {
match matches.value_of("script") {
Some(script) => {
let mut file = File::open(script)?;
let mut buffer = String::new();
file.read_to_string(&mut buffer)?;
let file = File::open(script)?;
let reader = BufReader::new(file);
let pipelines: Vec<String> = reader
.lines()
.filter_map(|x| {
if let Ok(x) = x {
if !x.starts_with('#') {
Some(x)
} else {
None
}
} else {
None
}
})
.collect();
futures::executor::block_on(nu_cli::run_script_file(
buffer,
futures::executor::block_on(nu_cli::run_vec_of_pipelines(
pipelines,
matches.is_present("stdin"),
))?;
return Ok(());