Merge branch 'main' into misc/close-stdout.sh

Author: mattsu2020

.github/workflows/CICD.yml

@@ -878,10 +878,14 @@ jobs:
       shell: bash
       run: |
         ## Package artifact(s)
-        # binary
+        # binaries
         cp 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
+        cp 'target/${{ matrix.job.target }}/release/uudoc${{ steps.vars.outputs.EXE_suffix }}' '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/' || :
         # `strip` binary (if needed)
-        if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' ; fi
+        if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then
+          "${{ steps.vars.outputs.STRIP }}" '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}'
+          "${{ steps.vars.outputs.STRIP }}" '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/uudoc' || :
+        fi
         # README and LICENSE
         # * spell-checker:ignore EADME ICENSE
         (shopt -s nullglob; for f in [R]"EADME"{,.*}; do cp $f '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/' ; done)

.github/workflows/benchmarks.yml

@@ -18,36 +18,38 @@ concurrency:
 
 jobs:
   benchmarks:
-    name: Run benchmarks (CodSpeed)
+    name: Run ${{ matrix.type }} benchmarks for ${{ matrix.package }} (CodSpeed)
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        benchmark-target:
-          - { package: uu_base64 }
-          - { package: uu_cksum }
-          - { package: uu_cp }
-          - { package: uu_cut }
-          - { package: uu_dd }
-          - { package: uu_df }
-          - { package: uu_du }
-          - { package: uu_expand }
-          - { package: uu_fold }
-          - { package: uu_join }
-          - { package: uu_ls }
-          - { package: uu_mv }
-          - { package: uu_nl }
-          - { package: uu_numfmt }
-          - { package: uu_rm }
-          - { package: uu_seq }
-          - { package: uu_shuf }
-          - { package: uu_sort }
-          - { package: uu_split }
-          - { package: uu_tsort }
-          - { package: uu_unexpand }
-          - { package: uu_uniq }
-          - { package: uu_wc }
-          - { package: uu_factor }
-          - { package: uu_date }
+        type: [performance, memory]
+        package: [
+          uu_base64,
+          uu_cksum,
+          uu_cp,
+          uu_cut,
+          uu_dd,
+          uu_df,
+          uu_du,
+          uu_expand,
+          uu_fold,
+          uu_join,
+          uu_ls,
+          uu_mv,
+          uu_nl,
+          uu_numfmt,
+          uu_rm,
+          uu_seq,
+          uu_shuf,
+          uu_sort,
+          uu_split,
+          uu_tsort,
+          uu_unexpand,
+          uu_uniq,
+          uu_wc,
+          uu_factor,
+          uu_date
+        ]
     steps:
       - uses: actions/checkout@v6
         with:
@@ -64,19 +66,23 @@ jobs:
         shell: bash
         run: cargo install cargo-codspeed --locked
 
-      - name: Build benchmarks for ${{ matrix.benchmark-target.package }}
+      - name: Build benchmarks for ${{ matrix.package }} (${{ matrix.type }})
         shell: bash
         run: |
-          echo "Building benchmarks for ${{ matrix.benchmark-target.package }}"
-          cargo codspeed build -p ${{ matrix.benchmark-target.package }}
+          echo "Building ${{ matrix.type }} benchmarks for ${{ matrix.package }}"
+          if [ "${{ matrix.type }}" = "memory" ]; then
+            cargo codspeed build -m analysis -p ${{ matrix.package }}
+          else
+            cargo codspeed build -p ${{ matrix.package }}
+          fi
 
-      - name: Run benchmarks for ${{ matrix.benchmark-target.package }}
+      - name: Run ${{ matrix.type }} benchmarks for ${{ matrix.package }}
         uses: CodSpeedHQ/action@v4
         env:
           CODSPEED_LOG: debug
         with:
-          mode: simulation
+          mode: ${{ matrix.type == 'memory' && 'memory' || 'simulation' }}
           run: |
-            echo "Running benchmarks for ${{ matrix.benchmark-target.package }}"
-            cargo codspeed run -p ${{ matrix.benchmark-target.package }} > /dev/null
+            echo "Running ${{ matrix.type }} benchmarks for ${{ matrix.package }}"
+            cargo codspeed run -p ${{ matrix.package }} > /dev/null
           token: ${{ secrets.CODSPEED_TOKEN }}

Cargo.lock

@@ -8,7 +8,7 @@
 mod locale;
 
 use clap::{Arg, ArgAction, Command};
-use jiff::fmt::strtime;
+use jiff::fmt::strtime::{self, BrokenDownTime, Config, PosixCustom};
 use jiff::tz::{TimeZone, TimeZoneDatabase};
 use jiff::{Timestamp, Zoned};
 use std::collections::HashMap;
@@ -431,21 +431,23 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let mut stdout = BufWriter::new(std::io::stdout().lock());
 
     // Format all the dates
+    let config = Config::new().custom(PosixCustom::new()).lenient(true);
     for date in dates {
         match date {
-            // TODO: Switch to lenient formatting.
-            Ok(date) => match strtime::format(format_string, &date) {
-                Ok(s) => writeln!(stdout, "{s}").map_err(|e| {
-                    USimpleError::new(1, translate!("date-error-write", "error" => e))
-                })?,
-                Err(e) => {
-                    let _ = stdout.flush();
-                    return Err(USimpleError::new(
-                        1,
-                        translate!("date-error-invalid-format", "format" => format_string, "error" => e),
-                    ));
+            Ok(date) => {
+                match BrokenDownTime::from(&date).to_string_with_config(&config, format_string) {
+                    Ok(s) => writeln!(stdout, "{s}").map_err(|e| {
+                        USimpleError::new(1, translate!("date-error-write", "error" => e))
+                    })?,
+                    Err(e) => {
+                        let _ = stdout.flush();
+                        return Err(USimpleError::new(
+                            1,
+                            translate!("date-error-invalid-format", "format" => format_string, "error" => e),
+                        ));
+                    }
                 }
-            },
+            }
             Err((input, _err)) => {
                 let _ = stdout.flush();
                 show!(USimpleError::new(

src/uu/date/src/date.rs

@@ -480,9 +480,8 @@ fn test_date_set_valid_4() {
 
 #[test]
 fn test_invalid_format_string() {
-    let result = new_ucmd!().arg("+%!").fails();
-    result.no_stdout();
-    assert!(result.stderr_str().starts_with("date: invalid format "));
+    // With lenient mode, invalid format sequences are output literally (like GNU date)
+    new_ucmd!().arg("+%!").succeeds().stdout_is("%!\n");
 }
 
 #[test]
@@ -1446,3 +1445,27 @@ fn test_date_locale_fr_french() {
         "Output should include timezone information, got: {stdout}"
     );
 }
+
+#[test]
+fn test_date_posix_format_specifiers() {
+    let cases = [
+        // %r: 12-hour time with zero-padded hour (08:17:48 AM, not 8:17:48 AM)
+        ("%r", "08:17:48 AM"),
+        // %x: locale date in MM/DD/YY format
+        ("%x", "01/19/97"),
+        // %X: locale time in HH:MM:SS format
+        ("%X", "08:17:48"),
+        // %:8z: invalid format (width between : and z) should output literally (lenient mode)
+        ("%:8z", "%:8z"),
+    ];
+
+    for (format, expected) in cases {
+        new_ucmd!()
+            .env("TZ", "UTC")
+            .arg("-d")
+            .arg("1997-01-19 08:17:48")
+            .arg(format!("+{format}"))
+            .succeeds()
+            .stdout_is(format!("{expected}\n"));
+    }
+}