Mirrors/nushell
2
0
Fork 0
mirror of https://github.com/nushell/nushell synced 2025-01-14 06:04:09 +00:00
Code Issues Projects Releases Packages Wiki Activity

Do a bit more cleanup of block params (#3455)

Browse source 
* Do a bit more cleanup of block params

* Do a bit more cleanup of block params
This commit is contained in:
JT 2021-05-21 19:04:27 +12:00 committed by GitHub
parent 28388b4e3a
commit 751de20f93
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 157 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
crates/nu-command/src/commands.rs
View file

@ -360,6 +360,7 @@ mod tests {
#[test] #[test]
fn examples_work_as_expected() -> Result<(), ShellError> { fn examples_work_as_expected() -> Result<(), ShellError> {
for cmd in only_examples() { for cmd in only_examples() {
println!("cmd: {}", cmd.name());
test_examples(cmd)?; test_examples(cmd)?;
} }

4
crates/nu-command/src/commands/any.rs
View file

@ -98,7 +98,9 @@ fn any(args: CommandArgs) -> Result<OutputStream, ShellError> {
let result = args.input.fold(init, move |acc, row| { let result = args.input.fold(init, move |acc, row| {
let condition = condition.clone(); let condition = condition.clone();
let ctx = ctx.clone(); let ctx = ctx.clone();
ctx.scope.add_var("$it", row); if let Some((arg, _)) = any_args.predicate.block.params.positional.first() {
ctx.scope.add_var(arg.name(), row);
}
let condition = evaluate_baseline_expr(&condition, &ctx); let condition = evaluate_baseline_expr(&condition, &ctx);

13
crates/nu-command/src/commands/each/command.rs
View file

@ -88,17 +88,8 @@ pub fn process_row(
context.scope.enter_scope(); context.scope.enter_scope();
context.scope.add_vars(&captured_block.captured.entries); context.scope.add_vars(&captured_block.captured.entries);
if !captured_block.block.params.positional.is_empty() { if let Some((arg, _)) = captured_block.block.params.positional.first() {
if captured_block.block.params.positional.len() > 1 { context.scope.add_var(arg.name(), input);
return Err(ShellError::labeled_error(
"Expected block with less than two parameters",
"too many parameters",
captured_block.block.span,
));
}
context
.scope
.add_var(captured_block.block.params.positional[0].0.name(), input);
} else { } else {
context.scope.add_var("$it", input); context.scope.add_var("$it", input);
} }

4
crates/nu-command/src/commands/empty.rs
View file

@ -140,7 +140,9 @@ fn process_row(
context.scope.enter_scope(); context.scope.enter_scope();
context.scope.add_vars(&default_block.captured.entries); context.scope.add_vars(&default_block.captured.entries);
context.scope.add_var("$it", input.clone()); if let Some((arg, _)) = default_block.block.params.positional.first() {
context.scope.add_var(arg.name(), input.clone());
}
let stream = run_block( let stream = run_block(
&default_block.block, &default_block.block,

4
crates/nu-command/src/commands/insert.rs
View file

@ -80,7 +80,9 @@ fn process_row(
context.scope.enter_scope(); context.scope.enter_scope();
context.scope.add_vars(&block.captured.entries); context.scope.add_vars(&block.captured.entries);
context.scope.add_var("$it", input.clone()); if let Some((arg, _)) = block.block.params.positional.first() {
context.scope.add_var(arg.name(), input.clone());
}
let result = run_block( let result = run_block(
&block.block, &block.block,

70
crates/nu-command/src/commands/keep/until.rs
View file

@ -1,10 +1,12 @@
use crate::prelude::*; use crate::prelude::*;
use log::trace;
use nu_engine::evaluate_baseline_expr; use nu_engine::evaluate_baseline_expr;
use nu_engine::WholeStreamCommand; use nu_engine::WholeStreamCommand;
use nu_errors::ShellError; use nu_errors::ShellError;
use nu_parser::ParserScope; use nu_parser::ParserScope;
use nu_protocol::{hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue, Value}; use nu_protocol::{
hir::{CapturedBlock, ClassifiedCommand},
Signature, SyntaxShape,
};
pub struct SubCommand; pub struct SubCommand;
@ -29,52 +31,38 @@ impl WholeStreamCommand for SubCommand {
fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> { fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
let ctx = Arc::new(EvaluationContext::from_args(&args)); let ctx = Arc::new(EvaluationContext::from_args(&args));
let tag = args.call_info.name_tag.clone();
let call_info = args.evaluate_once()?; let call_info = args.evaluate_once()?;
let block = call_info.args.expect_nth(0)?.clone(); let block: CapturedBlock = call_info.req(0)?;
let condition = {
let (condition, captured) = match block { if block.block.block.len() != 1 {
Value { return Err(ShellError::labeled_error(
value: UntaggedValue::Block(captured_block), "Expected a condition",
tag, "expected a condition",
} => { tag,
if captured_block.block.block.len() != 1 { ));
return Err(ShellError::labeled_error( }
"Expected a condition", match block.block.block[0].pipelines.get(0) {
"expected a condition", Some(item) => match item.list.get(0) {
tag, Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
)); _ => {
}
match captured_block.block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => {
(Arc::new(expr.clone()), captured_block.captured.clone())
}
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
}
},
None => {
return Err(ShellError::labeled_error( return Err(ShellError::labeled_error(
"Expected a condition", "Expected a condition",
"expected a condition", "expected a condition",
tag, tag,
)); ));
} }
},
None => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
} }
} }
Value { tag, .. } => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
}
}; };
Ok(call_info Ok(call_info
@ -83,13 +71,13 @@ impl WholeStreamCommand for SubCommand {
let condition = condition.clone(); let condition = condition.clone();
let ctx = ctx.clone(); let ctx = ctx.clone();
ctx.scope.enter_scope(); ctx.scope.enter_scope();
ctx.scope.add_vars(&captured.entries); ctx.scope.add_vars(&block.captured.entries);
ctx.scope.add_var("$it", item.clone()); if let Some((arg, _)) = block.block.params.positional.first() {
trace!("ITEM = {:?}", item); ctx.scope.add_var(arg.name(), item.clone());
}
let result = evaluate_baseline_expr(&*condition, &*ctx); let result = evaluate_baseline_expr(&*condition, &*ctx);
ctx.scope.exit_scope(); ctx.scope.exit_scope();
trace!("RESULT = {:?}", result);
!matches!(result, Ok(ref v) if v.is_true()) !matches!(result, Ok(ref v) if v.is_true())
}) })

67
crates/nu-command/src/commands/keep/while_.rs
View file

@ -3,7 +3,10 @@ use log::trace;
use nu_engine::evaluate_baseline_expr; use nu_engine::evaluate_baseline_expr;
use nu_engine::WholeStreamCommand; use nu_engine::WholeStreamCommand;
use nu_errors::ShellError; use nu_errors::ShellError;
use nu_protocol::{hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue, Value}; use nu_protocol::{
hir::{CapturedBlock, ClassifiedCommand},
Signature, SyntaxShape,
};
pub struct SubCommand; pub struct SubCommand;
@ -28,51 +31,37 @@ impl WholeStreamCommand for SubCommand {
fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> { fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
let ctx = Arc::new(EvaluationContext::from_args(&args)); let ctx = Arc::new(EvaluationContext::from_args(&args));
let tag = args.call_info.name_tag.clone();
let call_info = args.evaluate_once()?; let call_info = args.evaluate_once()?;
let block = call_info.args.expect_nth(0)?.clone(); let block: CapturedBlock = call_info.req(0)?;
let condition = {
let (condition, captured) = match block { if block.block.block.len() != 1 {
Value { return Err(ShellError::labeled_error(
value: UntaggedValue::Block(captured_block), "Expected a condition",
tag, "expected a condition",
} => { tag,
if captured_block.block.block.len() != 1 { ));
return Err(ShellError::labeled_error( }
"Expected a condition", match block.block.block[0].pipelines.get(0) {
"expected a condition", Some(item) => match item.list.get(0) {
tag, Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
)); _ => {
}
match captured_block.block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => {
(Arc::new(expr.clone()), captured_block.captured.clone())
}
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
}
},
None => {
return Err(ShellError::labeled_error( return Err(ShellError::labeled_error(
"Expected a condition", "Expected a condition",
"expected a condition", "expected a condition",
tag, tag,
)); ));
} }
},
None => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
} }
} }
Value { tag, .. } => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
}
}; };
Ok(call_info Ok(call_info
@ -82,8 +71,10 @@ impl WholeStreamCommand for SubCommand {
let ctx = ctx.clone(); let ctx = ctx.clone();
ctx.scope.enter_scope(); ctx.scope.enter_scope();
ctx.scope.add_var("$it", item.clone()); ctx.scope.add_vars(&block.captured.entries);
ctx.scope.add_vars(&captured.entries); if let Some((arg, _)) = block.block.params.positional.first() {
ctx.scope.add_var(arg.name(), item.clone());
}
trace!("ITEM = {:?}", item); trace!("ITEM = {:?}", item);
let result = evaluate_baseline_expr(&*condition, &*ctx); let result = evaluate_baseline_expr(&*condition, &*ctx);

8
crates/nu-command/src/commands/reduce.rs
View file

@ -89,7 +89,13 @@ fn process_row(
context.scope.enter_scope(); context.scope.enter_scope();
context.scope.add_vars(&block.captured.entries); context.scope.add_vars(&block.captured.entries);
context.scope.add_var("$it", row);
if let Some((arg, _)) = block.block.params.positional.first() {
context.scope.add_var(arg.name(), row);
} else {
context.scope.add_var("$it", row);
}
let result = run_block( let result = run_block(
&block.block, &block.block,
context, context,

67
crates/nu-command/src/commands/skip/until.rs
View file

@ -3,7 +3,10 @@ use log::trace;
use nu_engine::evaluate_baseline_expr; use nu_engine::evaluate_baseline_expr;
use nu_engine::WholeStreamCommand; use nu_engine::WholeStreamCommand;
use nu_errors::ShellError; use nu_errors::ShellError;
use nu_protocol::{hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue, Value}; use nu_protocol::{
hir::{CapturedBlock, ClassifiedCommand},
Signature, SyntaxShape,
};
pub struct SubCommand; pub struct SubCommand;
@ -28,51 +31,37 @@ impl WholeStreamCommand for SubCommand {
fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> { fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
let ctx = Arc::new(EvaluationContext::from_args(&args)); let ctx = Arc::new(EvaluationContext::from_args(&args));
let tag = args.call_info.name_tag.clone();
let call_info = args.evaluate_once()?; let call_info = args.evaluate_once()?;
let block = call_info.args.expect_nth(0)?.clone(); let block: CapturedBlock = call_info.req(0)?;
let condition = {
let (condition, captured) = match block { if block.block.block.len() != 1 {
Value { return Err(ShellError::labeled_error(
value: UntaggedValue::Block(captured_block), "Expected a condition",
tag, "expected a condition",
} => { tag,
if captured_block.block.block.len() != 1 { ));
return Err(ShellError::labeled_error( }
"Expected a condition", match block.block.block[0].pipelines.get(0) {
"expected a condition", Some(item) => match item.list.get(0) {
tag, Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
)); _ => {
}
match captured_block.block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => {
(Arc::new(expr.clone()), captured_block.captured.clone())
}
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
}
},
None => {
return Err(ShellError::labeled_error( return Err(ShellError::labeled_error(
"Expected a condition", "Expected a condition",
"expected a condition", "expected a condition",
tag, tag,
)); ));
} }
},
None => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
} }
} }
Value { tag, .. } => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
}
}; };
Ok(call_info Ok(call_info
@ -82,8 +71,10 @@ impl WholeStreamCommand for SubCommand {
let ctx = ctx.clone(); let ctx = ctx.clone();
ctx.scope.enter_scope(); ctx.scope.enter_scope();
ctx.scope.add_var("$it", item.clone()); ctx.scope.add_vars(&block.captured.entries);
ctx.scope.add_vars(&captured.entries); if let Some((arg, _)) = block.block.params.positional.first() {
ctx.scope.add_var(arg.name(), item.clone());
}
trace!("ITEM = {:?}", item); trace!("ITEM = {:?}", item);
let result = evaluate_baseline_expr(&*condition, &*ctx); let result = evaluate_baseline_expr(&*condition, &*ctx);

67
crates/nu-command/src/commands/skip/while_.rs
View file

@ -3,7 +3,10 @@ use log::trace;
use nu_engine::evaluate_baseline_expr; use nu_engine::evaluate_baseline_expr;
use nu_engine::WholeStreamCommand; use nu_engine::WholeStreamCommand;
use nu_errors::ShellError; use nu_errors::ShellError;
use nu_protocol::{hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue, Value}; use nu_protocol::{
hir::{CapturedBlock, ClassifiedCommand},
Signature, SyntaxShape,
};
pub struct SubCommand; pub struct SubCommand;
@ -28,51 +31,37 @@ impl WholeStreamCommand for SubCommand {
fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> { fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
let ctx = Arc::new(EvaluationContext::from_args(&args)); let ctx = Arc::new(EvaluationContext::from_args(&args));
let tag = args.call_info.name_tag.clone();
let call_info = args.evaluate_once()?; let call_info = args.evaluate_once()?;
let block = call_info.args.expect_nth(0)?.clone(); let block: CapturedBlock = call_info.req(0)?;
let condition = {
let (condition, captured) = match block { if block.block.block.len() != 1 {
Value { return Err(ShellError::labeled_error(
value: UntaggedValue::Block(captured_block), "Expected a condition",
tag, "expected a condition",
} => { tag,
if captured_block.block.block.len() != 1 { ));
return Err(ShellError::labeled_error( }
"Expected a condition", match block.block.block[0].pipelines.get(0) {
"expected a condition", Some(item) => match item.list.get(0) {
tag, Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
)); _ => {
}
match captured_block.block.block[0].pipelines.get(0) {
Some(item) => match item.list.get(0) {
Some(ClassifiedCommand::Expr(expr)) => {
(Arc::new(expr.clone()), captured_block.captured.clone())
}
_ => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
}
},
None => {
return Err(ShellError::labeled_error( return Err(ShellError::labeled_error(
"Expected a condition", "Expected a condition",
"expected a condition", "expected a condition",
tag, tag,
)); ));
} }
},
None => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
} }
} }
Value { tag, .. } => {
return Err(ShellError::labeled_error(
"Expected a condition",
"expected a condition",
tag,
));
}
}; };
Ok(call_info Ok(call_info
@ -83,8 +72,10 @@ impl WholeStreamCommand for SubCommand {
let ctx = ctx.clone(); let ctx = ctx.clone();
ctx.scope.enter_scope(); ctx.scope.enter_scope();
ctx.scope.add_vars(&captured.entries); ctx.scope.add_vars(&block.captured.entries);
ctx.scope.add_var("$it", item.clone()); if let Some((arg, _)) = block.block.params.positional.first() {
ctx.scope.add_var(arg.name(), item.clone());
}
trace!("ITEM = {:?}", item); trace!("ITEM = {:?}", item);
let result = evaluate_baseline_expr(&*condition, &*ctx); let result = evaluate_baseline_expr(&*condition, &*ctx);

5
crates/nu-command/src/commands/update.rs
View file

@ -84,7 +84,10 @@ fn process_row(
let input_stream = vec![Ok(for_block)].into_iter().to_input_stream(); let input_stream = vec![Ok(for_block)].into_iter().to_input_stream();
context.scope.enter_scope(); context.scope.enter_scope();
context.scope.add_var("$it", input.clone()); if let Some((arg, _)) = captured_block.block.params.positional.first() {
context.scope.add_var(arg.name(), input.clone());
}
context.scope.add_vars(&captured_block.captured.entries); context.scope.add_vars(&captured_block.captured.entries);
let result = run_block( let result = run_block(

5
crates/nu-command/src/commands/where_.rs
View file

@ -130,7 +130,10 @@ impl Iterator for WhereIterator {
while let Some(x) = self.input.next() { while let Some(x) = self.input.next() {
self.context.scope.enter_scope(); self.context.scope.enter_scope();
self.context.scope.add_vars(&self.block.captured.entries); self.context.scope.add_vars(&self.block.captured.entries);
self.context.scope.add_var("$it", x.clone());
if let Some((arg, _)) = self.block.block.params.positional.first() {
self.context.scope.add_var(arg.name(), x.clone());
}
//FIXME: should we use the scope that's brought in as well? //FIXME: should we use the scope that's brought in as well?
let condition = evaluate_baseline_expr(&self.condition, &self.context); let condition = evaluate_baseline_expr(&self.condition, &self.context);

2
crates/nu-command/src/examples.rs
View file

@ -51,8 +51,6 @@ pub fn test_examples(cmd: Command) -> Result<(), ShellError> {
let block = parse_line(sample_pipeline.example, &ctx)?; let block = parse_line(sample_pipeline.example, &ctx)?;
println!("{:#?}", block);
if let Some(expected) = &sample_pipeline.result { if let Some(expected) = &sample_pipeline.result {
let result = evaluate_block(block, &mut ctx)?; let result = evaluate_block(block, &mut ctx)?;

4
crates/nu-parser/src/parse.rs
View file

@ -1410,13 +1410,15 @@ fn parse_positional_argument(
let mut commands = hir::Pipeline::new(span); let mut commands = hir::Pipeline::new(span);
commands.push(ClassifiedCommand::Expr(Box::new(arg))); commands.push(ClassifiedCommand::Expr(Box::new(arg)));
let block = hir::Block::new( let mut block = hir::Block::new(
Signature::new("<cond>"), Signature::new("<cond>"),
vec![Group::new(vec![commands], lite_cmd.span())], vec![Group::new(vec![commands], lite_cmd.span())],
IndexMap::new(), IndexMap::new(),
span, span,
); );
block.infer_params();
let arg = SpannedExpression::new(Expression::Block(Arc::new(block)), span); let arg = SpannedExpression::new(Expression::Block(Arc::new(block)), span);
idx = new_idx - 1; idx = new_idx - 1;

22
tests/shell/pipeline/commands/internal.rs
View file

@ -379,17 +379,6 @@ fn proper_shadow_let_aliases() {
assert_eq!(actual.out, "falsetruefalse"); assert_eq!(actual.out, "falsetruefalse");
} }
#[test]
fn block_param_too_many() {
let actual = nu!(
cwd: ".",
r#"
[1, 2, 3] | each { |a, b| echo $a }
"#
);
assert!(actual.err.contains("too many"));
}
#[test] #[test]
fn block_params_override() { fn block_params_override() {
let actual = nu!( let actual = nu!(
@ -401,6 +390,17 @@ fn block_params_override() {
assert!(actual.err.contains("unknown variable")); assert!(actual.err.contains("unknown variable"));
} }
#[test]
fn block_params_override_correct() {
let actual = nu!(
cwd: ".",
r#"
[1, 2, 3] | each { |a| echo $a } | to json
"#
);
assert_eq!(actual.out, "[1,2,3]");
}
#[test] #[test]
fn run_dynamic_blocks() { fn run_dynamic_blocks() {
let actual = nu!( let actual = nu!(