nushell/crates/nu-command/tests/commands/roll.rs

169 lines
4.3 KiB
Rust
Raw Normal View History

Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
use nu_test_support::{nu, pipeline};
mod rows {
use super::*;
fn table() -> String {
pipeline(
r#"
echo [
[service, status];
[ruby, DOWN]
[db, DOWN]
[nud, DOWN]
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
[expected, HERE]
]"#,
)
}
#[test]
fn can_roll_down() {
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
let actual = nu!(
cwd: ".",
format!("{} | {}", table(), pipeline(r#"
roll down
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
| first
| get status
"#)));
assert_eq!(actual.out, "HERE");
}
#[test]
fn can_roll_up() {
let actual = nu!(
cwd: ".",
format!("{} | {}", table(), pipeline(r#"
roll up --by 3
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
| first
| get status
"#)));
assert_eq!(actual.out, "HERE");
}
}
mod columns {
use super::*;
fn table() -> String {
pipeline(
r#"
echo [
[commit_author, origin, stars];
[ "Andres", EC, amarillito]
[ "Darren", US, black]
[ "JT", US, black]
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
[ "Yehuda", US, black]
[ "Jason", CA, gold]
]"#,
)
}
#[test]
fn can_roll_left() {
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
let actual = nu!(
cwd: ".",
format!("{} | {}", table(), pipeline(r#"
roll left
| columns
| str join "-"
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
"#)));
assert_eq!(actual.out, "origin-stars-commit_author");
}
#[test]
fn can_roll_right() {
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
let actual = nu!(
cwd: ".",
format!("{} | {}", table(), pipeline(r#"
roll right --by 2
| columns
| str join "-"
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
"#)));
assert_eq!(actual.out, "origin-stars-commit_author");
}
Standardise the use of ShellError::UnsupportedInput and ShellError::TypeMismatch and add spans to every instance of the former (#7217) # Description * I was dismayed to discover recently that UnsupportedInput and TypeMismatch are used *extremely* inconsistently across the codebase. UnsupportedInput is sometimes used for input type-checks (as per the name!!), but *also* used for argument type-checks. TypeMismatch is also used for both. I thus devised the following standard: input type-checking *only* uses UnsupportedInput, and argument type-checking *only* uses TypeMismatch. Moreover, to differentiate them, UnsupportedInput now has *two* error arrows (spans), one pointing at the command and the other at the input origin, while TypeMismatch only has the one (because the command should always be nearby) * In order to apply that standard, a very large number of UnsupportedInput uses were changed so that the input's span could be retrieved and delivered to it. * Additionally, I noticed many places where **errors are not propagated correctly**: there are lots of `match` sites which take a Value::Error, then throw it away and replace it with a new Value::Error with less/misleading information (such as reporting the error as an "incorrect type"). I believe that the earliest errors are the most important, and should always be propagated where possible. * Also, to standardise one broad subset of UnsupportedInput error messages, who all used slightly different wordings of "expected `<type>`, got `<type>`", I created OnlySupportsThisInputType as a variant of it. * Finally, a bunch of error sites that had "repeated spans" - i.e. where an error expected two spans, but `call.head` was given for both - were fixed to use different spans. # Example BEFORE ``` 〉20b | str starts-with 'a' Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #31:1:1] 1 │ 20b | str starts-with 'a' · ┬ · ╰── Input's type is filesize. This command only works with strings. ╰──── 〉'a' | math cos Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #33:1:1] 1 │ 'a' | math cos · ─┬─ · ╰── Only numerical values are supported, input type: String ╰──── 〉0x[12] | encode utf8 Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #38:1:1] 1 │ 0x[12] | encode utf8 · ───┬── · ╰── non-string input ╰──── ``` AFTER ``` 〉20b | str starts-with 'a' Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #1:1:1] 1 │ 20b | str starts-with 'a' · ┬ ───────┬─────── · │ ╰── only string input data is supported · ╰── input type: filesize ╰──── 〉'a' | math cos Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #2:1:1] 1 │ 'a' | math cos · ─┬─ ────┬─── · │ ╰── only numeric input data is supported · ╰── input type: string ╰──── 〉0x[12] | encode utf8 Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #3:1:1] 1 │ 0x[12] | encode utf8 · ───┬── ───┬── · │ ╰── only string input data is supported · ╰── input type: binary ╰──── ``` # User-Facing Changes Various error messages suddenly make more sense (i.e. have two arrows instead of one). # 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 # 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.
2022-12-23 07:48:53 +01:00
struct ThirtyTwo<'a>(usize, &'a str);
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
#[test]
fn can_roll_the_cells_only_keeping_the_header_names() {
let four_bitstring = bitstring_to_nu_row_pipeline("00000100");
Standardise the use of ShellError::UnsupportedInput and ShellError::TypeMismatch and add spans to every instance of the former (#7217) # Description * I was dismayed to discover recently that UnsupportedInput and TypeMismatch are used *extremely* inconsistently across the codebase. UnsupportedInput is sometimes used for input type-checks (as per the name!!), but *also* used for argument type-checks. TypeMismatch is also used for both. I thus devised the following standard: input type-checking *only* uses UnsupportedInput, and argument type-checking *only* uses TypeMismatch. Moreover, to differentiate them, UnsupportedInput now has *two* error arrows (spans), one pointing at the command and the other at the input origin, while TypeMismatch only has the one (because the command should always be nearby) * In order to apply that standard, a very large number of UnsupportedInput uses were changed so that the input's span could be retrieved and delivered to it. * Additionally, I noticed many places where **errors are not propagated correctly**: there are lots of `match` sites which take a Value::Error, then throw it away and replace it with a new Value::Error with less/misleading information (such as reporting the error as an "incorrect type"). I believe that the earliest errors are the most important, and should always be propagated where possible. * Also, to standardise one broad subset of UnsupportedInput error messages, who all used slightly different wordings of "expected `<type>`, got `<type>`", I created OnlySupportsThisInputType as a variant of it. * Finally, a bunch of error sites that had "repeated spans" - i.e. where an error expected two spans, but `call.head` was given for both - were fixed to use different spans. # Example BEFORE ``` 〉20b | str starts-with 'a' Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #31:1:1] 1 │ 20b | str starts-with 'a' · ┬ · ╰── Input's type is filesize. This command only works with strings. ╰──── 〉'a' | math cos Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #33:1:1] 1 │ 'a' | math cos · ─┬─ · ╰── Only numerical values are supported, input type: String ╰──── 〉0x[12] | encode utf8 Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #38:1:1] 1 │ 0x[12] | encode utf8 · ───┬── · ╰── non-string input ╰──── ``` AFTER ``` 〉20b | str starts-with 'a' Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #1:1:1] 1 │ 20b | str starts-with 'a' · ┬ ───────┬─────── · │ ╰── only string input data is supported · ╰── input type: filesize ╰──── 〉'a' | math cos Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #2:1:1] 1 │ 'a' | math cos · ─┬─ ────┬─── · │ ╰── only numeric input data is supported · ╰── input type: string ╰──── 〉0x[12] | encode utf8 Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #3:1:1] 1 │ 0x[12] | encode utf8 · ───┬── ───┬── · │ ╰── only string input data is supported · ╰── input type: binary ╰──── ``` # User-Facing Changes Various error messages suddenly make more sense (i.e. have two arrows instead of one). # 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 # 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.
2022-12-23 07:48:53 +01:00
let expected_value = ThirtyTwo(32, "bit1-bit2-bit3-bit4-bit5-bit6-bit7-bit8");
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
let actual = nu!(
cwd: ".",
format!("{four_bitstring} | roll right --by 3 --cells-only | columns | str join '-' ")
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
);
assert_eq!(actual.out, expected_value.1);
}
#[test]
fn four_in_bitstring_left_shifted_with_three_bits_should_be_32_in_decimal() {
let four_bitstring = "00000100";
Standardise the use of ShellError::UnsupportedInput and ShellError::TypeMismatch and add spans to every instance of the former (#7217) # Description * I was dismayed to discover recently that UnsupportedInput and TypeMismatch are used *extremely* inconsistently across the codebase. UnsupportedInput is sometimes used for input type-checks (as per the name!!), but *also* used for argument type-checks. TypeMismatch is also used for both. I thus devised the following standard: input type-checking *only* uses UnsupportedInput, and argument type-checking *only* uses TypeMismatch. Moreover, to differentiate them, UnsupportedInput now has *two* error arrows (spans), one pointing at the command and the other at the input origin, while TypeMismatch only has the one (because the command should always be nearby) * In order to apply that standard, a very large number of UnsupportedInput uses were changed so that the input's span could be retrieved and delivered to it. * Additionally, I noticed many places where **errors are not propagated correctly**: there are lots of `match` sites which take a Value::Error, then throw it away and replace it with a new Value::Error with less/misleading information (such as reporting the error as an "incorrect type"). I believe that the earliest errors are the most important, and should always be propagated where possible. * Also, to standardise one broad subset of UnsupportedInput error messages, who all used slightly different wordings of "expected `<type>`, got `<type>`", I created OnlySupportsThisInputType as a variant of it. * Finally, a bunch of error sites that had "repeated spans" - i.e. where an error expected two spans, but `call.head` was given for both - were fixed to use different spans. # Example BEFORE ``` 〉20b | str starts-with 'a' Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #31:1:1] 1 │ 20b | str starts-with 'a' · ┬ · ╰── Input's type is filesize. This command only works with strings. ╰──── 〉'a' | math cos Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #33:1:1] 1 │ 'a' | math cos · ─┬─ · ╰── Only numerical values are supported, input type: String ╰──── 〉0x[12] | encode utf8 Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #38:1:1] 1 │ 0x[12] | encode utf8 · ───┬── · ╰── non-string input ╰──── ``` AFTER ``` 〉20b | str starts-with 'a' Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #1:1:1] 1 │ 20b | str starts-with 'a' · ┬ ───────┬─────── · │ ╰── only string input data is supported · ╰── input type: filesize ╰──── 〉'a' | math cos Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #2:1:1] 1 │ 'a' | math cos · ─┬─ ────┬─── · │ ╰── only numeric input data is supported · ╰── input type: string ╰──── 〉0x[12] | encode utf8 Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #3:1:1] 1 │ 0x[12] | encode utf8 · ───┬── ───┬── · │ ╰── only string input data is supported · ╰── input type: binary ╰──── ``` # User-Facing Changes Various error messages suddenly make more sense (i.e. have two arrows instead of one). # 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 # 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.
2022-12-23 07:48:53 +01:00
let expected_value = ThirtyTwo(32, "00100000");
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
assert_eq!(
shift_three_bits_to_the_left_to_bitstring(four_bitstring),
expected_value.0.to_string()
);
}
fn shift_three_bits_to_the_left_to_bitstring(bits: &str) -> String {
// this pipeline takes the bitstring and outputs a nu row literal
// for example the number 4 in bitstring:
//
// input: 00000100
//
// output:
// [
// [column1, column2, column3, column4, column5, column6, column7, column8];
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
// [ 0, 0, 0, 0, 0, 1, 0, 0]
// ]
//
let bitstring_as_nu_row_pipeline = bitstring_to_nu_row_pipeline(bits);
// this pipeline takes the nu bitstring row literal, computes it's
// decimal value.
let nu_row_literal_bitstring_to_decimal_value_pipeline = pipeline(
r#"
transpose bit --ignore-titles
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
| get bit
| reverse
| enumerate
| each { |it|
$it.item * (2 ** $it.index)
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
}
| math sum
"#,
);
Standardise the use of ShellError::UnsupportedInput and ShellError::TypeMismatch and add spans to every instance of the former (#7217) # Description * I was dismayed to discover recently that UnsupportedInput and TypeMismatch are used *extremely* inconsistently across the codebase. UnsupportedInput is sometimes used for input type-checks (as per the name!!), but *also* used for argument type-checks. TypeMismatch is also used for both. I thus devised the following standard: input type-checking *only* uses UnsupportedInput, and argument type-checking *only* uses TypeMismatch. Moreover, to differentiate them, UnsupportedInput now has *two* error arrows (spans), one pointing at the command and the other at the input origin, while TypeMismatch only has the one (because the command should always be nearby) * In order to apply that standard, a very large number of UnsupportedInput uses were changed so that the input's span could be retrieved and delivered to it. * Additionally, I noticed many places where **errors are not propagated correctly**: there are lots of `match` sites which take a Value::Error, then throw it away and replace it with a new Value::Error with less/misleading information (such as reporting the error as an "incorrect type"). I believe that the earliest errors are the most important, and should always be propagated where possible. * Also, to standardise one broad subset of UnsupportedInput error messages, who all used slightly different wordings of "expected `<type>`, got `<type>`", I created OnlySupportsThisInputType as a variant of it. * Finally, a bunch of error sites that had "repeated spans" - i.e. where an error expected two spans, but `call.head` was given for both - were fixed to use different spans. # Example BEFORE ``` 〉20b | str starts-with 'a' Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #31:1:1] 1 │ 20b | str starts-with 'a' · ┬ · ╰── Input's type is filesize. This command only works with strings. ╰──── 〉'a' | math cos Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #33:1:1] 1 │ 'a' | math cos · ─┬─ · ╰── Only numerical values are supported, input type: String ╰──── 〉0x[12] | encode utf8 Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #38:1:1] 1 │ 0x[12] | encode utf8 · ───┬── · ╰── non-string input ╰──── ``` AFTER ``` 〉20b | str starts-with 'a' Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #1:1:1] 1 │ 20b | str starts-with 'a' · ┬ ───────┬─────── · │ ╰── only string input data is supported · ╰── input type: filesize ╰──── 〉'a' | math cos Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #2:1:1] 1 │ 'a' | math cos · ─┬─ ────┬─── · │ ╰── only numeric input data is supported · ╰── input type: string ╰──── 〉0x[12] | encode utf8 Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #3:1:1] 1 │ 0x[12] | encode utf8 · ───┬── ───┬── · │ ╰── only string input data is supported · ╰── input type: binary ╰──── ``` # User-Facing Changes Various error messages suddenly make more sense (i.e. have two arrows instead of one). # 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 # 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.
2022-12-23 07:48:53 +01:00
println!(
"{bitstring_as_nu_row_pipeline} | roll left --by 3 | {nu_row_literal_bitstring_to_decimal_value_pipeline}"
Standardise the use of ShellError::UnsupportedInput and ShellError::TypeMismatch and add spans to every instance of the former (#7217) # Description * I was dismayed to discover recently that UnsupportedInput and TypeMismatch are used *extremely* inconsistently across the codebase. UnsupportedInput is sometimes used for input type-checks (as per the name!!), but *also* used for argument type-checks. TypeMismatch is also used for both. I thus devised the following standard: input type-checking *only* uses UnsupportedInput, and argument type-checking *only* uses TypeMismatch. Moreover, to differentiate them, UnsupportedInput now has *two* error arrows (spans), one pointing at the command and the other at the input origin, while TypeMismatch only has the one (because the command should always be nearby) * In order to apply that standard, a very large number of UnsupportedInput uses were changed so that the input's span could be retrieved and delivered to it. * Additionally, I noticed many places where **errors are not propagated correctly**: there are lots of `match` sites which take a Value::Error, then throw it away and replace it with a new Value::Error with less/misleading information (such as reporting the error as an "incorrect type"). I believe that the earliest errors are the most important, and should always be propagated where possible. * Also, to standardise one broad subset of UnsupportedInput error messages, who all used slightly different wordings of "expected `<type>`, got `<type>`", I created OnlySupportsThisInputType as a variant of it. * Finally, a bunch of error sites that had "repeated spans" - i.e. where an error expected two spans, but `call.head` was given for both - were fixed to use different spans. # Example BEFORE ``` 〉20b | str starts-with 'a' Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #31:1:1] 1 │ 20b | str starts-with 'a' · ┬ · ╰── Input's type is filesize. This command only works with strings. ╰──── 〉'a' | math cos Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #33:1:1] 1 │ 'a' | math cos · ─┬─ · ╰── Only numerical values are supported, input type: String ╰──── 〉0x[12] | encode utf8 Error: nu::shell::unsupported_input (link) × Unsupported input ╭─[entry #38:1:1] 1 │ 0x[12] | encode utf8 · ───┬── · ╰── non-string input ╰──── ``` AFTER ``` 〉20b | str starts-with 'a' Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #1:1:1] 1 │ 20b | str starts-with 'a' · ┬ ───────┬─────── · │ ╰── only string input data is supported · ╰── input type: filesize ╰──── 〉'a' | math cos Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #2:1:1] 1 │ 'a' | math cos · ─┬─ ────┬─── · │ ╰── only numeric input data is supported · ╰── input type: string ╰──── 〉0x[12] | encode utf8 Error: nu::shell::pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #3:1:1] 1 │ 0x[12] | encode utf8 · ───┬── ───┬── · │ ╰── only string input data is supported · ╰── input type: binary ╰──── ``` # User-Facing Changes Various error messages suddenly make more sense (i.e. have two arrows instead of one). # 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 # 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.
2022-12-23 07:48:53 +01:00
);
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
nu!(
cwd: ".",
format!("{bitstring_as_nu_row_pipeline} | roll left --by 3 | {nu_row_literal_bitstring_to_decimal_value_pipeline}")
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
).out
}
fn bitstring_to_nu_row_pipeline(bits: &str) -> String {
format!(
"echo '{}' | {}",
bits,
pipeline(
r#"
split chars
| each { |it| $it | into int }
| rotate --ccw
Table content rolling. (#3097) There are many use cases. Here we introduce the following: - The rows can be rolled `... | roll` (up) or `... | roll down` - Columns can be rolled too (the default is on the `left`, you can pass `... | roll column --opposite` to roll in the other direction) - You can `roll` the cells of a table and keeping the header names in the same order (`... | roll column --cells-only`) - Above examples can also be passed (Ex. `... | roll down 3`) a number to tell how many places to roll. Basic working example with rolling columns: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` We want to "shift" three bits to the left of the bitstring (four in decimal), let's try it: ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 │ bit1 │ bit2 │ bit3 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` The tables was rolled correctly (32 in decimal, for above bitstring). However, the *last three header names* look confusing. We can roll the cell contents only to fix it. ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8 | roll column 3 --cells-only ───┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬────── # │ bit1 │ bit2 │ bit3 │ bit4 │ bit5 │ bit6 │ bit7 │ bit8 ───┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼────── 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 ───┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴────── ``` There we go. Let's compute it's decimal value now (should be 32) ``` > echo '00000100' | split chars | each { str to-int } | rotate counter-clockwise _ | reject _ | roll column 3 --cells-only | pivot bit --ignore-titles | get bit | reverse | each --numbered { = $it.item * (2 ** $it.index) } | math sum 32 ```
2021-02-23 19:29:07 +01:00
| rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8
"#
)
)
}
}