mirror of
https://github.com/nushell/nushell
synced 2024-12-28 14:03:09 +00:00
1552eb921a
# Description
This adds a new cell path literal syntax for use in any value position,
not just in a context where we expect a cell path.
This can be used to assign to a variable and then later use that
variable as a cell path.
Example:
```
> let cell_path = $.a.b
> {a: {b: 3}} | get $cell_path
3
```
# User-Facing Changes
This adds the syntax `$.a.b` to universally mean the cell path `a.b`,
even in a context that doesn't expect a cell path.
# 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` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass
> **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.
140 lines
3.5 KiB
Rust
140 lines
3.5 KiB
Rust
use crate::tests::{fail_test, run_test, TestResult};
|
|
|
|
// Tests for $nothing / null / Value::Nothing
|
|
#[test]
|
|
fn nothing_fails_string() -> TestResult {
|
|
fail_test("$nothing.foo", "doesn't support cell paths")
|
|
}
|
|
|
|
#[test]
|
|
fn nothing_fails_int() -> TestResult {
|
|
fail_test("$nothing.3", "doesn't support cell paths")
|
|
}
|
|
|
|
// Tests for records
|
|
#[test]
|
|
fn record_single_field_success() -> TestResult {
|
|
run_test("{foo: 'bar'}.foo == 'bar'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn record_single_field_optional_success() -> TestResult {
|
|
run_test("{foo: 'bar'}.foo? == 'bar'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn get_works_with_cell_path_success() -> TestResult {
|
|
run_test("{foo: 'bar'} | get foo?", "bar")
|
|
}
|
|
|
|
#[test]
|
|
fn get_works_with_cell_path_missing_data() -> TestResult {
|
|
run_test("{foo: 'bar'} | get foobar? | to nuon", "null")
|
|
}
|
|
|
|
#[test]
|
|
fn record_single_field_failure() -> TestResult {
|
|
fail_test("{foo: 'bar'}.foobar", "")
|
|
}
|
|
|
|
#[test]
|
|
fn record_int_failure() -> TestResult {
|
|
fail_test("{foo: 'bar'}.3", "")
|
|
}
|
|
|
|
#[test]
|
|
fn record_single_field_optional() -> TestResult {
|
|
run_test("{foo: 'bar'}.foobar? | to nuon", "null")
|
|
}
|
|
|
|
#[test]
|
|
fn record_single_field_optional_does_not_short_circuit() -> TestResult {
|
|
fail_test("{foo: 'bar'}.foobar?.baz", "nothing")
|
|
}
|
|
|
|
#[test]
|
|
fn record_multiple_optional_fields() -> TestResult {
|
|
run_test("{foo: 'bar'}.foobar?.baz? | to nuon", "null")
|
|
}
|
|
|
|
#[test]
|
|
fn nested_record_field_success() -> TestResult {
|
|
run_test("{foo: {bar: 'baz'} }.foo.bar == 'baz'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn nested_record_field_failure() -> TestResult {
|
|
fail_test("{foo: {bar: 'baz'} }.foo.asdf", "")
|
|
}
|
|
|
|
#[test]
|
|
fn nested_record_field_optional() -> TestResult {
|
|
run_test("{foo: {bar: 'baz'} }.foo.asdf? | to nuon", "null")
|
|
}
|
|
|
|
#[test]
|
|
fn record_with_nested_list_success() -> TestResult {
|
|
run_test("{foo: [{bar: 'baz'}]}.foo.0.bar == 'baz'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn record_with_nested_list_int_failure() -> TestResult {
|
|
fail_test("{foo: [{bar: 'baz'}]}.foo.3.bar", "")
|
|
}
|
|
|
|
#[test]
|
|
fn record_with_nested_list_column_failure() -> TestResult {
|
|
fail_test("{foo: [{bar: 'baz'}]}.foo.0.asdf", "")
|
|
}
|
|
|
|
// Tests for lists
|
|
#[test]
|
|
fn list_single_field_success() -> TestResult {
|
|
run_test("[{foo: 'bar'}].foo.0 == 'bar'", "true")?;
|
|
// test field access both ways
|
|
run_test("[{foo: 'bar'}].0.foo == 'bar'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn list_single_field_failure() -> TestResult {
|
|
fail_test("[{foo: 'bar'}].asdf", "")
|
|
}
|
|
|
|
// Test the scenario where the requested column is not present in all rows
|
|
#[test]
|
|
fn jagged_list_access_fails() -> TestResult {
|
|
fail_test("[{foo: 'bar'}, {}].foo", "cannot find column")?;
|
|
fail_test("[{}, {foo: 'bar'}].foo", "cannot find column")
|
|
}
|
|
|
|
#[test]
|
|
fn jagged_list_optional_access_succeeds() -> TestResult {
|
|
run_test("[{foo: 'bar'}, {}].foo?.0", "bar")?;
|
|
run_test("[{foo: 'bar'}, {}].foo?.1 | to nuon", "null")?;
|
|
|
|
run_test("[{}, {foo: 'bar'}].foo?.0 | to nuon", "null")?;
|
|
run_test("[{}, {foo: 'bar'}].foo?.1", "bar")
|
|
}
|
|
|
|
// test that accessing a nonexistent row fails
|
|
#[test]
|
|
fn list_row_access_failure() -> TestResult {
|
|
fail_test("[{foo: 'bar'}, {foo: 'baz'}].2", "")
|
|
}
|
|
|
|
#[test]
|
|
fn list_row_optional_access_succeeds() -> TestResult {
|
|
run_test("[{foo: 'bar'}, {foo: 'baz'}].2? | to nuon", "null")?;
|
|
run_test("[{foo: 'bar'}, {foo: 'baz'}].3? | to nuon", "null")
|
|
}
|
|
|
|
// regression test for an old bug
|
|
#[test]
|
|
fn do_not_delve_too_deep_in_nested_lists() -> TestResult {
|
|
fail_test("[[{foo: bar}]].foo", "cannot find column")
|
|
}
|
|
|
|
#[test]
|
|
fn cell_path_literals() -> TestResult {
|
|
run_test("let cell_path = $.a.b; {a: {b: 3}} | get $cell_path", "3")
|
|
}
|