holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'main' into fix_for

Browse Source
This commit is contained in:
JT
2021-10-10 05:20:50 +13:00
parent 789fc30bf9 2c01901fcf
commit 5d36d37d20
12 changed files with 347 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
crates/nu-command/src/core_commands/for_.rs
View File

@ -99,34 +99,43 @@ impl Command for For {
Example {
description: "Echo the square of each integer",
example: "for x in [1 2 3] { $x * $x }",
result: Some(vec![
Value::Int { val: 1, span },
Value::Int { val: 4, span },
Value::Int { val: 9, span },
]),
result: Some(Value::List {
vals: vec![
Value::Int { val: 1, span },
Value::Int { val: 4, span },
Value::Int { val: 9, span },
],
span: Span::unknown(),
}),
},
Example {
description: "Work with elements of a range",
example: "for $x in 1..3 { $x }",
result: Some(vec![
Value::Int { val: 1, span },
Value::Int { val: 2, span },
Value::Int { val: 3, span },
]),
result: Some(Value::List {
vals: vec![
Value::Int { val: 1, span },
Value::Int { val: 2, span },
Value::Int { val: 3, span },
],
span: Span::unknown(),
}),
},
Example {
description: "Number each item and echo a message",
example: "for $it in ['bob' 'fred'] --numbered { $\"($it.index) is ($it.item)\" }",
result: Some(vec![
Value::String {
val: "0 is bob".into(),
span,
},
Value::String {
val: "0 is fred".into(),
span,
},
]),
result: Some(Value::List {
vals: vec![
Value::String {
val: "0 is bob".into(),
span,
},
Value::String {
val: "0 is fred".into(),
span,
},
],
span: Span::unknown(),
}),
},
]
}

75
crates/nu-command/src/example_test.rs Normal file
View File

@ -0,0 +1,75 @@
use std::{cell::RefCell, rc::Rc};
use nu_engine::eval_block;
use nu_parser::parse;
use nu_protocol::{
engine::{Command, EngineState, EvaluationContext, StateWorkingSet},
Value,
};
use super::{From, Split};
pub fn test_examples(cmd: impl Command + 'static) {
let examples = cmd.examples();
let engine_state = Rc::new(RefCell::new(EngineState::new()));
let delta = {
// Base functions that are needed for testing
// Try to keep this working set small to keep tests running as fast as possible
let engine_state = engine_state.borrow();
let mut working_set = StateWorkingSet::new(&*engine_state);
working_set.add_decl(Box::new(From));
working_set.add_decl(Box::new(Split));
// Adding the command that is being tested to the working set
working_set.add_decl(Box::new(cmd));
working_set.render()
};
EngineState::merge_delta(&mut *engine_state.borrow_mut(), delta);
for example in examples {
let start = std::time::Instant::now();
let (block, delta) = {
let engine_state = engine_state.borrow();
let mut working_set = StateWorkingSet::new(&*engine_state);
let (output, err) = parse(&mut working_set, None, example.example.as_bytes(), false);
if let Some(err) = err {
panic!("test parse error: {:?}", err)
}
(output, working_set.render())
};
EngineState::merge_delta(&mut *engine_state.borrow_mut(), delta);
let state = EvaluationContext {
engine_state: engine_state.clone(),
stack: nu_protocol::engine::Stack::new(),
};
match eval_block(&state, &block, Value::nothing()) {
Err(err) => panic!("test eval error: {:?}", err),
Ok(result) => {
println!("input: {}", example.example);
println!("result: {:?}", result);
println!("done: {:?}", start.elapsed());
// Note. Value implements PartialEq for Bool, Int, Float, String and Block
// If the command you are testing requires to compare another case, then
// you need to define its equality in the Value struct
if let Some(expected) = example.result {
if result != expected {
panic!(
"the example result is different to expected value: {:?} != {:?}",
result, expected
)
}
}
}
}
}
}

40
crates/nu-command/src/filters/each.rs
View File

@ -1,7 +1,7 @@
use nu_engine::eval_block;
use nu_protocol::ast::Call;
use nu_protocol::engine::{Command, EvaluationContext};
use nu_protocol::{IntoValueStream, Signature, SyntaxShape, Value};
use nu_protocol::{Example, IntoValueStream, Signature, Span, SyntaxShape, Value};
pub struct Each;
@ -24,6 +24,32 @@ impl Command for Each {
.switch("numbered", "iterate with an index", Some('n'))
}
fn examples(&self) -> Vec<Example> {
let stream_test_1 = vec![
Value::Int {
val: 2,
span: Span::unknown(),
},
Value::Int {
val: 4,
span: Span::unknown(),
},
Value::Int {
val: 6,
span: Span::unknown(),
},
];
vec![Example {
example: "[1 2 3] | each { 2 * $it }",
description: "Multiplies elements in list",
result: Some(Value::Stream {
stream: stream_test_1.into_iter().into_value_stream(),
span: Span::unknown(),
}),
}]
}
fn run(
&self,
context: &EvaluationContext,
@ -225,3 +251,15 @@ impl Command for Each {
}
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_examples() {
use crate::test_examples;
test_examples(Each {})
}
}

58
crates/nu-command/src/formats/from/json.rs
View File

@ -1,6 +1,6 @@
use nu_protocol::ast::Call;
use nu_protocol::engine::{Command, EvaluationContext};
use nu_protocol::{IntoValueStream, ShellError, Signature, Span, Value};
use nu_protocol::{Example, IntoValueStream, ShellError, Signature, Span, Value};
pub struct FromJson;
@ -21,6 +21,50 @@ impl Command for FromJson {
)
}
fn examples(&self) -> Vec<Example> {
vec![
Example {
example: "'{ a:1 }' | from json",
description: "Converts json formatted string to table",
result: Some(Value::Record {
cols: vec!["a".to_string()],
vals: vec![Value::Int {
val: 1,
span: Span::unknown(),
}],
span: Span::unknown(),
}),
},
Example {
example: "'{ a:1, b: [1, 2] }' | from json",
description: "Converts json formatted string to table",
result: Some(Value::Record {
cols: vec!["a".to_string(), "b".to_string()],
vals: vec![
Value::Int {
val: 1,
span: Span::unknown(),
},
Value::List {
vals: vec![
Value::Int {
val: 1,
span: Span::unknown(),
},
Value::Int {
val: 2,
span: Span::unknown(),
},
],
span: Span::unknown(),
},
],
span: Span::unknown(),
}),
},
]
}
fn run(
&self,
_context: &EvaluationContext,
@ -109,3 +153,15 @@ fn convert_string_to_value(string_input: String, span: Span) -> Result<Value, Sh
)),
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_examples() {
use crate::test_examples;
test_examples(FromJson {})
}
}

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

@ -1,6 +1,7 @@
mod core_commands;
mod default_context;
mod env;
mod example_test;
mod experimental;
mod filesystem;
mod filters;
@ -9,9 +10,10 @@ mod strings;
mod system;
mod viewers;
pub use core_commands::*;
pub(crate) use core_commands::*;
pub use default_context::*;
pub use env::*;
pub use example_test::test_examples;
pub use experimental::*;
pub use filesystem::*;
pub use filters::*;

35
crates/nu-command/src/strings/build_string.rs
View File

@ -1,7 +1,7 @@
use nu_engine::eval_expression;
use nu_protocol::ast::Call;
use nu_protocol::engine::{Command, EvaluationContext};
use nu_protocol::{ShellError, Signature, SyntaxShape, Value};
use nu_protocol::{Example, ShellError, Signature, Span, SyntaxShape, Value};
pub struct BuildString;
@ -18,6 +18,27 @@ impl Command for BuildString {
Signature::build("build-string").rest("rest", SyntaxShape::String, "list of string")
}
fn examples(&self) -> Vec<Example> {
vec![
Example {
example: "build-string a b c",
description: "Builds a string from letters a b c",
result: Some(Value::String {
val: "abc".to_string(),
span: Span::unknown(),
}),
},
Example {
example: "build-string (1 + 2) = one ' ' plus ' ' two",
description: "Builds a string from letters a b c",
result: Some(Value::String {
val: "3=one plus two".to_string(),
span: Span::unknown(),
}),
},
]
}
fn run(
&self,
context: &EvaluationContext,
@ -36,3 +57,15 @@ impl Command for BuildString {
})
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_examples() {
use crate::test_examples;
test_examples(BuildString {})
}
}

80
crates/nu-command/src/strings/split/chars.rs
View File

@ -19,6 +19,38 @@ impl Command for SubCommand {
"splits a string's characters into separate rows"
}
fn examples(&self) -> Vec<Example> {
vec![Example {
description: "Split the string's characters into separate rows",
example: "'hello' | split chars",
result: Some(Value::List {
vals: vec![
Value::String {
val: "h".into(),
span: Span::unknown(),
},
Value::String {
val: "e".into(),
span: Span::unknown(),
},
Value::String {
val: "l".into(),
span: Span::unknown(),
},
Value::String {
val: "l".into(),
span: Span::unknown(),
},
Value::String {
val: "o".into(),
span: Span::unknown(),
},
],
span: Span::unknown(),
}),
}]
}
fn run(
&self,
_context: &EvaluationContext,
@ -27,35 +59,6 @@ impl Command for SubCommand {
) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
split_chars(call, input)
}
fn examples(&self) -> Vec<Example> {
vec![Example {
description: "Split the string's characters into separate rows",
example: "echo 'hello' | split chars",
result: Some(vec![
Value::String {
val: "h".into(),
span: Span::unknown(),
},
Value::String {
val: "e".into(),
span: Span::unknown(),
},
Value::String {
val: "l".into(),
span: Span::unknown(),
},
Value::String {
val: "l".into(),
span: Span::unknown(),
},
Value::String {
val: "o".into(),
span: Span::unknown(),
},
]),
}]
}
}
fn split_chars(call: &Call, input: Value) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
@ -86,15 +89,14 @@ fn split_chars_helper(v: &Value, name: Span) -> Vec<Value> {
}
}
// #[cfg(test)]
// mod tests {
// use super::ShellError;
// use super::SubCommand;
#[cfg(test)]
mod test {
use super::*;
// #[test]
// fn examples_work_as_expected() -> Result<(), ShellError> {
// use crate::examples::test as test_examples;
#[test]
fn test_examples() {
use crate::test_examples;
// test_examples(SubCommand {})
// }
// }
test_examples(SubCommand {})
}
}