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
```

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

@@ -0,0 +1,166 @@
+use nu_test_support::{nu, pipeline};
+
+mod rows {
+    use super::*;
+
+    fn table() -> String {
+        pipeline(
+            r#"
+            echo [
+                [service, status];
+            
+                [ruby,      DOWN] 
+                [db,        DOWN] 
+                [nud,       DOWN] 
+                [expected,  HERE]
+            ]"#,
+        )
+    }
+
+    #[test]
+    fn roll_down_by_default() {
+        let actual = nu!(
+        cwd: ".",
+        format!("{} | {}", table(), pipeline(r#"
+            roll
+            | first
+            | get status
+        "#)));
+
+        assert_eq!(actual.out, "HERE");
+    }
+
+    #[test]
+    fn can_roll_up() {
+        let actual = nu!(
+        cwd: ".",
+        format!("{} | {}", table(), pipeline(r#"
+            roll up 3
+            | 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] 
+                [   "Jonathan",     US,      black] 
+                [     "Yehuda",     US,      black]
+                [      "Jason",     CA,       gold]
+            ]"#,
+        )
+    }
+
+    #[test]
+    fn roll_left_by_default() {
+        let actual = nu!(
+        cwd: ".",
+        format!("{} | {}", table(), pipeline(r#"
+            roll column
+            | get
+            | str collect "-"
+        "#)));
+
+        assert_eq!(actual.out, "origin-stars-commit_author");
+    }
+
+    #[test]
+    fn can_roll_in_the_opposite_direction() {
+        let actual = nu!(
+        cwd: ".",
+        format!("{} | {}", table(), pipeline(r#"
+            roll column 2 --opposite
+            | get
+            | str collect "-"
+        "#)));
+
+        assert_eq!(actual.out, "origin-stars-commit_author");
+    }
+
+    struct ThirtieTwo<'a>(usize, &'a str);
+
+    #[test]
+    fn can_roll_the_cells_only_keeping_the_header_names() {
+        let four_bitstring = bitstring_to_nu_row_pipeline("00000100");
+        let expected_value = ThirtieTwo(32, "bit1-bit2-bit3-bit4-bit5-bit6-bit7-bit8");
+
+        let actual = nu!(
+            cwd: ".",
+            format!("{} | roll column 3 --opposite --cells-only | get | str collect '-' ", four_bitstring)
+        );
+
+        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";
+        let expected_value = ThirtieTwo(32, "00100000");
+
+        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];
+        //   [      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#"
+            pivot bit --ignore-titles
+            | get bit
+            | reverse
+            | each --numbered {
+                = $it.item * (2 ** $it.index)
+            }
+            | math sum
+        "#,
+        );
+
+        nu!(
+            cwd: ".",
+            format!("{} | roll column 3 | {}", bitstring_as_nu_row_pipeline, nu_row_literal_bitstring_to_decimal_value_pipeline)
+        ).out
+    }
+
+    fn bitstring_to_nu_row_pipeline(bits: &str) -> String {
+        format!(
+            "echo '{}' | {}",
+            bits,
+            pipeline(
+                r#"
+            split chars
+            | each { str to-int }
+            | rotate counter-clockwise _
+            | reject _
+            | rename bit1 bit2 bit3 bit4 bit5 bit6 bit7 bit8
+        "#
+            )
+        )
+    }
+}