mirror of
https://github.com/nushell/nushell
synced 2024-12-30 15:03:25 +00:00
53ae03bd63
# Description
This adds input/output types to custom commands. These are input/output
pairs that related an input type to an output type.
For example (a single int-to-int input/output pair):
```
def foo []: int -> int { ... }
```
You can also have multiple input/output pairs:
```
def bar []: [int -> string, string -> list<string>] { ... }
```
These types are checked during definition time in the parser. If the
block does not match the type, the user will get a parser error.
This `:` to begin the input/output signatures should immediately follow
the argument signature as shown above.
The PR also improves type parsing by re-using the shape parser. The
shape parser is now the canonical way to parse types/shapes in user
code.
This PR also splits `extern` into `extern`/`extern-wrapped` because of
the parser limitation that a multi-span argument (which Signature now
is) can't precede an optional argument. `extern-wrapped` now takes the
required block that was previously optional.
# User-Facing Changes
The change to `extern` to split into `extern` and `extern-wrapped` is a
breaking change.
# Tests + Formatting
<!--
Don't forget to add tests that cover your changes.
Make sure you've run and fixed any issues with these commands:
- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect -A clippy::result_large_err` to check that
you're using the standard code style
- `cargo test --workspace` to check that all tests pass
- `cargo run -- -c "use std testing; testing run-tests --path
crates/nu-std"` to run the tests for the standard library
> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->
# After Submitting
<!-- If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
-->
166 lines
4.1 KiB
Rust
166 lines
4.1 KiB
Rust
use nu_test_support::nu;
|
|
use nu_test_support::playground::Playground;
|
|
use std::fs;
|
|
|
|
#[test]
|
|
fn def_with_comment() {
|
|
Playground::setup("def_with_comment", |dirs, _| {
|
|
let data = r#"
|
|
#My echo
|
|
export def e [arg] {echo $arg}
|
|
"#;
|
|
fs::write(dirs.root().join("def_test"), data).expect("Unable to write file");
|
|
let actual = nu!(
|
|
cwd: dirs.root(),
|
|
"use def_test e; help e | to json -r"
|
|
);
|
|
|
|
assert!(actual.out.contains("My echo\\n\\n"));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn def_with_param_comment() {
|
|
Playground::setup("def_with_param_comment", |dirs, _| {
|
|
let data = r#"
|
|
export def e [
|
|
param:string #My cool attractive param
|
|
] {echo $param};
|
|
"#;
|
|
fs::write(dirs.root().join("def_test"), data).expect("Unable to write file");
|
|
let actual = nu!(
|
|
cwd: dirs.root(),
|
|
"use def_test e; help e"
|
|
);
|
|
|
|
assert!(actual.out.contains(r#"My cool attractive param"#));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn def_errors_with_no_space_between_params_and_name_1() {
|
|
let actual = nu!("def test-command[] {}");
|
|
|
|
assert!(actual.err.contains("expected space"));
|
|
}
|
|
|
|
#[test]
|
|
fn def_errors_with_no_space_between_params_and_name_2() {
|
|
let actual = nu!("def-env test-command() {}");
|
|
|
|
assert!(actual.err.contains("expected space"));
|
|
}
|
|
|
|
#[test]
|
|
fn def_errors_with_multiple_short_flags() {
|
|
let actual = nu!("def test-command [ --long(-l)(-o) ] {}");
|
|
|
|
assert!(actual.err.contains("expected only one short flag"));
|
|
}
|
|
|
|
#[test]
|
|
fn def_errors_with_comma_before_alternative_short_flag() {
|
|
let actual = nu!("def test-command [ --long, (-l) ] {}");
|
|
|
|
assert!(actual.err.contains("expected parameter"));
|
|
}
|
|
|
|
#[test]
|
|
fn def_errors_with_comma_before_equals() {
|
|
let actual = nu!("def test-command [ foo, = 1 ] {}");
|
|
|
|
assert!(actual.err.contains("expected parameter"));
|
|
}
|
|
|
|
#[test]
|
|
fn def_errors_with_comma_before_colon() {
|
|
let actual = nu!("def test-command [ foo, : int ] {}");
|
|
|
|
assert!(actual.err.contains("expected parameter"));
|
|
}
|
|
|
|
#[test]
|
|
fn def_errors_with_multiple_colons() {
|
|
let actual = nu!("def test-command [ foo::int ] {}");
|
|
assert!(actual.err.contains("expected type"));
|
|
}
|
|
|
|
#[ignore = "This error condition is not implemented yet"]
|
|
#[test]
|
|
fn def_errors_with_multiple_types() {
|
|
let actual = nu!("def test-command [ foo:int:string ] {}");
|
|
|
|
assert!(actual.err.contains("expected parameter"));
|
|
}
|
|
|
|
#[test]
|
|
fn def_errors_with_multiple_commas() {
|
|
let actual = nu!("def test-command [ foo,,bar ] {}");
|
|
|
|
assert!(actual.err.contains("expected parameter"));
|
|
}
|
|
|
|
#[test]
|
|
fn def_fails_with_invalid_name() {
|
|
let err_msg = "command name can't be a number, a filesize, or contain a hash # or caret ^";
|
|
let actual = nu!(r#"def 1234 = echo "test""#);
|
|
assert!(actual.err.contains(err_msg));
|
|
|
|
let actual = nu!(r#"def 5gib = echo "test""#);
|
|
assert!(actual.err.contains(err_msg));
|
|
|
|
let actual = nu!(r#"def ^foo [] {}"#);
|
|
assert!(actual.err.contains(err_msg));
|
|
}
|
|
|
|
#[test]
|
|
fn def_with_list() {
|
|
Playground::setup("def_with_list", |dirs, _| {
|
|
let data = r#"
|
|
def e [
|
|
param: list
|
|
] {echo $param};
|
|
"#;
|
|
fs::write(dirs.root().join("def_test"), data).expect("Unable to write file");
|
|
let actual = nu!(
|
|
cwd: dirs.root(),
|
|
"source def_test; e [one] | to json -r"
|
|
);
|
|
|
|
assert!(actual.out.contains(r#"one"#));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn def_with_default_list() {
|
|
Playground::setup("def_with_default_list", |dirs, _| {
|
|
let data = r#"
|
|
def f [
|
|
param: list = [one]
|
|
] {echo $param};
|
|
"#;
|
|
fs::write(dirs.root().join("def_test"), data).expect("Unable to write file");
|
|
let actual = nu!(
|
|
cwd: dirs.root(),
|
|
"source def_test; f | to json -r"
|
|
);
|
|
|
|
assert!(actual.out.contains(r#"["one"]"#));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn def_with_paren_params() {
|
|
let actual = nu!("def foo (x: int, y: int) { $x + $y }; foo 1 2");
|
|
|
|
assert_eq!(actual.out, "3");
|
|
}
|
|
|
|
#[test]
|
|
fn extern_with_block() {
|
|
let actual = nu!(
|
|
"extern-wrapped foo [...rest] { print ($rest | str join ',' ) }; foo --bar baz -- -q -u -x"
|
|
);
|
|
|
|
assert_eq!(actual.out, "--bar,baz,--,-q,-u,-x");
|
|
}
|