Add string/binary type color to ByteStream (#12897)

# Description

This PR allows byte streams to optionally be colored as being
specifically binary or string data, which guarantees that they'll be
converted to `Binary` or `String` appropriately on `into_value()`,
making them compatible with `Type` guarantees. This makes them
significantly more broadly usable for command input and output.

There is still an `Unknown` type for byte streams coming from external
commands, which uses the same behavior as we previously did where it's a
string if it's UTF-8.

A small number of commands were updated to take advantage of this, just
to prove the point. I will be adding more after this merges.

# User-Facing Changes
- New types in `describe`: `string (stream)`, `binary (stream)`
- These commands now return a stream if their input was a stream:
  - `into binary`
  - `into string`
  - `bytes collect`
  - `str join`
  - `first` (binary)
  - `last` (binary)
  - `take` (binary)
  - `skip` (binary)
- Streams that are explicitly binary colored will print as a streaming
hexdump
  - example:
    ```nushell
    1.. | each { into binary } | bytes collect
    ```

# Tests + Formatting
I've added some tests to cover it at a basic level, and it doesn't break
anything existing, but I do think more would be nice. Some of those will
come when I modify more commands to stream.

# After Submitting
There are a few things I'm not quite satisfied with:

- **String trimming behavior.** We automatically trim newlines from
streams from external commands, but I don't think we should do this with
internal commands. If I call a command that happens to turn my string
into a stream, I don't want the newline to suddenly disappear. I changed
this to specifically do it only on `Child` and `File`, but I don't know
if this is quite right, and maybe we should bring back the old flag for
`trim_end_newline`
- **Known binary always resulting in a hexdump.** It would be nice to
have a `print --raw`, so that we can put binary data on stdout
explicitly if we want to. This PR doesn't change how external commands
work though - they still dump straight to stdout.

Otherwise, here's the normal checklist:

- [ ] release notes
- [ ] docs update for plugin protocol changes (added `type` field)

---------

Co-authored-by: Ian Manske <ian.manske@pm.me>

crates/nu-command/tests/commands/bytes/collect.rs

@@ -0,0 +1,27 @@
+use nu_test_support::{nu, pipeline};
+
+#[test]
+fn test_stream() {
+    let actual = nu!(pipeline(
+        "
+            [0x[01] 0x[02] 0x[03] 0x[04]]
+            | filter {true}
+            | bytes collect 0x[aa aa]
+            | encode hex
+        "
+    ));
+    assert_eq!(actual.out, "01AAAA02AAAA03AAAA04");
+}
+
+#[test]
+fn test_stream_type() {
+    let actual = nu!(pipeline(
+        "
+            [0x[01] 0x[02] 0x[03] 0x[04]]
+            | filter {true}
+            | bytes collect 0x[00]
+            | describe -n
+        "
+    ));
+    assert_eq!(actual.out, "binary (stream)");
+}

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

@@ -0,0 +1 @@
+mod collect;

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

@@ -68,6 +68,20 @@ fn gets_first_byte() {
     assert_eq!(actual.out, "170");
 }
 
+#[test]
+fn gets_first_bytes_from_stream() {
+    let actual = nu!("(1.. | each { 0x[aa bb cc] } | bytes collect | first 2) == 0x[aa bb]");
+
+    assert_eq!(actual.out, "true");
+}
+
+#[test]
+fn gets_first_byte_from_stream() {
+    let actual = nu!("1.. | each { 0x[aa bb cc] } | bytes collect | first");
+
+    assert_eq!(actual.out, "170");
+}
+
 #[test]
 // covers a situation where `first` used to behave strangely on list<binary> input
 fn works_with_binary_list() {

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

@@ -68,6 +68,20 @@ fn gets_last_byte() {
     assert_eq!(actual.out, "204");
 }
 
+#[test]
+fn gets_last_bytes_from_stream() {
+    let actual = nu!("(1..10 | each { 0x[aa bb cc] } | bytes collect | last 2) == 0x[bb cc]");
+
+    assert_eq!(actual.out, "true");
+}
+
+#[test]
+fn gets_last_byte_from_stream() {
+    let actual = nu!("1..10 | each { 0x[aa bb cc] } | bytes collect | last");
+
+    assert_eq!(actual.out, "204");
+}
+
 #[test]
 fn last_errors_on_negative_index() {
     let actual = nu!("[1, 2, 3] | last -2");

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

@@ -4,6 +4,7 @@ mod any;
 mod append;
 mod assignment;
 mod break_;
+mod bytes;
 mod cal;
 mod cd;
 mod compact;

crates/nu-command/tests/commands/skip/skip_.rs

@@ -1,13 +1,17 @@
 use nu_test_support::nu;
 
 #[test]
-fn binary_skip_will_raise_error() {
-    let actual = nu!(
-        cwd: "tests/fixtures/formats",
-        "open sample_data.ods --raw | skip 2"
-    );
+fn skips_bytes() {
+    let actual = nu!("(0x[aa bb cc] | skip 2) == 0x[cc]");
 
-    assert!(actual.err.contains("only_supports_this_input_type"));
+    assert_eq!(actual.out, "true");
+}
+
+#[test]
+fn skips_bytes_from_stream() {
+    let actual = nu!("([0 1] | each { 0x[aa bb cc] } | bytes collect | skip 2) == 0x[cc aa bb cc]");
+
+    assert_eq!(actual.out, "true");
 }
 
 #[test]

crates/nu-command/tests/commands/str_/join.rs

@@ -22,6 +22,18 @@ fn test_2() {
     assert_eq!(actual.out, "a<sep>b<sep>c<sep>d");
 }
 
+#[test]
+fn test_stream() {
+    let actual = nu!("[a b c d] | filter {true} | str join .");
+    assert_eq!(actual.out, "a.b.c.d");
+}
+
+#[test]
+fn test_stream_type() {
+    let actual = nu!("[a b c d] | filter {true} | str join . | describe -n");
+    assert_eq!(actual.out, "string (stream)");
+}
+
 #[test]
 fn construct_a_path() {
     let actual = nu!(pipeline(

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

@@ -1,5 +1,5 @@
-mod collect;
 mod into_string;
+mod join;
 
 use nu_test_support::fs::Stub::FileWithContent;
 use nu_test_support::playground::Playground;

crates/nu-command/tests/commands/take/rows.rs

@@ -35,6 +35,20 @@ fn fails_on_string() {
     assert!(actual.err.contains("command doesn't support"));
 }
 
+#[test]
+fn takes_bytes() {
+    let actual = nu!("(0x[aa bb cc] | take 2) == 0x[aa bb]");
+
+    assert_eq!(actual.out, "true");
+}
+
+#[test]
+fn takes_bytes_from_stream() {
+    let actual = nu!("(1.. | each { 0x[aa bb cc] } | bytes collect | take 2) == 0x[aa bb]");
+
+    assert_eq!(actual.out, "true");
+}
+
 #[test]
 // covers a situation where `take` used to behave strangely on list<binary> input
 fn works_with_binary_list() {