update reedline to the latest commit (nushell#16791)

This PR updates nushell to the latest reedline commit 32e82c27.

Notes from @JonLD regarding reedline's new `TextObject`, reedline change
author of nushell/reedline#939 and
nushell/reedline#957 and nushell#16808

Since EditCommand contains a TextObject and not a string it is not
possible for the user to directly there needs to be a bit of work done
to construct the relevant text object. Maintains the edit command names,
seen under "keybindings list", of CutTextObject and CopyTextObject and
using scope: <inner|around> and the object_type: mirrors the Reedline
implementation and the informative error messages should help signal to
users what are valid inputs. Ideally the "keybindings list" would be a
bit mor informative as to how to set up specific keybindings but that's
not currently possible, and perhaps not even necessary.
The alternative would be to set up edit commands for each text object,
this would be a larger Reedline change and add unecessary complexity to
Reedline but would expose the commands better to the use. You could just
add them in this file and keep Reedline as is but that would not be
exposed to the user via "keybindings list" as this command lists the
actual enums and not commands set up in the reedline_config.rs.

## Release notes summary - What our users need to know
Breaking change since the reedline change renames `cutinside` and
`yankinside`. The PR adds these new EditCommands:
- cutinsidepair
- copyinsidepair
- cutaroundpair
- copyaroundpair
- cuttextobject
- copytextobject

## Tasks after submitting
N/A

Author: fdncred

Cargo.lock

@@ -13,8 +13,9 @@ use nu_protocol::{
 };
 use reedline::{
     ColumnarMenu, DescriptionMenu, DescriptionMode, EditCommand, IdeMenu, Keybindings, ListMenu,
-    MenuBuilder, Reedline, ReedlineEvent, ReedlineMenu, TraversalDirection,
-    default_emacs_keybindings, default_vi_insert_keybindings, default_vi_normal_keybindings,
+    MenuBuilder, Reedline, ReedlineEvent, ReedlineMenu, TextObject, TextObjectScope,
+    TextObjectType, TraversalDirection, default_emacs_keybindings, default_vi_insert_keybindings,
+    default_vi_normal_keybindings,
 };
 use std::sync::Arc;
 
@@ -1307,20 +1308,40 @@ fn edit_from_record(
         "copyselectionsystem" => EditCommand::CopySelectionSystem,
         #[cfg(feature = "system-clipboard")]
         "pastesystem" => EditCommand::PasteSystem,
-        "cutinside" => {
+        "cutinsidepair" => {
             let value = extract_value("left", record, span)?;
             let left = extract_char(value)?;
             let value = extract_value("right", record, span)?;
             let right = extract_char(value)?;
-            EditCommand::CutInside { left, right }
+            EditCommand::CutInsidePair { left, right }
         }
-        "yankinside" => {
+        "copyinsidepair" => {
             let value = extract_value("left", record, span)?;
             let left = extract_char(value)?;
             let value = extract_value("right", record, span)?;
             let right = extract_char(value)?;
-            EditCommand::YankInside { left, right }
+            EditCommand::CopyInsidePair { left, right }
         }
+        "cutaroundpair" => {
+            let value = extract_value("left", record, span)?;
+            let left = extract_char(value)?;
+            let value = extract_value("right", record, span)?;
+            let right = extract_char(value)?;
+            EditCommand::CutAroundPair { left, right }
+        }
+        "copyaroundpair" => {
+            let value = extract_value("left", record, span)?;
+            let left = extract_char(value)?;
+            let value = extract_value("right", record, span)?;
+            let right = extract_char(value)?;
+            EditCommand::CopyAroundPair { left, right }
+        }
+        "copytextobject" => EditCommand::CopyTextObject {
+            text_object: parse_text_object(record, config, span)?,
+        },
+        "cuttextobject" => EditCommand::CutTextObject {
+            text_object: parse_text_object(record, config, span)?,
+        },
         str => {
             return Err(ShellError::InvalidValue {
                 valid: "a reedline EditCommand".into(),
@@ -1353,6 +1374,48 @@ fn extract_char(value: &Value) -> Result<char, ShellError> {
     }
 }
 
+fn parse_text_object(
+    record: &Record,
+    config: &Config,
+    span: Span,
+) -> Result<TextObject, ShellError> {
+    let scope_value = extract_value("scope", record, span)?;
+    let scope_str = scope_value
+        .to_expanded_string("", config)
+        .to_ascii_lowercase();
+    let scope = match scope_str.as_str() {
+        "inner" => TextObjectScope::Inner,
+        "around" => TextObjectScope::Around,
+        str => {
+            return Err(ShellError::InvalidValue {
+                valid: "'inner' or 'around'".into(),
+                actual: format!("'{str}'"),
+                span: scope_value.span(),
+            });
+        }
+    };
+
+    let type_value = extract_value("object_type", record, span)?;
+    let type_str = type_value
+        .to_expanded_string("", config)
+        .to_ascii_lowercase();
+    let object_type = match type_str.as_str() {
+        "word" => TextObjectType::Word,
+        "bigword" => TextObjectType::BigWord,
+        "brackets" | "bracket" => TextObjectType::Brackets,
+        "quote" | "quotes" => TextObjectType::Quote,
+        str => {
+            return Err(ShellError::InvalidValue {
+                valid: "'word', 'bigword', 'brackets', or 'quote'".into(),
+                actual: format!("'{str}'"),
+                span: type_value.span(),
+            });
+        }
+    };
+
+    Ok(TextObject { scope, object_type })
+}
+
 #[cfg(test)]
 mod test {
     use super::*;