Merge branch 'main' into sort_sort.pl

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(

fuzz/Cargo.lock

@@ -527,18 +527,16 @@ pub(crate) fn color_name(
     #[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
     {
         // Skip checking capabilities if LS_COLORS=ca=:
-        let capabilities = style_manager
+        let has_capabilities = style_manager
             .colors
-            .style_for_indicator(Indicator::Capabilities);
-
-        let has_capabilities = if capabilities.is_none() {
-            false
-        } else {
-            uucore::fsxattr::has_acl(path.p_buf.as_path())
-        };
+            .has_explicit_style_for(Indicator::Capabilities)
+            && uucore::fsxattr::has_security_cap_acl(path.p_buf.as_path());
 
         // If the file has capabilities, use a specific style for `ca` (capabilities)
         if has_capabilities {
+            let capabilities = style_manager
+                .colors
+                .style_for_indicator(Indicator::Capabilities);
             return style_manager.apply_style(capabilities, Some(path), name, wrap);
         }
     }

src/uu/date/src/date.rs

@@ -2968,8 +2968,10 @@ fn display_item_long(
             output_display.extend(b".");
         } else if is_acl_set {
             output_display.extend(b"+");
+        } else {
+            output_display.extend(b" ");
         }
-        output_display.extend(b" ");
+
         output_display.extend_pad_left(&display_symlink_count(md), padding.link_count);
 
         if config.long.owner {
@@ -3626,6 +3628,19 @@ fn calculate_padding_collection(
             if config.context {
                 padding_collections.context = context_len.max(padding_collections.context);
             }
+
+            // correctly align columns when some files have capabilities/ACLs and others do not
+            {
+                #[cfg(any(not(unix), target_os = "android", target_os = "macos"))]
+                // TODO: See how Mac should work here
+                let is_acl_set = false;
+                #[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+                let is_acl_set = has_acl(item.display_name());
+                if context_len > 1 || is_acl_set {
+                    padding_collections.link_count += 1;
+                }
+            }
+
             if items.len() == 1usize {
                 padding_collections.size = 0usize;
                 padding_collections.major = 0usize;

src/uu/ls/src/colors.rs

@@ -193,9 +193,22 @@ struct Params {
 /// assert_eq!(find_last_contiguous_block_of_xs("aXbXcX"), None);
 /// ```
 fn find_last_contiguous_block_of_xs(s: &str) -> Option<(usize, usize)> {
-    let j = s.rfind("XXX")? + 3;
-    let i = s[..j].rfind(|c| c != 'X').map_or(0, |i| i + 1);
-    Some((i, j))
+    let bytes = s.as_bytes();
+
+    // Find the index of the last 'X'.
+    let end = bytes.iter().rposition(|&b| b == b'X')?;
+
+    // Walk left to find the start of the run of Xs that ends at `end`.
+    let mut start = end;
+    while start > 0 && bytes[start - 1] == b'X' {
+        start -= 1;
+    }
+
+    if end + 1 - start >= 3 {
+        Some((start, end + 1))
+    } else {
+        None
+    }
 }
 
 impl Params {

src/uu/ls/src/ls.rs

@@ -34,7 +34,12 @@ self_cell = { workspace = true }
 tempfile = { workspace = true }
 thiserror = { workspace = true }
 unicode-width = { workspace = true }
-uucore = { workspace = true, features = ["fs", "parser-size", "version-cmp"] }
+uucore = { workspace = true, features = [
+  "fs",
+  "parser-size",
+  "version-cmp",
+  "i18n-decimal",
+] }
 fluent = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]