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

68 lines
762 B
Rust
Raw Normal View History

mod all;
mod any;
mod append;
mod cal;
mod cd;
mod compact;
mod cp;
mod def;
mod default;
mod drop;
mod each;
mod echo;
2020-10-06 12:21:20 +02:00
mod empty;
mod enter;
mod every;
mod find;
mod first;
2020-10-14 11:36:11 +02:00
mod flatten;
mod format;
mod get;
mod group_by;
mod hash_;
mod headers;
mod help;
mod histogram;
mod into_filesize;
mod into_int;
mod keep;
mod last;
mod length;
mod lines;
mod ls;
mod math;
mod merge;
mod mkdir;
2020-07-06 17:27:01 +02:00
mod move_;
mod open;
mod parse;
mod path;
mod prepend;
mod random;
mod range;
mod reduce;
mod reject;
2020-03-03 22:01:24 +01:00
mod rename;
mod reverse;
mod rm;
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
mod roll;
90 degree table rotations (clockwise and counter-clockwise) (#3086) Also for 180 degree is expected. Rotation is not exactly like pivoting (transposing) for instance, given the following table: ``` > echo [[col1, col2, col3]; [cell1, cell2, cell3] [cell4, cell5, cell6]] ───┬───────┬───────┬─────── # │ col1 │ col2 │ col3 ───┼───────┼───────┼─────── 0 │ cell1 │ cell2 │ cell3 1 │ cell4 │ cell5 │ cell6 ───┴───────┴───────┴─────── ``` To rotate it counter clockwise by 90 degrees, we can resort to first transposing (`pivot`) them adding a new column (preferably integers), sort by that column from highest to lowest, then remove the column and we have a counter clockwise rotation. ``` > echo [[col1, col2, col3]; [cell1, cell2, cell3] [cell4, cell5, cell6]] | pivot | each --numbered { = $it.item | insert idx $it.index } | sort-by idx | reverse | reject idx ───┬─────────┬─────────┬───────── # │ Column0 │ Column1 │ Column2 ───┼─────────┼─────────┼───────── 0 │ col3 │ cell3 │ cell6 1 │ col2 │ cell2 │ cell5 2 │ col1 │ cell1 │ cell4 ───┴─────────┴─────────┴───────── ``` Which we can get easily, in this case, by doing: ``` > echo [[col1, col2, cel3]; [cell1, cell2, cell3] [cell4, cell5, cell6]] | rotate counter-clockwise ───┬─────────┬─────────┬───────── # │ Column0 │ Column1 │ Column2 ───┼─────────┼─────────┼───────── 0 │ col3 │ cell3 │ cell6 1 │ col2 │ cell2 │ cell5 2 │ col1 │ cell1 │ cell4 ───┴─────────┴─────────┴───────── ``` There are also many powerful use cases with rotation, it makes a breeze creating tables with many columns, say: ``` echo 0..12 | rotate counter-clockwise | reject Column0 ───┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬──────────┬──────────┬──────────┬────────── # │ Column1 │ Column2 │ Column3 │ Column4 │ Column5 │ Column6 │ Column7 │ Column8 │ Column9 │ Column10 │ Column11 │ Column12 │ Column13 ───┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼──────────┼──────────┼──────────┼────────── 0 │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │ 11 │ 12 ───┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴──────────┴──────────┴──────────┴────────── ```
2021-02-22 12:56:34 +01:00
mod rotate;
mod save;
mod select;
mod semicolon;
mod skip;
mod sort_by;
mod source;
mod split_by;
mod split_column;
2020-05-24 08:41:30 +02:00
mod split_row;
mod str_;
2020-02-18 21:54:32 +01:00
mod touch;
mod uniq;
mod update;
mod where_;
Obey precedence rules in which; Fix #2875 (#2885) * Obay precedence rules in which; Fix #2875 Before which did not obay the precedence of alias before def commands. Furthermore, `which -a echo` would only report either an alias or a def command or an internal command with the provided name. Not all. With this commit applied its fixed :) Example: ```shell /home/leo/repos/nushell(fix/which_reports_wrong_usage)> def echo [] {^echo hi} /home/leo/repos/nushell(fix/which_reports_wrong_usage)> echo hi /home/leo/repos/nushell(fix/which_reports_wrong_usage)> which -a echo ───┬──────┬──────────────────────────┬───────── # │ arg │ path │ builtin ───┼──────┼──────────────────────────┼───────── 0 │ echo │ Nushell custom command │ No 1 │ echo │ Nushell built-in command │ Yes 2 │ echo │ /usr/bin/echo │ No ───┴──────┴──────────────────────────┴───────── /home/leo/repos/nushell(fix/which_reports_wrong_usage)> alias echo = ^echo hi there /home/leo/repos/nushell(fix/which_reports_wrong_usage)> echo hi there /home/leo/repos/nushell(fix/which_reports_wrong_usage)> which -a echo ───┬──────┬──────────────────────────┬───────── # │ arg │ path │ builtin ───┼──────┼──────────────────────────┼───────── 0 │ echo │ Nushell alias │ No 1 │ echo │ Nushell custom command │ No 2 │ echo │ Nushell built-in command │ Yes 3 │ echo │ /usr/bin/echo │ No ───┴──────┴──────────────────────────┴───────── ``` * Fix clippy lint * Fix vec always Some even if empty
2021-01-08 18:44:31 +01:00
mod which;
2020-05-06 05:56:31 +02:00
mod with_env;
mod wrap;
mod zip;