Add %J and %Q format specifiers for compact date/time formatting (nushell#16588)

## Summary

Adds two new format specifiers to the `format date` and `into datetime`
commands that provide compact, human-readable date and time formatting
with improved modularity:

- **%J**: "Joined date" format - expands to `%Y%m%d` producing compact
dates like `20211022`
- **%Q**: "seQuential time" format - expands to `%H%M%S` producing
compact times like `200012`
- **Use case**: Ideal for flexible timestamp formatting, backup files,
logs, and sortable date/time components
- **Rationale**: Replaces single `%K` format with modular date/time
components after maintainer feedback
- **Flexibility**: Can be used individually or combined (e.g., `%J_%Q`,
`%J-%Q`) for custom formats
- **Consistency**: Both `format date` and `into datetime` use the same
format specifications

## Examples

```nushell
# Individual date formatting
"2021-10-22 20:00:12 +01:00" | format date "%J"
# Output: 20211022

# Individual time formatting
"2021-10-22 20:00:12 +01:00" | format date "%Q"
# Output: 200012

# Combined for full timestamp (equivalent to previous %K)
"2021-10-22 20:00:12 +01:00" | format date "%J_%Q"
# Output: 20211022_200012

# Parse compact date with into datetime
"20211022" | into datetime --format "%J"

# Parse compact time with into datetime
"200012" | into datetime --format "%Q"

# Round-trip functionality
"2021-10-22 20:00:12 +01:00" | format date "%J_%Q" | into datetime --format "%J_%Q" | format date "%J_%Q"
# Output: 20211022_200012

# Custom separators for different use cases
date now | format date "backup_%J-%Q.sql"
# Output: backup_20250918-131144.sql

# Date-only file naming
date now | format date "report_%J.txt"
# Output: report_20250918.txt
```

## Release notes summary - What our users need to know

The `format date` and `into datetime` commands now support two new
format specifiers for creating compact, sortable date and time
components:

- **%J** produces compact dates in `YYYYMMDD` format (e.g., `20250918`)
- **%Q** produces compact times in `HHMMSS` format (e.g., `131144`)

These can be used individually for date-only or time-only formatting, or
combined for full timestamps (`%J_%Q` produces `20250918_131144`),
providing more flexibility than a single combined format.

Perfect for:
- Backup file naming with custom separators
- Log file timestamps with flexible formatting
- Date-only or time-only compact representations
- Any scenario requiring sortable, human-readable date/time components

Both commands use the same format specifications, ensuring consistency
when parsing and formatting dates.

This addition is fully backward compatible - all existing format
specifiers continue to work unchanged.

## Implementation Details

- **Preprocessing approach**: Replaces `%J` with `%Y%m%d` and `%Q` with
`%H%M%S` before passing to chrono
- **Help integration**: Both specifiers appear in `format date -l` with
proper example generation
- **Letter choice rationale**:
- `%J` for "Joined date" - unused in major standards (lowercase %j is
day-of-year)
- `%Q` for "seQuential time" - unused in major time formatting standards
- **Modular design**: Users can format dates and times independently or
combine as needed
- **Consistent behavior**: Same format handling in both `format date`
and `into datetime`
- **No breaking changes**: Existing functionality remains unchanged
- **Performance**: Minimal overhead, only processes when specifiers are
used

## Test Results

- ✅ `format date -l` shows both new specifications correctly
- ✅ `%J` format produces expected date format `YYYYMMDD`
- ✅ `%Q` format produces expected time format `HHMMSS`
- ✅ `%J_%Q` combined produces expected timestamp format
- ✅ `into datetime --format "%J"` parses compact dates correctly
- ✅ `into datetime --format "%Q"` parses compact times correctly
- ✅ `into datetime --format "%J_%Q"` parses compact timestamps correctly
- ✅ Round-trip functionality between both commands works for all formats
- ✅ Individual and combined format specifiers work with current time
- ✅ No regression in existing format specifiers
- ✅ All existing tests pass with updated test suite
- ✅ Comprehensive test coverage for new functionality

---------

Co-authored-by: claude <[email protected]>
Co-authored-by: Claude <[email protected]>

Author: 3 people

crates/nu-command/src/conversions/into/datetime.rs

@@ -422,9 +422,15 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
 
     let parse_as_string = |val: &str| {
         match dateformat {
-            Some(dt_format) => match DateTime::parse_from_str(val, &dt_format.item.0) {
-                Ok(dt) => {
-                    match timezone {
+            Some(dt_format) => {
+                // Handle custom format specifiers for compact formats
+                let format_str = dt_format
+                    .item
+                    .0
+                    .replace("%J", "%Y%m%d") // %J for joined date (YYYYMMDD)
+                    .replace("%Q", "%H%M%S"); // %Q for sequential time (HHMMSS)
+                match DateTime::parse_from_str(val, &format_str) {
+                    Ok(dt) => match timezone {
                         None => Value::date(dt, head),
                         Some(Spanned { item, span }) => match item {
                             Zone::Utc => Value::date(dt, head),
@@ -464,10 +470,8 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
                                 *span,
                             ),
                         },
-                    }
-                }
-                Err(reason) => {
-                    parse_with_format(val, &dt_format.item.0, head).unwrap_or_else(|_| {
+                    },
+                    Err(reason) => parse_with_format(val, &format_str, head).unwrap_or_else(|_| {
                         Value::error(
                             ShellError::CantConvert {
                                 to_type: format!(
@@ -478,15 +482,15 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
                                 span: head,
                                 help: Some(
                                     "you can use `into datetime` without a format string to \
-                                     enable flexible parsing"
+                                         enable flexible parsing"
                                         .to_string(),
                                 ),
                             },
                             head,
                         )
-                    })
+                    }),
                 }
-            },
+            }
 
             // Tries to automatically parse the date
             // (i.e. without a format string)

crates/nu-command/src/date/utils.rs

@@ -247,6 +247,14 @@ pub(crate) fn generate_strftime_list(head: Span, show_parse_only_formats: bool)
             spec: "%s",
             description: "UNIX timestamp, the number of seconds since 1970-01-01",
         },
+        FormatSpecification {
+            spec: "%J",
+            description: "Joined date format. Same as %Y%m%d.",
+        },
+        FormatSpecification {
+            spec: "%Q",
+            description: "Sequential time format. Same as %H%M%S.",
+        },
         FormatSpecification {
             spec: "%t",
             description: "Literal tab (\\t).",
@@ -264,10 +272,17 @@ pub(crate) fn generate_strftime_list(head: Span, show_parse_only_formats: bool)
     let mut records = specifications
         .iter()
         .map(|s| {
+            // Handle custom format specifiers that aren't supported by chrono
+            let example = match s.spec {
+                "%J" => now.format("%Y%m%d").to_string(),
+                "%Q" => now.format("%H%M%S").to_string(),
+                _ => now.format(s.spec).to_string(),
+            };
+
             Value::record(
                 record! {
                     "Specification" => Value::string(s.spec, head),
-                    "Example" => Value::string(now.format(s.spec).to_string(), head),
+                    "Example" => Value::string(example, head),
                     "Description" => Value::string(s.description, head),
                 },
                 head,

crates/nu-command/src/strings/format/date.rs

@@ -199,7 +199,11 @@ where
     Tz::Offset: Display,
 {
     let mut formatter_buf = String::new();
-    let format = date_time.format_localized(formatter, locale);
+    // Handle custom format specifiers for compact formats
+    let processed_formatter = formatter
+        .replace("%J", "%Y%m%d") // %J for joined date (YYYYMMDD)
+        .replace("%Q", "%H%M%S"); // %Q for sequential time (HHMMSS)
+    let format = date_time.format_localized(&processed_formatter, locale);
 
     match formatter_buf.write_fmt(format_args!("{format}")) {
         Ok(_) => Value::string(formatter_buf, span),

crates/nu-command/tests/commands/date/format.rs

@@ -9,6 +9,43 @@ fn formatter_not_valid() {
     assert!(actual.err.contains("invalid format"));
 }
 
+#[test]
+fn test_j_q_format_specifiers() {
+    let actual = nu!(r#"
+        "2021-10-22 20:00:12 +01:00" | format date '%J_%Q'
+        "#);
+
+    assert_eq!(actual.out, "20211022_200012");
+}
+
+#[test]
+fn test_j_q_format_specifiers_current_time() {
+    let actual = nu!(r#"
+        date now | format date '%J_%Q' | str length
+        "#);
+
+    // Should be exactly 15 characters: YYYYMMDD_HHMMSS
+    assert_eq!(actual.out, "15");
+}
+
+#[test]
+fn test_j_format_specifier_date_only() {
+    let actual = nu!(r#"
+        "2021-10-22 20:00:12 +01:00" | format date '%J'
+        "#);
+
+    assert_eq!(actual.out, "20211022");
+}
+
+#[test]
+fn test_q_format_specifier_time_only() {
+    let actual = nu!(r#"
+        "2021-10-22 20:00:12 +01:00" | format date '%Q'
+        "#);
+
+    assert_eq!(actual.out, "200012");
+}
+
 #[test]
 fn fails_without_input() {
     let actual = nu!(r#"

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

@@ -119,3 +119,44 @@ fn into_datetime_from_record_incompatible_with_offset_flag() {
 
     assert!(actual.err.contains("nu::shell::incompatible_parameters"));
 }
+
+#[test]
+fn test_j_q_format_specifiers_into_datetime() {
+    let actual = nu!(r#"
+        "20211022_200012" | into datetime --format '%J_%Q'
+        "#);
+
+    // Check for the date components - the exact output format may vary
+    assert!(actual.out.contains("22 Oct 2021") || actual.out.contains("2021-10-22"));
+    assert!(actual.out.contains("20:00:12"));
+}
+
+#[test]
+fn test_j_q_format_specifiers_round_trip() {
+    let actual = nu!(r#"
+        "2021-10-22 20:00:12 +01:00" | format date '%J_%Q' | into datetime --format '%J_%Q' | format date '%J_%Q'
+        "#);
+
+    assert_eq!(actual.out, "20211022_200012");
+}
+
+#[test]
+fn test_j_format_specifier_date_only() {
+    let actual = nu!(r#"
+        "20211022" | into datetime --format '%J'
+        "#);
+
+    // Check for the date components - time should default to midnight
+    assert!(actual.out.contains("22 Oct 2021") || actual.out.contains("2021-10-22"));
+    assert!(actual.out.contains("00:00:00"));
+}
+
+#[test]
+fn test_q_format_specifier_time_only() {
+    let actual = nu!(r#"
+        "200012" | into datetime --format '%Q'
+        "#);
+
+    // Check for the time components - should parse as time with default date
+    assert!(actual.out.contains("20:00:12"));
+}