Seq char update will work on all char (#14261)

# Description - fixes #14174

This PR addresses a bug in the `seq char` command where the command's
behavior did not align with its help description, which stated that it
prints a sequence of ASCII characters. The initial implementation only
allowed alphabetic characters, leading to user confusion when
non-alphabetic characters (e.g., digits, punctuation) were rejected or
when unexpected behavior occurred for certain input ranges.

### Changes Made:
- **Updated the input validation**: Modified the `is_single_character`
function to accept any ASCII character instead of restricting to
alphabetic characters.
- **Enhanced error messages**: Clarified error messages to specify that
any single ASCII character is acceptable.
- **Expanded functionality**: Ensured that the command can now generate
sequences that include non-alphabetic ASCII characters.
- **Updated tests**: Added tests to cover new use cases involving
non-alphabetic characters and improved validation.

### Examples After Fix:
- `seq char '0' '9'` now outputs `['0', '1', '2', '3', '4', '5', '6',
'7', '8', '9']`
- `seq char ' ' '/'` outputs a list of characters from space to `/`
- `seq char 'A' 'z'` correctly includes alphabetic and non-alphabetic
characters between `A` and `z`

# User-Facing Changes
- Users can now input any single ASCII character for the `start` and
`end` parameters of `seq char`.
- The output will accurately include all characters within the specified
ASCII range, including digits and punctuation.

# Tests + Formatting
- Added new tests to ensure the `seq char` command supports sequences
including non-alphabetic ASCII characters.

crates/nu-command/src/generators/seq_char.rs

@@ -45,9 +45,10 @@ impl Command for SeqChar {
                 )),
             },
             Example {
-                description: "sequence a to e, and put the characters in a pipe-separated string",
+                description: "Sequence a to e, and join the characters with a pipe",
                 example: "seq char a e | str join '|'",
                 // TODO: it would be nice to test this example, but it currently breaks the input/output type tests
+                // result: Some(Value::test_string("a|b|c|d|e")),
                 result: None,
             },
         ]
@@ -65,7 +66,7 @@ impl Command for SeqChar {
 }
 
 fn is_single_character(ch: &str) -> bool {
-    ch.is_ascii() && ch.len() == 1 && ch.chars().all(char::is_alphabetic)
+    ch.is_ascii() && (ch.len() == 1)
 }
 
 fn seq_char(
@@ -79,7 +80,7 @@ fn seq_char(
     if !is_single_character(&start.item) {
         return Err(ShellError::GenericError {
             error: "seq char only accepts individual ASCII characters as parameters".into(),
-            msg: "should be 1 character long".into(),
+            msg: "input should be a single ASCII character".into(),
             span: Some(start.span),
             help: None,
             inner: vec![],
@@ -89,7 +90,7 @@ fn seq_char(
     if !is_single_character(&end.item) {
         return Err(ShellError::GenericError {
             error: "seq char only accepts individual ASCII characters as parameters".into(),
-            msg: "should be 1 character long".into(),
+            msg: "input should be a single ASCII character".into(),
             span: Some(end.span),
             help: None,
             inner: vec![],
@@ -115,18 +116,27 @@ fn seq_char(
 }
 
 fn run_seq_char(start_ch: char, end_ch: char, span: Span) -> Result<PipelineData, ShellError> {
-    let mut result_vec = vec![];
+    let start = start_ch as u8;
-    for current_ch in start_ch as u8..end_ch as u8 + 1 {
+    let end = end_ch as u8;
-        result_vec.push((current_ch as char).to_string())
+    let range = if start <= end {
-    }
+        start..=end
-
+    } else {
+        end..=start
+    };
+    let result_vec = if start <= end {
+        range.map(|c| (c as char).to_string()).collect::<Vec<_>>()
+    } else {
+        range
+            .rev()
+            .map(|c| (c as char).to_string())
+            .collect::<Vec<_>>()
+    };
     let result = result_vec
         .into_iter()
         .map(|x| Value::string(x, span))
         .collect::<Vec<Value>>();
     Ok(Value::list(result, span).into_pipeline_data())
 }
-
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -4,12 +4,55 @@ use nu_test_support::nu;
 fn fails_when_first_arg_is_multiple_chars() {
     let actual = nu!("seq char aa z");
 
-    assert!(actual.err.contains("should be 1 character long"));
+    assert!(actual
+        .err
+        .contains("input should be a single ASCII character"));
 }
 
 #[test]
 fn fails_when_second_arg_is_multiple_chars() {
     let actual = nu!("seq char a zz");
 
-    assert!(actual.err.contains("should be 1 character long"));
+    assert!(actual
+        .err
+        .contains("input should be a single ASCII character"));
+}
+
+#[test]
+fn generates_sequence_from_a_to_e() {
+    let actual = nu!("seq char a e | str join ''");
+
+    assert_eq!(actual.out, "abcde");
+}
+
+#[test]
+fn generates_sequence_from_e_to_a() {
+    let actual = nu!("seq char e a | str join ''");
+
+    assert_eq!(actual.out, "edcba");
+}
+
+#[test]
+fn fails_when_non_ascii_character_is_used_in_first_arg() {
+    let actual = nu!("seq char ñ z");
+
+    assert!(actual
+        .err
+        .contains("input should be a single ASCII character"));
+}
+
+#[test]
+fn fails_when_non_ascii_character_is_used_in_second_arg() {
+    let actual = nu!("seq char a ñ");
+
+    assert!(actual
+        .err
+        .contains("input should be a single ASCII character"));
+}
+
+#[test]
+fn joins_sequence_with_pipe() {
+    let actual = nu!("seq char a e | str join '|'");
+
+    assert_eq!(actual.out, "a|b|c|d|e");
 }