Make parse simple patterns ignore fields with placeholder (_) (#15873)

# Description
Simple `parse` patterns let you quickly put together simple parsers, but
sometimes you aren't actually interested in some of the output (such as
variable whitespace). This PR lets you use `{_}` to discard part of the
input.

Example:
```nushell
"hello world" | parse "{foo} {_}"
# => ╭───┬───────╮
# => │ # │  foo  │
# => ├───┼───────┤
# => │ 0 │ hello │
# => ╰───┴───────╯
```

here's a simple parser for the `apropops` using the `_` placeholder to
discard the variable whitespace, without needing to resort to a full
regex pattern:

```nushell
apropos linux | parse "{name} ({section}) {_}- {topic}"
# => ╭───┬───────────────────────────────────────┬─────────┬─────────────────────────────────────────────────────────────────────╮
# => │ # │                 name                  │ section │                                topic                                │
# => ├───┼───────────────────────────────────────┼─────────┼─────────────────────────────────────────────────────────────────────┤
# => │ 0 │ PAM                                   │ 8       │ Pluggable Authentication Modules for Linux                          │
# => │ 1 │ aarch64-linux-gnu-addr2line           │ 1       │ convert addresses or symbol+offset into file names and line numbers │
# => │ 2 │ ...                                   │ ...     │ ...                                                                 │
# => │ 3 │ xcb_selinux_set_window_create_context │ 3       │ (unknown subject)                                                   │
# => │ 4 │ xorriso-dd-target                     │ 1       │ Device evaluator and disk image copier for GNU/Linux                │
# => ╰───┴───────────────────────────────────────┴─────────┴─────────────────────────────────────────────────────────────────────╯
```

# User-Facing Changes
* `parse` simple patterns can now discard input using `{_}`

# Tests + Formatting
N/A

# After Submitting
N/A

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

@@ -7,7 +7,7 @@ mod simple {
 
     #[test]
     fn extracts_fields_from_the_given_the_pattern() {
-        Playground::setup("parse_test_1", |dirs, sandbox| {
+        Playground::setup("parse_test_simple_1", |dirs, sandbox| {
             sandbox.with_files(&[Stub::FileWithContentToBeTrimmed(
                 "key_value_separated_arepa_ingredients.txt",
                 r#"
@@ -35,71 +35,74 @@ mod simple {
 
     #[test]
     fn double_open_curly_evaluates_to_a_single_curly() {
-        Playground::setup("parse_test_regex_2", |dirs, _sandbox| {
-            let actual = nu!(
-                cwd: dirs.test(), pipeline(
-                r#"
-                    echo "{abc}123"
-                    | parse "{{abc}{name}"
-                    | get name.0
-                "#
-            ));
-
-            assert_eq!(actual.out, "123");
-        })
+        let actual = nu!(pipeline(
+            r#"
+                echo "{abc}123"
+                | parse "{{abc}{name}"
+                | get name.0
+            "#
+        ));
+        assert_eq!(actual.out, "123");
     }
 
     #[test]
     fn properly_escapes_text() {
-        Playground::setup("parse_test_regex_3", |dirs, _sandbox| {
-            let actual = nu!(
-                cwd: dirs.test(), pipeline(
-                r#"
-                    echo "(abc)123"
-                    | parse "(abc){name}"
-                    | get name.0
-                "#
-            ));
+        let actual = nu!(pipeline(
+            r#"
+                echo "(abc)123"
+                | parse "(abc){name}"
+                | get name.0
+            "#
+        ));
 
-            assert_eq!(actual.out, "123");
-        })
+        assert_eq!(actual.out, "123");
     }
 
     #[test]
     fn properly_captures_empty_column() {
-        Playground::setup("parse_test_regex_4", |dirs, _sandbox| {
-            let actual = nu!(
-                cwd: dirs.test(), pipeline(
-                r#"
-                    echo ["1:INFO:component:all is well" "2:ERROR::something bad happened"]
-                    | parse "{timestamp}:{level}:{tag}:{entry}"
-                    | get entry
-                    | get 1
-                "#
-            ));
+        let actual = nu!(pipeline(
+            r#"
+                echo ["1:INFO:component:all is well" "2:ERROR::something bad happened"]
+                | parse "{timestamp}:{level}:{tag}:{entry}"
+                | get entry
+                | get 1
+            "#
+        ));
 
-            assert_eq!(actual.out, "something bad happened");
-        })
+        assert_eq!(actual.out, "something bad happened");
     }
 
     #[test]
     fn errors_when_missing_closing_brace() {
-        Playground::setup("parse_test_regex_5", |dirs, _sandbox| {
-            let actual = nu!(
-                cwd: dirs.test(), pipeline(
-                r#"
-                    echo "(abc)123"
-                    | parse "(abc){name"
-                    | get name
-                "#
-            ));
+        let actual = nu!(pipeline(
+            r#"
+                echo "(abc)123"
+                | parse "(abc){name"
+                | get name
+            "#
+        ));
 
-            assert!(
-                actual
-                    .err
-                    .contains("Found opening `{` without an associated closing `}`")
-            );
-        })
+        assert!(
+            actual
+                .err
+                .contains("Found opening `{` without an associated closing `}`")
+        );
+    }
+
+    #[test]
+    fn ignore_multiple_placeholder() {
+        let actual = nu!(pipeline(
+            r#"
+                echo ["1:INFO:component:all is well" "2:ERROR::something bad happened"]
+                | parse "{_}:{level}:{_}:{entry}"
+                | to json -r
+            "#
+        ));
+
+        assert_eq!(
+            actual.out,
+            r#"[{"level":"INFO","entry":"all is well"},{"level":"ERROR","entry":"something bad happened"}]"#
+        );
     }
 }